typhoon-protocol 0.1.0

A sample implementation of TYPHOON protocol
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

//! Override map types for type-safe settings storage.

#[cfg(test)]
#[path = "../../tests/settings/override_map.rs"]
mod tests;

use std::collections::HashMap;
use std::ops::Add;

/// A typed setting key that carries its value type at compile time.
/// This ensures type-safe access to settings - you can only get/set
/// values of the correct type for each key.
pub struct Key<T> {
    pub name: &'static str,
    pub default: T,
}

impl<T> Key<T> {
    pub const fn new(name: &'static str, default: T) -> Self {
        Self {
            name,
            default,
        }
    }
}

/// Trait for types that can be stored in Settings.
/// Provides conversion to/from the internal SettingValue representation.
pub trait SettingType: Copy {
    fn from_value(v: SettingValue) -> Self;
    fn to_value(self) -> SettingValue;
    fn try_parse(s: &str) -> Option<Self>;
}

impl SettingType for i64 {
    #[inline]
    fn from_value(v: SettingValue) -> Self {
        match v {
            SettingValue::Signed(x) => x,
            _ => unreachable!("expected signed setting"),
        }
    }

    #[inline]
    fn to_value(self) -> SettingValue {
        SettingValue::Signed(self)
    }

    #[inline]
    fn try_parse(s: &str) -> Option<Self> {
        s.parse().ok()
    }
}

impl SettingType for u64 {
    #[inline]
    fn from_value(v: SettingValue) -> Self {
        match v {
            SettingValue::Unsigned(x) => x,
            _ => unreachable!("expected unsigned setting"),
        }
    }

    #[inline]
    fn to_value(self) -> SettingValue {
        SettingValue::Unsigned(self)
    }

    #[inline]
    fn try_parse(s: &str) -> Option<Self> {
        s.parse().ok()
    }
}

impl SettingType for f64 {
    #[inline]
    fn from_value(v: SettingValue) -> Self {
        match v {
            SettingValue::Float(x) => x,
            _ => unreachable!("expected float setting"),
        }
    }

    #[inline]
    fn to_value(self) -> SettingValue {
        SettingValue::Float(self)
    }

    #[inline]
    fn try_parse(s: &str) -> Option<Self> {
        s.parse().ok()
    }
}

/// Internal representation of a setting value.
#[derive(Copy, Clone, Debug)]
pub enum SettingValue {
    Signed(i64),
    Unsigned(u64),
    Float(f64),
}

impl Add for SettingValue {
    type Output = Self;

    #[inline]
    fn add(self, rhs: Self) -> Self::Output {
        match (self, rhs) {
            (SettingValue::Signed(a), SettingValue::Signed(b)) => SettingValue::Signed(a + b),
            (SettingValue::Unsigned(a), SettingValue::Unsigned(b)) => SettingValue::Unsigned(a + b),
            (SettingValue::Float(a), SettingValue::Float(b)) => SettingValue::Float(a + b),
            (SettingValue::Signed(a), SettingValue::Unsigned(b)) => SettingValue::Float(a as f64 + b as f64),
            (SettingValue::Unsigned(a), SettingValue::Signed(b)) => SettingValue::Float(a as f64 + b as f64),
            (SettingValue::Signed(a), SettingValue::Float(b)) | (SettingValue::Float(b), SettingValue::Signed(a)) => SettingValue::Float(a as f64 + b),
            (SettingValue::Unsigned(a), SettingValue::Float(b)) | (SettingValue::Float(b), SettingValue::Unsigned(a)) => SettingValue::Float(a as f64 + b),
        }
    }
}

/// Map of setting name to override value.
pub type OverrideMap = HashMap<&'static str, SettingValue>;