Skip to main content

tanzim_source/
impls.rs

1//! [`From`] and [`TryFrom`] conversions for [`Source`], [`SourceBuilder`], and [`OptionValue`].
2
3use crate::{Error, OptionValue, Options, ParseError, Source, SourceBuilder};
4use std::borrow::Cow;
5use std::collections::HashMap;
6
7impl From<Source> for SourceBuilder {
8    fn from(value: Source) -> Self {
9        Self {
10            source: Some(value.source().to_string()),
11            options: value.options().clone(),
12            resource: value.resource().to_string(),
13            resource_colon: value.resource_colon(),
14        }
15    }
16}
17
18impl TryFrom<&str> for SourceBuilder {
19    type Error = Error;
20
21    fn try_from(value: &str) -> Result<Self, Self::Error> {
22        Ok(Source::parse(value)?.into())
23    }
24}
25
26impl TryFrom<String> for SourceBuilder {
27    type Error = Error;
28
29    fn try_from(value: String) -> Result<Self, Self::Error> {
30        Self::try_from(value.as_str())
31    }
32}
33
34impl TryFrom<&String> for SourceBuilder {
35    type Error = Error;
36
37    fn try_from(value: &String) -> Result<Self, Self::Error> {
38        Self::try_from(value.as_str())
39    }
40}
41
42impl TryFrom<Cow<'_, str>> for SourceBuilder {
43    type Error = Error;
44
45    fn try_from(value: Cow<'_, str>) -> Result<Self, Self::Error> {
46        Self::try_from(value.as_ref())
47    }
48}
49
50impl From<bool> for OptionValue {
51    fn from(value: bool) -> Self {
52        Self::Bool(value)
53    }
54}
55
56impl From<i64> for OptionValue {
57    fn from(value: i64) -> Self {
58        Self::Integer(value)
59    }
60}
61
62impl From<i32> for OptionValue {
63    fn from(value: i32) -> Self {
64        Self::Integer(value as i64)
65    }
66}
67
68impl From<i16> for OptionValue {
69    fn from(value: i16) -> Self {
70        Self::Integer(value as i64)
71    }
72}
73
74impl From<i8> for OptionValue {
75    fn from(value: i8) -> Self {
76        Self::Integer(value as i64)
77    }
78}
79
80impl From<u64> for OptionValue {
81    fn from(value: u64) -> Self {
82        Self::Integer(value as i64)
83    }
84}
85
86impl From<u32> for OptionValue {
87    fn from(value: u32) -> Self {
88        Self::Integer(value as i64)
89    }
90}
91
92impl From<u16> for OptionValue {
93    fn from(value: u16) -> Self {
94        Self::Integer(value as i64)
95    }
96}
97
98impl From<u8> for OptionValue {
99    fn from(value: u8) -> Self {
100        Self::Integer(value as i64)
101    }
102}
103
104impl From<isize> for OptionValue {
105    fn from(value: isize) -> Self {
106        Self::Integer(value as i64)
107    }
108}
109
110impl From<usize> for OptionValue {
111    fn from(value: usize) -> Self {
112        Self::Integer(value as i64)
113    }
114}
115
116impl From<f64> for OptionValue {
117    fn from(value: f64) -> Self {
118        Self::Float(value)
119    }
120}
121
122impl From<f32> for OptionValue {
123    fn from(value: f32) -> Self {
124        Self::Float(value as f64)
125    }
126}
127
128impl From<&str> for OptionValue {
129    fn from(value: &str) -> Self {
130        Self::String(value.to_string())
131    }
132}
133
134impl From<String> for OptionValue {
135    fn from(value: String) -> Self {
136        Self::String(value)
137    }
138}
139
140impl From<&String> for OptionValue {
141    fn from(value: &String) -> Self {
142        Self::String(value.clone())
143    }
144}
145
146impl<T: Into<OptionValue>> From<Vec<T>> for OptionValue {
147    fn from(value: Vec<T>) -> Self {
148        Self::List(value.into_iter().map(Into::into).collect())
149    }
150}
151
152impl<T: Into<OptionValue> + Clone> From<&[T]> for OptionValue {
153    fn from(value: &[T]) -> Self {
154        Self::List(value.iter().cloned().map(Into::into).collect())
155    }
156}
157
158impl From<Options> for OptionValue {
159    fn from(value: Options) -> Self {
160        Self::Map(value)
161    }
162}
163
164impl<K: Into<String>, V: Into<OptionValue>> From<HashMap<K, V>> for OptionValue {
165    fn from(value: HashMap<K, V>) -> Self {
166        let mut options = Options::default();
167        for (key, value) in value {
168            options.insert(key, value);
169        }
170        Self::Map(options)
171    }
172}
173
174impl std::str::FromStr for Source {
175    type Err = ParseError;
176
177    fn from_str(value: &str) -> Result<Self, Self::Err> {
178        Self::parse(value)
179    }
180}
181
182impl TryFrom<&str> for Source {
183    type Error = ParseError;
184
185    fn try_from(value: &str) -> Result<Self, Self::Error> {
186        Self::parse(value)
187    }
188}
189
190impl TryFrom<String> for Source {
191    type Error = ParseError;
192
193    fn try_from(value: String) -> Result<Self, Self::Error> {
194        Self::parse(&value)
195    }
196}
197
198impl TryFrom<&String> for Source {
199    type Error = ParseError;
200
201    fn try_from(value: &String) -> Result<Self, Self::Error> {
202        Self::parse(value)
203    }
204}
205
206impl TryFrom<Cow<'_, str>> for Source {
207    type Error = ParseError;
208
209    fn try_from(value: Cow<'_, str>) -> Result<Self, Self::Error> {
210        Self::parse(&value)
211    }
212}