1use alloc::borrow::ToOwned;
4use alloc::string::String;
5use alloc::vec::Vec;
6use core::fmt;
7use core::ops::{Deref, DerefMut};
8
9use super::array::Array;
10use super::id::Id;
11use super::map::Map;
12use super::spec::DataType;
13
14#[derive(Clone, PartialEq)]
15pub enum Value {
16 F32(f32),
17 F64(f64),
18 I32(i32),
19 I64(i64),
20 U32(u32),
21 U64(u64),
22 I8(i8),
23 U8(u8),
24 I16(i16),
25 U16(u16),
26 String(String),
27 Array(Array),
28 Map(Map),
29 Bool(bool),
30 Null,
31 Binary(Binary),
32 TimeStamp(TimeStamp),
33 Id(Id),
34}
35
36impl Eq for Value {}
37
38impl fmt::Debug for Value {
39 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
40 match self {
41 Value::F32(f) => write!(fmt, "F32({:?})", f),
42 Value::F64(f) => write!(fmt, "F64({:?})", f),
43 Value::I32(i) => write!(fmt, "I32({:?})", i),
44 Value::I64(i) => write!(fmt, "I64({:?})", i),
45 Value::U32(u) => write!(fmt, "U32({:?})", u),
46 Value::U64(u) => write!(fmt, "U64({:?})", u),
47 Value::I8(i) => write!(fmt, "I8({:?})", i),
48 Value::U8(u) => write!(fmt, "U8({:?})", u),
49 Value::I16(i) => write!(fmt, "I16({:?})", i),
50 Value::U16(u) => write!(fmt, "U16({:?})", u),
51 Value::String(s) => write!(fmt, "String({:?})", s),
52 Value::Array(vec) => write!(fmt, "Array({:?})", vec),
53 Value::Map(o) => write!(fmt, "{:?}", o),
54 Value::Bool(b) => write!(fmt, "Bool({:?})", b),
55 Value::Null => write!(fmt, "Null"),
56 Value::Binary(vec) => write!(fmt, "Binary(0x{})", const_hex::encode(&vec.0)),
57 Value::TimeStamp(t) => {
58 write!(fmt, "TimeStamp({})", t.0)
59 }
60 Value::Id(id) => write!(fmt, "Id({})", id),
61 }
62 }
63}
64
65impl fmt::Display for Value {
66 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
67 match self {
68 Value::F32(f) => write!(fmt, "F32({})", f),
69 Value::F64(f) => write!(fmt, "F64({})", f),
70 Value::I32(i) => write!(fmt, "I32({})", i),
71 Value::I64(i) => write!(fmt, "I64({})", i),
72 Value::U32(u) => write!(fmt, "U32({})", u),
73 Value::U64(u) => write!(fmt, "U64({})", u),
74 Value::I8(i) => write!(fmt, "I8({})", i),
75 Value::U8(u) => write!(fmt, "U8({})", u),
76 Value::I16(i) => write!(fmt, "I16({})", i),
77 Value::U16(u) => write!(fmt, "U16({})", u),
78 Value::String(s) => write!(fmt, "String({})", s),
79 Value::Array(vec) => {
80 write!(fmt, "Array[")?;
81
82 let mut first = true;
83 for value in vec.iter() {
84 if !first {
85 write!(fmt, ", ")?;
86 }
87
88 write!(fmt, "{}", value)?;
89 first = false;
90 }
91
92 write!(fmt, "]")
93 }
94 Value::Map(o) => write!(fmt, "Map({})", o),
95 Value::Bool(b) => write!(fmt, "{}", b),
96 Value::Null => write!(fmt, "null"),
97 Value::Binary(vec) => write!(fmt, "Binary(0x{})", const_hex::encode(&vec.0)),
98 Value::TimeStamp(t) => {
99 write!(fmt, "TimeStamp({})", t.0)
100 }
101 Value::Id(id) => write!(fmt, "Id({})", id),
102 }
103 }
104}
105
106impl From<f32> for Value {
107 fn from(f: f32) -> Value {
108 Value::F32(f)
109 }
110}
111
112impl From<f64> for Value {
113 fn from(f: f64) -> Value {
114 Value::F64(f)
115 }
116}
117
118impl From<i32> for Value {
119 fn from(i: i32) -> Value {
120 Value::I32(i)
121 }
122}
123
124impl From<i64> for Value {
125 fn from(i: i64) -> Value {
126 Value::I64(i)
127 }
128}
129
130impl From<u32> for Value {
131 fn from(u: u32) -> Value {
132 Value::U32(u)
133 }
134}
135
136impl From<u64> for Value {
137 fn from(u: u64) -> Value {
138 Value::U64(u)
139 }
140}
141
142impl From<i8> for Value {
143 fn from(i: i8) -> Value {
144 Value::I8(i)
145 }
146}
147
148impl From<u8> for Value {
149 fn from(u: u8) -> Value {
150 Value::U8(u)
151 }
152}
153
154impl From<i16> for Value {
155 fn from(i: i16) -> Value {
156 Value::I16(i)
157 }
158}
159
160impl From<u16> for Value {
161 fn from(u: u16) -> Value {
162 Value::U16(u)
163 }
164}
165
166impl From<&str> for Value {
167 fn from(s: &str) -> Value {
168 Value::String(s.to_owned())
169 }
170}
171
172impl From<String> for Value {
173 fn from(s: String) -> Value {
174 Value::String(s)
175 }
176}
177
178impl<'a> From<&'a String> for Value {
179 fn from(s: &'a String) -> Value {
180 Value::String(s.to_owned())
181 }
182}
183
184impl From<Binary> for Value {
185 fn from(b: Binary) -> Value {
186 Value::Binary(b)
187 }
188}
189
190impl<'a> From<&'a Binary> for Value {
191 fn from(b: &'a Binary) -> Value {
192 Value::Binary(b.to_owned())
193 }
194}
195
196impl From<Array> for Value {
197 fn from(a: Array) -> Value {
198 Value::Array(a)
199 }
200}
201
202impl From<Map> for Value {
203 fn from(d: Map) -> Value {
204 Value::Map(d)
205 }
206}
207
208impl From<bool> for Value {
209 fn from(b: bool) -> Value {
210 Value::Bool(b)
211 }
212}
213
214impl From<Vec<u8>> for Value {
215 fn from(b: Vec<u8>) -> Value {
216 Value::Binary(Binary(b))
217 }
218}
219
220impl From<[u8; 12]> for Value {
221 fn from(o: [u8; 12]) -> Value {
222 Value::Id(Id::with_bytes(o))
223 }
224}
225
226impl From<TimeStamp> for Value {
227 fn from(t: TimeStamp) -> Self {
228 Value::TimeStamp(t)
229 }
230}
231
232impl From<Id> for Value {
233 fn from(o: Id) -> Value {
234 Value::Id(o)
235 }
236}
237
238impl<'a> From<&'a Id> for Value {
239 fn from(o: &'a Id) -> Value {
240 Value::Id(o.to_owned())
241 }
242}
243
244impl<T: Into<Value>> From<Option<T>> for Value {
245 fn from(v: Option<T>) -> Value {
246 v.map(|v| v.into()).unwrap_or(Value::Null)
247 }
248}
249
250macro_rules! value_from_impls {
251 ($($T:ty)+) => {
252 $(
253 impl From<Vec<$T>> for Value {
254 fn from(vec: Vec<$T>) -> Value {
255 Value::Array(vec.into())
256 }
257 }
258 )+
259 }
260}
261
262value_from_impls! {
263 f32 f64 i32 i64 &str String &String Array
264 Map bool Vec<u8> Id
265}
266
267impl Value {
268 pub fn element_type(&self) -> DataType {
269 match self {
270 Value::F32(..) => DataType::F32,
271 Value::F64(..) => DataType::F64,
272 Value::I32(..) => DataType::I32,
273 Value::I64(..) => DataType::I64,
274 Value::U32(..) => DataType::U32,
275 Value::U64(..) => DataType::U64,
276 Value::I8(..) => DataType::I8,
277 Value::U8(..) => DataType::U8,
278 Value::I16(..) => DataType::I16,
279 Value::U16(..) => DataType::U16,
280 Value::String(..) => DataType::String,
281 Value::Array(..) => DataType::Array,
282 Value::Map(..) => DataType::Map,
283 Value::Bool(..) => DataType::Bool,
284 Value::Null => DataType::Null,
285 Value::Binary(..) => DataType::Binary,
286 Value::TimeStamp(..) => DataType::TimeStamp,
287 Value::Id(..) => DataType::Id,
288 }
289 }
290
291 pub fn bytes_size(&self) -> usize {
292 match self {
293 Value::F32(_) => 4,
294 Value::F64(_) => 8,
295 Value::I32(_) => 4,
296 Value::I64(_) => 8,
297 Value::U32(_) => 4,
298 Value::U64(_) => 8,
299 Value::I8(_) => 1,
300 Value::U8(_) => 1,
301 Value::I16(_) => 2,
302 Value::U16(_) => 2,
303 Value::String(s) => 4 + s.len(),
304 Value::Array(a) => a.bytes_size(),
305 Value::Map(m) => m.bytes_size(),
306 Value::Bool(_) => 1,
307 Value::Null => 0,
308 Value::Binary(b) => 4 + b.0.len(),
309 Value::TimeStamp(_) => 8,
310 Value::Id(_) => 12,
311 }
312 }
313
314 pub fn as_f32(&self) -> Option<f32> {
315 match self {
316 Value::F32(v) => Some(*v),
317 _ => None,
318 }
319 }
320
321 pub fn as_f64(&self) -> Option<f64> {
322 match self {
323 Value::F64(v) => Some(*v),
324 _ => None,
325 }
326 }
327
328 pub fn as_i32(&self) -> Option<i32> {
329 match self {
330 Value::I32(v) => Some(*v),
331 _ => None,
332 }
333 }
334
335 pub fn as_u32(&self) -> Option<u32> {
336 match self {
337 Value::U32(v) => Some(*v),
338 _ => None,
339 }
340 }
341
342 pub fn as_i64(&self) -> Option<i64> {
343 match self {
344 Value::I64(v) => Some(*v),
345 _ => None,
346 }
347 }
348
349 pub fn as_u64(&self) -> Option<u64> {
350 match self {
351 Value::U64(v) => Some(*v),
352 _ => None,
353 }
354 }
355
356 pub fn as_i8(&self) -> Option<i8> {
357 match self {
358 Value::I8(v) => Some(*v),
359 _ => None,
360 }
361 }
362
363 pub fn as_u8(&self) -> Option<u8> {
364 match self {
365 Value::U8(v) => Some(*v),
366 _ => None,
367 }
368 }
369
370 pub fn as_i16(&self) -> Option<i16> {
371 match self {
372 Value::I16(v) => Some(*v),
373 _ => None,
374 }
375 }
376
377 pub fn as_u16(&self) -> Option<u16> {
378 match self {
379 Value::U16(v) => Some(*v),
380 _ => None,
381 }
382 }
383
384 pub fn as_str(&self) -> Option<&str> {
385 match self {
386 Value::String(s) => Some(s),
387 _ => None,
388 }
389 }
390
391 pub fn as_array(&self) -> Option<&Array> {
392 match self {
393 Value::Array(v) => Some(v),
394 _ => None,
395 }
396 }
397
398 pub fn as_map(&self) -> Option<&Map> {
399 match self {
400 Value::Map(v) => Some(v),
401 _ => None,
402 }
403 }
404
405 pub fn as_bool(&self) -> Option<bool> {
406 match self {
407 Value::Bool(v) => Some(*v),
408 _ => None,
409 }
410 }
411
412 pub fn as_id(&self) -> Option<&Id> {
413 match self {
414 Value::Id(v) => Some(v),
415 _ => None,
416 }
417 }
418
419 pub fn as_timestamp(&self) -> Option<TimeStamp> {
420 match self {
421 Value::TimeStamp(v) => Some(*v),
422 _ => None,
423 }
424 }
425
426 pub fn as_null(&self) -> Option<()> {
427 match self {
428 Value::Null => Some(()),
429 _ => None,
430 }
431 }
432
433 pub fn as_binary(&self) -> Option<&Binary> {
434 match self {
435 Value::Binary(b) => Some(b),
436 _ => None,
437 }
438 }
439
440 #[cfg(feature = "serde")]
441 pub(crate) fn to_extended_map(&self) -> Map {
442 match self {
443 Value::Binary(v) => {
444 let mut msg = Map::with_capacity(1);
445 msg.insert("$bin", const_hex::encode(&v.0));
446 msg
447 }
448 Value::TimeStamp(v) => {
449 let mut msg = Map::with_capacity(1);
450 msg.insert("$tim", v.0);
451 msg
452 }
453 Value::Id(v) => {
454 let mut msg = Map::with_capacity(1);
455 msg.insert("$mid", v.to_hex());
456 msg
457 }
458 _ => panic!("Attempted conversion of invalid data type: {}", self),
459 }
460 }
461
462 #[cfg(feature = "serde")]
463 pub(crate) fn from_extended_map(msg: Map) -> Value {
464 if msg.len() == 1 {
465 let (key, value) = msg.get_index(0).unwrap();
466
467 match key.as_str() {
468 "$bin" => {
469 if let Value::String(hex) = value
470 && let Ok(bin) = const_hex::decode(hex.as_bytes())
471 {
472 return Value::Binary(Binary(bin));
473 }
474 }
475 "$tim" => {
476 if let Value::U64(u) = value {
477 return Value::TimeStamp((*u).into());
478 }
479 }
480 "$mid" => {
481 if let Value::String(hex) = value
482 && let Ok(id) = Id::with_string(hex)
483 {
484 return id.into();
485 }
486 }
487 _ => (),
488 }
489 }
490
491 Value::Map(msg)
492 }
493}
494
495#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone)]
496pub struct Binary(pub Vec<u8>);
497
498impl From<Vec<u8>> for Binary {
499 fn from(v: Vec<u8>) -> Self {
500 Binary(v)
501 }
502}
503
504impl From<Binary> for Vec<u8> {
505 fn from(b: Binary) -> Self {
506 b.0
507 }
508}
509
510impl Deref for Binary {
511 type Target = Vec<u8>;
512 fn deref(&self) -> &Vec<u8> {
513 &self.0
514 }
515}
516
517impl DerefMut for Binary {
518 fn deref_mut(&mut self) -> &mut Vec<u8> {
519 &mut self.0
520 }
521}
522
523#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Copy, Clone)]
524pub struct TimeStamp(pub u64);
525
526impl From<u64> for TimeStamp {
527 fn from(v: u64) -> Self {
528 TimeStamp(v)
529 }
530}
531
532impl From<TimeStamp> for u64 {
533 fn from(t: TimeStamp) -> Self {
534 t.0
535 }
536}