1use std::iter::FromIterator;
2use std::str::FromStr;
3
4use toml_datetime::{Date, Datetime, Time};
5
6use crate::key::Key;
7use crate::repr::{Decor, Formatted};
8use crate::{Array, InlineTable, InternalString, RawString};
9
10/// Representation of a TOML Value (as part of a Key/Value Pair).
11#[derive(Debug, Clone)]
12pub enum Value {
13 /// A string value.
14 String(Formatted<String>),
15 /// A 64-bit integer value.
16 Integer(Formatted<i64>),
17 /// A 64-bit float value.
18 Float(Formatted<f64>),
19 /// A boolean value.
20 Boolean(Formatted<bool>),
21 /// An RFC 3339 formatted date-time with offset.
22 Datetime(Formatted<Datetime>),
23 /// An inline array of values.
24 Array(Array),
25 /// An inline table of key/value pairs.
26 InlineTable(InlineTable),
27}
28
29/// Downcasting
30impl Value {
31 /// Text description of value type
32 pub fn type_name(&self) -> &'static str {
33 match self {
34 Value::String(..) => "string",
35 Value::Integer(..) => "integer",
36 Value::Float(..) => "float",
37 Value::Boolean(..) => "boolean",
38 Value::Datetime(..) => "datetime",
39 Value::Array(..) => "array",
40 Value::InlineTable(..) => "inline table",
41 }
42 }
43
44 /// Casts `self` to str.
45 pub fn as_str(&self) -> Option<&str> {
46 match *self {
47 Value::String(ref value) => Some(value.value()),
48 _ => None,
49 }
50 }
51
52 /// Returns true if `self` is a string.
53 pub fn is_str(&self) -> bool {
54 self.as_str().is_some()
55 }
56
57 /// Casts `self` to integer.
58 pub fn as_integer(&self) -> Option<i64> {
59 match *self {
60 Value::Integer(ref value) => Some(*value.value()),
61 _ => None,
62 }
63 }
64
65 /// Returns true if `self` is an integer.
66 pub fn is_integer(&self) -> bool {
67 self.as_integer().is_some()
68 }
69
70 /// Casts `self` to float.
71 pub fn as_float(&self) -> Option<f64> {
72 match *self {
73 Value::Float(ref value) => Some(*value.value()),
74 _ => None,
75 }
76 }
77
78 /// Returns true if `self` is a float.
79 pub fn is_float(&self) -> bool {
80 self.as_float().is_some()
81 }
82
83 /// Casts `self` to boolean.
84 pub fn as_bool(&self) -> Option<bool> {
85 match *self {
86 Value::Boolean(ref value) => Some(*value.value()),
87 _ => None,
88 }
89 }
90
91 /// Returns true if `self` is a boolean.
92 pub fn is_bool(&self) -> bool {
93 self.as_bool().is_some()
94 }
95
96 /// Casts `self` to date-time.
97 pub fn as_datetime(&self) -> Option<&Datetime> {
98 match *self {
99 Value::Datetime(ref value) => Some(value.value()),
100 _ => None,
101 }
102 }
103
104 /// Returns true if `self` is a date-time.
105 pub fn is_datetime(&self) -> bool {
106 self.as_datetime().is_some()
107 }
108
109 /// Casts `self` to array.
110 pub fn as_array(&self) -> Option<&Array> {
111 match *self {
112 Value::Array(ref value) => Some(value),
113 _ => None,
114 }
115 }
116
117 /// Casts `self` to mutable array.
118 pub fn as_array_mut(&mut self) -> Option<&mut Array> {
119 match *self {
120 Value::Array(ref mut value) => Some(value),
121 _ => None,
122 }
123 }
124
125 /// Returns true if `self` is an array.
126 pub fn is_array(&self) -> bool {
127 self.as_array().is_some()
128 }
129
130 /// Casts `self` to inline table.
131 pub fn as_inline_table(&self) -> Option<&InlineTable> {
132 match *self {
133 Value::InlineTable(ref value) => Some(value),
134 _ => None,
135 }
136 }
137
138 /// Casts `self` to mutable inline table.
139 pub fn as_inline_table_mut(&mut self) -> Option<&mut InlineTable> {
140 match *self {
141 Value::InlineTable(ref mut value) => Some(value),
142 _ => None,
143 }
144 }
145
146 /// Returns true if `self` is an inline table.
147 pub fn is_inline_table(&self) -> bool {
148 self.as_inline_table().is_some()
149 }
150}
151
152impl Value {
153 /// Get the decoration of the value.
154 /// # Example
155 /// ```rust
156 /// let v = toml_edit::Value::from(true);
157 /// assert_eq!(v.decor().suffix(), None);
158 ///```
159 pub fn decor_mut(&mut self) -> &mut Decor {
160 match self {
161 Value::String(f) => f.decor_mut(),
162 Value::Integer(f) => f.decor_mut(),
163 Value::Float(f) => f.decor_mut(),
164 Value::Boolean(f) => f.decor_mut(),
165 Value::Datetime(f) => f.decor_mut(),
166 Value::Array(a) => a.decor_mut(),
167 Value::InlineTable(t) => t.decor_mut(),
168 }
169 }
170
171 /// Get the decoration of the value.
172 /// # Example
173 /// ```rust
174 /// let v = toml_edit::Value::from(true);
175 /// assert_eq!(v.decor().suffix(), None);
176 ///```
177 pub fn decor(&self) -> &Decor {
178 match *self {
179 Value::String(ref f) => f.decor(),
180 Value::Integer(ref f) => f.decor(),
181 Value::Float(ref f) => f.decor(),
182 Value::Boolean(ref f) => f.decor(),
183 Value::Datetime(ref f) => f.decor(),
184 Value::Array(ref a) => a.decor(),
185 Value::InlineTable(ref t) => t.decor(),
186 }
187 }
188
189 /// Sets the prefix and the suffix for value.
190 /// # Example
191 /// ```rust
192 /// # #[cfg(feature = "display")] {
193 /// let mut v = toml_edit::Value::from(42);
194 /// assert_eq!(&v.to_string(), "42");
195 /// let d = v.decorated(" ", " ");
196 /// assert_eq!(&d.to_string(), " 42 ");
197 /// # }
198 /// ```
199 pub fn decorated(mut self, prefix: impl Into<RawString>, suffix: impl Into<RawString>) -> Self {
200 self.decorate(prefix, suffix);
201 self
202 }
203
204 pub(crate) fn decorate(&mut self, prefix: impl Into<RawString>, suffix: impl Into<RawString>) {
205 let decor = self.decor_mut();
206 *decor = Decor::new(prefix, suffix);
207 }
208
209 /// The location within the original document
210 ///
211 /// This generally requires an [`ImDocument`][crate::ImDocument].
212 pub fn span(&self) -> Option<std::ops::Range<usize>> {
213 match self {
214 Value::String(f) => f.span(),
215 Value::Integer(f) => f.span(),
216 Value::Float(f) => f.span(),
217 Value::Boolean(f) => f.span(),
218 Value::Datetime(f) => f.span(),
219 Value::Array(a) => a.span(),
220 Value::InlineTable(t) => t.span(),
221 }
222 }
223
224 pub(crate) fn despan(&mut self, input: &str) {
225 match self {
226 Value::String(f) => f.despan(input),
227 Value::Integer(f) => f.despan(input),
228 Value::Float(f) => f.despan(input),
229 Value::Boolean(f) => f.despan(input),
230 Value::Datetime(f) => f.despan(input),
231 Value::Array(a) => a.despan(input),
232 Value::InlineTable(t) => t.despan(input),
233 }
234 }
235}
236
237#[cfg(feature = "parse")]
238impl FromStr for Value {
239 type Err = crate::TomlError;
240
241 /// Parses a value from a &str
242 fn from_str(s: &str) -> Result<Self, Self::Err> {
243 crate::parser::parse_value(raw:s)
244 }
245}
246
247impl<'b> From<&'b Value> for Value {
248 fn from(s: &'b Value) -> Self {
249 s.clone()
250 }
251}
252
253impl<'b> From<&'b str> for Value {
254 fn from(s: &'b str) -> Self {
255 s.to_owned().into()
256 }
257}
258
259impl<'b> From<&'b String> for Value {
260 fn from(s: &'b String) -> Self {
261 s.to_owned().into()
262 }
263}
264
265impl From<String> for Value {
266 fn from(s: String) -> Self {
267 Value::String(Formatted::new(s))
268 }
269}
270
271impl<'b> From<&'b InternalString> for Value {
272 fn from(s: &'b InternalString) -> Self {
273 s.as_str().into()
274 }
275}
276
277impl From<InternalString> for Value {
278 fn from(s: InternalString) -> Self {
279 s.as_str().into()
280 }
281}
282
283impl From<i64> for Value {
284 fn from(i: i64) -> Self {
285 Value::Integer(Formatted::new(i))
286 }
287}
288
289impl From<f64> for Value {
290 fn from(f: f64) -> Self {
291 // Preserve sign of NaN. It may get written to TOML as `-nan`.
292 Value::Float(Formatted::new(f))
293 }
294}
295
296impl From<bool> for Value {
297 fn from(b: bool) -> Self {
298 Value::Boolean(Formatted::new(b))
299 }
300}
301
302impl From<Datetime> for Value {
303 fn from(d: Datetime) -> Self {
304 Value::Datetime(Formatted::new(d))
305 }
306}
307
308impl From<Date> for Value {
309 fn from(d: Date) -> Self {
310 let d: Datetime = d.into();
311 d.into()
312 }
313}
314
315impl From<Time> for Value {
316 fn from(d: Time) -> Self {
317 let d: Datetime = d.into();
318 d.into()
319 }
320}
321
322impl From<Array> for Value {
323 fn from(array: Array) -> Self {
324 Value::Array(array)
325 }
326}
327
328impl From<InlineTable> for Value {
329 fn from(table: InlineTable) -> Self {
330 Value::InlineTable(table)
331 }
332}
333
334impl<V: Into<Value>> FromIterator<V> for Value {
335 fn from_iter<I>(iter: I) -> Self
336 where
337 I: IntoIterator<Item = V>,
338 {
339 let array: Array = iter.into_iter().collect();
340 Value::Array(array)
341 }
342}
343
344impl<K: Into<Key>, V: Into<Value>> FromIterator<(K, V)> for Value {
345 fn from_iter<I>(iter: I) -> Self
346 where
347 I: IntoIterator<Item = (K, V)>,
348 {
349 let table: InlineTable = iter.into_iter().collect();
350 Value::InlineTable(table)
351 }
352}
353
354#[cfg(feature = "display")]
355impl std::fmt::Display for Value {
356 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
357 crate::encode::encode_value(self, buf:f, input:None, ("", ""))
358 }
359}
360
361// `key1 = value1`
362pub(crate) const DEFAULT_VALUE_DECOR: (&str, &str) = (" ", "");
363// `{ key = value }`
364pub(crate) const DEFAULT_TRAILING_VALUE_DECOR: (&str, &str) = (" ", " ");
365// `[value1, value2]`
366pub(crate) const DEFAULT_LEADING_VALUE_DECOR: (&str, &str) = ("", "");
367
368#[cfg(test)]
369#[cfg(feature = "parse")]
370#[cfg(feature = "display")]
371mod tests {
372 use super::*;
373
374 #[test]
375 fn from_iter_formatting() {
376 let features = ["node".to_owned(), "mouth".to_owned()];
377 let features: Value = features.iter().cloned().collect();
378 assert_eq!(features.to_string(), r#"["node", "mouth"]"#);
379 }
380}
381
382#[test]
383#[cfg(feature = "parse")]
384#[cfg(feature = "display")]
385fn string_roundtrip() {
386 Value::from("hello").to_string().parse::<Value>().unwrap();
387}
388