litl/
lib.rs

1use std::collections::HashMap;
2
3use deepsize::DeepSizeOf;
4use futures_core::Stream;
5use futures_io::AsyncBufRead;
6use futures_util::{future, AsyncBufReadExt, StreamExt, TryStreamExt};
7use map_ordering_serializer::MapOrderingSerializer;
8use serde::{de::DeserializeOwned, Serialize};
9use serde_json::ser::CompactFormatter;
10use thiserror::Error;
11
12pub use zbase32;
13
14mod map_ordering_serializer;
15pub mod raw_data_serde;
16mod tagged_data;
17
18pub use tagged_data::*;
19
20#[inline]
21pub fn to_writer<W, T>(writer: W, value: &T) -> std::io::Result<()>
22where
23    W: std::io::Write,
24    T: ?Sized + Serialize,
25{
26    let mut ser = serde_json::Serializer::with_formatter(writer, CompactFormatter {});
27    value.serialize(&mut ser)?;
28    Ok(())
29}
30
31#[inline]
32pub fn to_writer_canonical<W, T>(writer: W, value: &T) -> std::io::Result<()>
33where
34    W: std::io::Write,
35    T: ?Sized + Serialize,
36{
37    let mut ser = MapOrderingSerializer::new(writer);
38    value.serialize(&mut ser)?;
39    Ok(())
40}
41
42#[inline]
43pub fn to_vec<T>(value: &T) -> std::io::Result<Vec<u8>>
44where
45    T: ?Sized + Serialize,
46{
47    let mut writer = Vec::new();
48    to_writer(&mut writer, value)?;
49    Ok(writer)
50}
51
52#[inline]
53pub fn to_vec_canonical<T>(value: &T) -> std::io::Result<Vec<u8>>
54where
55    T: ?Sized + Serialize,
56{
57    let mut writer = Vec::new();
58    to_writer_canonical(&mut writer, value)?;
59    Ok(writer)
60}
61
62#[inline]
63pub fn to_string<T>(value: &T) -> std::io::Result<String>
64where
65    T: ?Sized + Serialize,
66{
67    let vec = to_vec(value)?;
68
69    Ok(unsafe {
70        // We do not emit invalid UTF-8.
71        String::from_utf8_unchecked(vec)
72    })
73}
74
75#[inline]
76pub fn to_string_canonical<T>(value: &T) -> std::io::Result<String>
77where
78    T: ?Sized + Serialize,
79{
80    let vec = to_vec_canonical(value)?;
81
82    Ok(unsafe {
83        // We do not emit invalid UTF-8.
84        String::from_utf8_unchecked(vec)
85    })
86}
87
88#[inline]
89pub fn from_slice_owned<T: DeserializeOwned>(sl: &[u8]) -> Result<T, self::Error> {
90    serde_json::from_reader(sl)
91}
92
93#[inline]
94pub fn val_from_str(s: &str) -> Result<litl_val::Val, self::Error> {
95    serde_json::from_str(s)
96}
97
98pub use serde_json::{
99    from_reader, from_slice, from_str, from_value, json, to_string_pretty, to_value, Error, Value,
100};
101
102pub use litl_val::{from_val, to_val, Key, Map, Val, ValDeserializerError, ValE, ValRef};
103
104pub struct MeasureValue(pub Value);
105
106impl DeepSizeOf for MeasureValue {
107    fn deep_size_of_children(&self, context: &mut deepsize::Context) -> usize {
108        match self.0.clone() {
109            Value::Null => std::mem::size_of::<Value>(),
110            Value::Bool(_) => std::mem::size_of::<Value>(),
111            Value::Number(_) => std::mem::size_of::<Value>(),
112            Value::String(s) => {
113                s.deep_size_of_children(context) + std::mem::size_of::<Value>()
114                    - std::mem::size_of::<String>()
115            }
116            Value::Array(a) => {
117                a.into_iter()
118                    .map(MeasureValue)
119                    .collect::<Vec<_>>()
120                    .deep_size_of_children(context)
121                    + std::mem::size_of::<Value>()
122                    - std::mem::size_of::<Vec<Value>>()
123            }
124            Value::Object(o) => {
125                o.into_iter()
126                    .map(|(k, v)| (k, MeasureValue(v)))
127                    .collect::<HashMap<_, _>>()
128                    .deep_size_of_children(context)
129                    + std::mem::size_of::<Value>()
130                    - std::mem::size_of::<serde_json::map::Map<String, Value>>()
131            }
132        }
133    }
134}
135
136#[macro_export]
137macro_rules! impl_debug_as_litl {
138    ($t:ty) => {
139        impl std::fmt::Debug for $t {
140            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
141                f.write_str(&litl::to_string_pretty(&self).unwrap())
142            }
143        }
144    };
145}
146
147pub fn from_newln_sep_slice<T: DeserializeOwned>(s: &[u8]) -> Result<Vec<T>, Error> {
148    let mut result = Vec::new();
149    for line in s.split(|b| *b == b'\n') {
150        if !line.is_empty() {
151            result.push(from_slice(line)?);
152        }
153    }
154    Ok(result)
155}
156
157pub fn read_newln_sep_stream<R: AsyncBufRead, T: DeserializeOwned>(
158    reader: R,
159) -> impl Stream<Item = Result<T, ReadNewlnSepStreamError>> {
160    reader
161        .lines()
162        .map_err(ReadNewlnSepStreamError::Io)
163        .and_then(|line| {
164            future::ready(from_str(&line).map_err(ReadNewlnSepStreamError::Deserialize))
165        })
166}
167
168#[derive(Error, Debug)]
169pub enum ReadNewlnSepStreamError {
170    #[error(transparent)]
171    Io(#[from] std::io::Error),
172    #[error(transparent)]
173    Deserialize(#[from] crate::Error),
174}
175
176pub fn to_newln_sep_vec<'a, T: Serialize + 'a, I: IntoIterator<Item = &'a T>>(
177    iter: I,
178) -> Result<Vec<u8>, std::io::Error> {
179    let mut buf = Vec::new();
180    for item in iter {
181        let item_str = to_string(item)?;
182        buf.extend_from_slice(item_str.as_bytes());
183        buf.push(b'\n');
184    }
185    Ok(buf)
186}
187
188pub fn to_newln_sep_stream<T: Serialize, S: Stream<Item = T>>(
189    stream: S,
190) -> impl Stream<Item = Result<Vec<u8>, std::io::Error>> {
191    stream.map(|val| {
192        let mut bytes = crate::to_vec(&val)?;
193        bytes.push(b'\n');
194        Ok(bytes)
195    })
196}
litl/lib.rs

litl/
lib.rs
