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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
use std::convert::{From, TryFrom};
// Variant for a configuration Value
// The additional Option<String> is used for the textual representation of the
// underlying type (to cache the string generation) but only if requested.
pub enum Value {
String(String),
Integer(i64, Option<String>),
Float(f64, Option<String>),
Boolean(bool, Option<String>),
}
// Conversion from type into variant
impl From<String> for Value {
fn from(value: String) -> Value {
Value::String(value)
}
}
impl<'a> From<&'a str> for Value {
fn from(value: &'a str) -> Value {
Value::String(value.into())
}
}
impl From<i64> for Value {
fn from(value: i64) -> Value {
Value::Integer(value, None)
}
}
impl From<f64> for Value {
fn from(value: f64) -> Value {
Value::Float(value, None)
}
}
impl From<bool> for Value {
fn from(value: bool) -> Value {
Value::Boolean(value, None)
}
}
// Conversion from variant into type
impl<'a> TryFrom<&'a mut Value> for &'a str {
type Err = ();
fn try_from(value: &mut Value) -> Result<&str, ()> {
// When converting a non-string value into a string;
// cache the conversion and return a reference
if let Value::String(ref value) = *value {
Ok(value)
} else if let Value::Integer(value, ref mut text) = *value {
if let Some(ref text) = *text {
Ok(text)
} else {
*text = Some(value.to_string());
Ok(text.as_ref().unwrap())
}
} else if let Value::Float(value, ref mut text) = *value {
if let Some(ref text) = *text {
Ok(text)
} else {
*text = Some(value.to_string());
Ok(text.as_ref().unwrap())
}
} else if let Value::Boolean(value, ref mut text) = *value {
if let Some(ref text) = *text {
Ok(text)
} else {
*text = Some(value.to_string());
Ok(text.as_ref().unwrap())
}
} else {
Err(())
}
}
}
impl<'a> TryFrom<&'a mut Value> for i64 {
type Err = ();
fn try_from(value: &mut Value) -> Result<i64, ()> {
if let Value::Integer(value, ..) = *value {
Ok(value)
} else if let Value::String(ref value) = *value {
value.parse().map_err(|_| {
// Drop specific error
})
} else if let Value::Boolean(value, ..) = *value {
Ok(if value { 1 } else { 0 })
} else if let Value::Float(value, ..) = *value {
Ok(value.round() as i64)
} else {
Err(())
}
}
}
impl<'a> TryFrom<&'a mut Value> for f64 {
type Err = ();
fn try_from(value: &mut Value) -> Result<f64, ()> {
if let Value::Float(value, ..) = *value {
Ok(value)
} else if let Value::String(ref value) = *value {
value.parse().map_err(|_| {
// Drop specific error
})
} else if let Value::Integer(value, ..) = *value {
Ok(value as f64)
} else if let Value::Boolean(value, ..) = *value {
Ok(if value { 1.0 } else { 0.0 })
} else {
Err(())
}
}
}
impl<'a> TryFrom<&'a mut Value> for bool {
type Err = ();
fn try_from(value: &mut Value) -> Result<bool, ()> {
if let Value::Boolean(value, ..) = *value {
Ok(value)
} else if let Value::String(ref value) = *value {
Ok(match value.to_lowercase().as_ref() {
"1" | "true" | "on" | "yes" => true,
_ => false,
})
} else if let Value::Integer(value, ..) = *value {
Ok(value != 0)
} else if let Value::Float(value, ..) = *value {
Ok(value != 0.0)
} else {
Err(())
}
}
}
|
