simple_parse 0.6.3

A declarative converter for Rust type to and from binary
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use std::cmp::{Eq, Ord};
use std::collections::*;
use std::ffi::{CStr, CString};
use std::hash::Hash;
use std::num::*;
use std::sync::atomic::*;

use crate::*;

impl_writer_all!(u8, prim_to_writer);
impl_writer_all!(u16, prim_to_writer);
impl_writer_all!(u32, prim_to_writer);
impl_writer_all!(u64, prim_to_writer);
impl_writer_all!(u128, prim_to_writer);
impl_writer_all!(usize, prim_to_writer);
impl_writer_all!(i8, prim_to_writer);
impl_writer_all!(i16, prim_to_writer);
impl_writer_all!(i32, prim_to_writer);
impl_writer_all!(i64, prim_to_writer);
impl_writer_all!(i128, prim_to_writer);
impl_writer_all!(isize, prim_to_writer);
impl_writer_all!(bool as u8, prim_to_writer);
impl_writer_all!(f32 as u32, prim_to_writer);
impl_writer_all!(f64 as u64, prim_to_writer);

impl_writer_all!(AtomicU8 as u8, prim_to_writer);
impl_writer_all!(AtomicU16 as u16, prim_to_writer);
impl_writer_all!(AtomicU32 as u32, prim_to_writer);
impl_writer_all!(AtomicU64 as u64, prim_to_writer);
impl_writer_all!(AtomicUsize as usize, prim_to_writer);
impl_writer_all!(AtomicI8 as i8, prim_to_writer);
impl_writer_all!(AtomicI16 as i16, prim_to_writer);
impl_writer_all!(AtomicI32 as i32, prim_to_writer);
impl_writer_all!(AtomicI64 as i64, prim_to_writer);
impl_writer_all!(AtomicIsize as isize, prim_to_writer);
impl_writer_all!(AtomicBool as bool, prim_to_writer);

impl_writer_all!(NonZeroU8 as u8, prim_to_writer);
impl_writer_all!(NonZeroU16 as u16, prim_to_writer);
impl_writer_all!(NonZeroU32 as u32, prim_to_writer);
impl_writer_all!(NonZeroU64 as u64, prim_to_writer);
impl_writer_all!(NonZeroU128 as u128, prim_to_writer);
impl_writer_all!(NonZeroUsize as usize, prim_to_writer);
impl_writer_all!(NonZeroI8 as i8, prim_to_writer);
impl_writer_all!(NonZeroI16 as i16, prim_to_writer);
impl_writer_all!(NonZeroI32 as i32, prim_to_writer);
impl_writer_all!(NonZeroI64 as i64, prim_to_writer);
impl_writer_all!(NonZeroI128 as i128, prim_to_writer);
impl_writer_all!(NonZeroIsize as isize, prim_to_writer);

/* String types */

macro_rules! asbytes_to_writer {
    ($self:ident, $ctx:ident, $dst: ident) => {{
        // Convert to &[u8]
        let s = $self.as_bytes();
        s.inner_to_writer($ctx, $dst)
    }};
}
impl_writer!(&str, asbytes_to_writer);
impl_writer!(String, asbytes_to_writer);

macro_rules! tobytes_to_writer {
    ($self:ident, $ctx:ident, $dst: ident) => {{
        // Convert to &[u8]
        let s = $self.to_bytes_with_nul();
        s.inner_to_writer($ctx, $dst)
    }};
}
impl_writer!(&CStr, tobytes_to_writer);
impl_writer!(CString, tobytes_to_writer);

/* Generic types */

macro_rules! option_to_writer {
    ($self:ident, $ctx:ident, $dst: ident $(, $generics:tt $(: $bound:ident $(+ $other:ident)*)?)*) => {{
        let mut total_sz: usize = 0;
        match $self {
            Some(v) => {
                if $ctx.count.is_none() {
                    total_sz += (true).inner_to_writer($ctx, $dst)?;
                } else {
                    $ctx.count = None;
                }
                total_sz += v.inner_to_writer($ctx, $dst)?;
            }
            None => {
                if $ctx.count.is_none() {
                    total_sz += (false).inner_to_writer($ctx, $dst)?;
                }
            }
        }
        Ok(total_sz)
    }};
}
impl_writer!(Option<T>, option_to_writer, T);

impl_writer!(Vec<T>, iterator_to_writer, T);
impl_writer!(VecDeque<T>, iterator_to_writer, T);
impl_writer!(LinkedList<T>, iterator_to_writer, T);
impl_writer!(HashSet<K>, iterator_to_writer, K: Eq + Hash);
impl_writer!(BTreeSet<K>, iterator_to_writer, K: Ord);
impl_writer!(HashMap<K,V>, iterator_to_writer, K: Eq + Hash, V);
impl_writer!(BTreeMap<K,V>, iterator_to_writer, K: Ord, V);
impl_writer!(BinaryHeap<T>, iterator_to_writer, T: Ord);