record_query/value/
mod.rs

1use crate::error;
2
3use ordered_float;
4use serde;
5use serde_json;
6use std::collections;
7use std::fmt;
8use std::io;
9
10pub mod avro;
11pub mod cbor;
12pub mod csv;
13pub mod json;
14pub mod messagepack;
15pub mod protobuf;
16pub mod raw;
17pub mod toml;
18pub mod yaml;
19
20#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
21pub enum Value {
22    Unit,
23    Bool(bool),
24
25    I8(i8),
26    I16(i16),
27    I32(i32),
28    I64(i64),
29
30    U8(u8),
31    U16(u16),
32    U32(u32),
33    U64(u64),
34
35    F32(ordered_float::OrderedFloat<f32>),
36    F64(ordered_float::OrderedFloat<f64>),
37
38    Char(char),
39    String(String),
40    Bytes(Vec<u8>),
41
42    Sequence(Vec<Value>),
43    // TODO: Use a container that preserves insertion order
44    Map(collections::BTreeMap<Value, Value>),
45}
46
47pub trait Source {
48    fn read(&mut self) -> error::Result<Option<Value>>;
49}
50
51pub trait Sink {
52    fn write(&mut self, v: Value) -> error::Result<()>;
53}
54
55struct ValueVisitor;
56
57impl Value {
58    pub fn to_json<W>(&self, mut w: &mut W) -> error::Result<()>
59    where
60        W: io::Write,
61    {
62        serde_json::to_writer(&mut w, self)?;
63        w.write_all(&[10])?; // Newline
64        Ok(())
65    }
66
67    pub fn from_f32(v: f32) -> Self {
68        Self::F32(ordered_float::OrderedFloat(v))
69    }
70
71    pub fn from_f64(v: f64) -> Self {
72        Self::F64(ordered_float::OrderedFloat(v))
73    }
74}
75
76impl fmt::Display for Value {
77    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
78        match *self {
79            Self::Unit => write!(f, "()"),
80            Self::Bool(v) => write!(f, "{}", v),
81
82            Self::I8(v) => write!(f, "{}", v),
83            Self::I16(v) => write!(f, "{}", v),
84            Self::I32(v) => write!(f, "{}", v),
85            Self::I64(v) => write!(f, "{}", v),
86
87            Self::U8(v) => write!(f, "{}", v),
88            Self::U16(v) => write!(f, "{}", v),
89            Self::U32(v) => write!(f, "{}", v),
90            Self::U64(v) => write!(f, "{}", v),
91
92            Self::F32(v) => write!(f, "{}", v),
93            Self::F64(v) => write!(f, "{}", v),
94
95            Self::Char(v) => write!(f, "{}", v),
96            Self::String(ref v) => write!(f, "{}", v),
97            Self::Bytes(ref v) => {
98                for b in v {
99                    write!(f, "{:02x}", b)?;
100                }
101                Ok(())
102            }
103
104            Self::Sequence(ref seq) => {
105                let mut needs_sep = false;
106                write!(f, "[")?;
107                for v in seq {
108                    if needs_sep {
109                        write!(f, ", ")?;
110                    }
111                    write!(f, "{}", v)?;
112                    needs_sep = true;
113                }
114                write!(f, "]")?;
115                Ok(())
116            }
117            Self::Map(ref map) => {
118                let mut needs_sep = false;
119                write!(f, "{{")?;
120                for (k, v) in map {
121                    if needs_sep {
122                        write!(f, ", ")?;
123                    }
124                    write!(f, "{}: {}", k, v)?;
125                    needs_sep = true;
126                }
127                write!(f, "}}")?;
128                Ok(())
129            }
130        }
131    }
132}
133
134impl serde::ser::Serialize for Value {
135    #[inline]
136    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
137    where
138        S: serde::ser::Serializer,
139    {
140        match *self {
141            Self::Unit => ().serialize(s),
142            Self::Bool(v) => v.serialize(s),
143
144            Self::I8(v) => v.serialize(s),
145            Self::I16(v) => v.serialize(s),
146            Self::I32(v) => v.serialize(s),
147            Self::I64(v) => v.serialize(s),
148
149            Self::U8(v) => v.serialize(s),
150            Self::U16(v) => v.serialize(s),
151            Self::U32(v) => v.serialize(s),
152            Self::U64(v) => v.serialize(s),
153
154            Self::F32(v) => v.serialize(s),
155            Self::F64(v) => v.serialize(s),
156
157            Self::Char(v) => v.serialize(s),
158            Self::String(ref v) => v.serialize(s),
159            Self::Bytes(ref v) => v.serialize(s),
160
161            Self::Sequence(ref v) => v.serialize(s),
162            Self::Map(ref v) => v.serialize(s),
163        }
164    }
165}
166
167impl<'de> serde::de::Deserialize<'de> for Value {
168    #[inline]
169    fn deserialize<D>(d: D) -> Result<Self, D::Error>
170    where
171        D: serde::Deserializer<'de>,
172    {
173        d.deserialize_any(ValueVisitor)
174    }
175}
176
177impl<'de> serde::de::Visitor<'de> for ValueVisitor {
178    type Value = Value;
179
180    #[inline]
181    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
182        write!(f, "any value")
183    }
184
185    #[inline]
186    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
187    where
188        E: serde::de::Error,
189    {
190        Ok(Value::Bool(v))
191    }
192
193    #[inline]
194    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
195    where
196        E: serde::de::Error,
197    {
198        Ok(Value::I8(v))
199    }
200
201    #[inline]
202    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
203    where
204        E: serde::de::Error,
205    {
206        Ok(Value::I16(v))
207    }
208
209    #[inline]
210    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
211    where
212        E: serde::de::Error,
213    {
214        Ok(Value::I32(v))
215    }
216
217    #[inline]
218    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
219    where
220        E: serde::de::Error,
221    {
222        Ok(Value::I64(v))
223    }
224
225    #[inline]
226    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
227    where
228        E: serde::de::Error,
229    {
230        Ok(Value::U8(v))
231    }
232
233    #[inline]
234    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
235    where
236        E: serde::de::Error,
237    {
238        Ok(Value::U16(v))
239    }
240
241    #[inline]
242    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
243    where
244        E: serde::de::Error,
245    {
246        Ok(Value::U32(v))
247    }
248
249    #[inline]
250    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
251    where
252        E: serde::de::Error,
253    {
254        Ok(Value::U64(v))
255    }
256
257    #[inline]
258    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
259    where
260        E: serde::de::Error,
261    {
262        Ok(Value::from_f32(v))
263    }
264
265    #[inline]
266    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
267    where
268        E: serde::de::Error,
269    {
270        Ok(Value::from_f64(v))
271    }
272
273    #[inline]
274    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
275    where
276        E: serde::de::Error,
277    {
278        Ok(Value::Char(v))
279    }
280
281    #[inline]
282    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
283    where
284        E: serde::de::Error,
285    {
286        Ok(Value::String(v.to_owned()))
287    }
288
289    #[inline]
290    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
291    where
292        E: serde::de::Error,
293    {
294        Ok(Value::String(v))
295    }
296
297    #[inline]
298    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
299    where
300        E: serde::de::Error,
301    {
302        Ok(Value::Bytes(v.to_vec()))
303    }
304
305    #[inline]
306    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
307    where
308        E: serde::de::Error,
309    {
310        Ok(Value::Bytes(v))
311    }
312
313    #[inline]
314    fn visit_none<E>(self) -> Result<Self::Value, E>
315    where
316        E: serde::de::Error,
317    {
318        Ok(Value::Unit)
319    }
320
321    #[inline]
322    fn visit_some<D>(self, d: D) -> Result<Self::Value, D::Error>
323    where
324        D: serde::de::Deserializer<'de>,
325    {
326        serde::de::Deserialize::deserialize(d)
327    }
328
329    #[inline]
330    fn visit_unit<E>(self) -> Result<Self::Value, E>
331    where
332        E: serde::de::Error,
333    {
334        Ok(Value::Unit)
335    }
336
337    #[inline]
338    fn visit_seq<V>(self, mut v: V) -> Result<Self::Value, V::Error>
339    where
340        V: serde::de::SeqAccess<'de>,
341    {
342        let mut values = v.size_hint().map_or(Vec::new(), Vec::with_capacity);
343
344        while let Some(element) = v.next_element()? {
345            values.push(element);
346        }
347
348        Ok(Value::Sequence(values))
349    }
350
351    #[inline]
352    fn visit_map<V>(self, mut v: V) -> Result<Self::Value, V::Error>
353    where
354        V: serde::de::MapAccess<'de>,
355    {
356        let mut values = collections::BTreeMap::new();
357
358        while let Some((key, value)) = v.next_entry()? {
359            values.insert(key, value);
360        }
361
362        Ok(Value::Map(values))
363    }
364}
record_query/value/mod.rs

record_query/value/
mod.rs
