warframe 9.0.1

An async crate to wrap Warframe's Worldstate API.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use core::str;
use std::fmt;

use serde::{
    Deserialize,
    Deserializer,
    Serialize,
    de,
    de::Visitor,
};

#[derive(Debug, Clone)]
pub struct PlatformName {
    /// name
    pub name: String,

    /// platform
    pub platform: Platform,
}

impl<'de> Deserialize<'de> for PlatformName {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct SplitFieldVisitor;

        impl Visitor<'_> for SplitFieldVisitor {
            type Value = PlatformName;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("a string with a byte code for platform at the end")
            }

            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
            where
                E: de::Error,
            {
                let mut chars = value.chars();
                let platform_char = chars
                    .next_back()
                    .ok_or_else(|| E::custom("value cannot be empty"))?;

                let mut platform = Platform::from_char(platform_char);

                let mut name = chars.collect();
                if platform.is_none() {
                    // Older profiles don't have this field, so we default to PC
                    platform = Some(Platform::PC);
                    name = format!("{name}{platform_char}");
                }

                Ok(PlatformName {
                    name,
                    platform: platform.unwrap(),
                })
            }
        }

        deserializer.deserialize_str(SplitFieldVisitor)
    }
}

#[derive(Serialize, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Platform {
    PC,
    Xbox,
    PS,
    Switch,
    Mobile,
}

impl Platform {
    #[must_use]
    pub fn to_char(self) -> char {
        match self {
            Self::PC => '\u{e000}',
            Self::Xbox => '\u{e001}',
            Self::PS => '\u{e002}',
            Self::Switch => '\u{e003}',
            Self::Mobile => '\u{e004}',
        }
    }

    #[must_use]
    pub fn to_sub_domain(self) -> &'static str {
        match self {
            Self::PC => "content",
            Self::Xbox => "content-xb1",
            Self::PS => "content-ps4",
            Self::Switch => "content-swi",
            Self::Mobile => "content-mob",
        }
    }

    #[must_use]
    pub fn from_char(char: char) -> Option<Self> {
        match char {
            '\u{e000}' => Some(Self::PC),
            '\u{e001}' => Some(Self::Xbox),
            '\u{e002}' => Some(Self::PS),
            '\u{e003}' => Some(Self::Switch),
            '\u{e004}' => Some(Self::Mobile),
            _ => None,
        }
    }
}