steamid 0.3.0

Simple SteamID type.
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121

#[cfg(feature = "redis-support")]
extern crate redis;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct SteamId(u64);

impl SteamId {
    pub fn from_u64(u: u64) -> SteamId {
        SteamId(u)
    }

    pub fn to_u64(self) -> u64 {
        self.0
    }

    pub fn get_account_id(self) -> u32 {
        (self.0 & 0xFFFFFFFF) as u32 
    }

    pub fn get_instance(self) -> u32 {
        ((self.0 >> 32) & 0xFFFFF) as u32
    }

    pub fn get_type(self) -> Option<AccountType> {
        use AccountType::*;

        let int_rep = (self.0 >> 52) & 0xF;
        match int_rep {
            0 => Some(Invalid),
            1 => Some(Individual),
            2 => Some(Multiseat),
            3 => Some(GameServer),
            4 => Some(AnonGameServer),
            5 => Some(Pending),
            6 => Some(ContentServer),
            7 => Some(Clan),
            8 => Some(Chat),
            9 => Some(SuperSeeder),
            10 => Some(AnonUser),
            _ => None
        }
    }

    pub fn get_universe(self) -> Option<Universe> {
        use Universe::*;

        let int_rep = (self.0 >> 56) & 0xFF;
        match int_rep {
            0 => Some(Invalid),
            1 => Some(Public),
            2 => Some(Beta),
            3 => Some(Internal),
            4 => Some(Dev),
            _ => None
        }
    }
}

#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum AccountType {
    Invalid = 0,
    Individual = 1,
    Multiseat = 2,
    GameServer = 3,
    AnonGameServer = 4,
    Pending = 5,
    ContentServer = 6,
    Clan = 7,
    Chat = 8,
    SuperSeeder = 9,
    AnonUser = 10
}


#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum Universe {
    Invalid = 0,
    Public = 1,
    Beta = 2,
    Internal = 3,
    Dev = 4
}

#[cfg(feature = "redis-support")]
impl redis::FromRedisValue for SteamId {
    fn from_redis_value(v: &redis::Value) -> redis::RedisResult<SteamId> {
        use std::convert::From;
        use std::str::FromStr;
        use redis::Value::*;

        match *v {
            Int(i) => {
                Ok(SteamId::from_u64(i as u64))
            },
            Data(ref data) => {
                let string = std::str::from_utf8(data).ok();
                let number = string.and_then(|string| u64::from_str(string).ok());

                match number {
                    Some(number) => {
                        Ok(SteamId::from_u64(number))
                    },
                    None => {
                        Err(From::from((redis::ErrorKind::TypeError, "Not numeric")))
                    }
                }
            },
            _ => {
                Err(From::from((redis::ErrorKind::TypeError, "Not numeric")))
            }
        }
    }
}

#[cfg(feature = "redis-support")]
impl redis::ToRedisArgs for SteamId {
    fn to_redis_args(&self) -> Vec<Vec<u8>> {
        let s = self.0.to_string();
        vec![s.as_bytes().to_vec()]
    }
}