musli_core/internal/
macros.rs

1macro_rules! __slice_sequence {
2    (
3        $(#[$($meta:meta)*])*
4        $cx:ident,
5        $ty:ident <T $(, $alloc:ident)?>,
6        || $new:expr,
7        |$vec:ident, $value:ident| $insert:expr,
8        |$reserve_vec:ident, $reserve_capacity:ident| $reserve:expr,
9        |$capacity:ident| $with_capacity:expr,
10    ) => {
11        $(#[$($meta)*])*
12        impl<M, T $(, $alloc)*> $crate::en::Encode<M> for $ty<T $(, $alloc)*>
13        where
14            T: $crate::en::Encode<M>,
15            $($alloc: Allocator,)*
16        {
17            const IS_BITWISE_ENCODE: bool = false;
18
19            type Encode = Self;
20
21            #[inline]
22            fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
23            where
24                E: $crate::en::Encoder<Mode = M>,
25            {
26                encoder.encode_slice(self)
27            }
28
29            #[inline]
30            fn as_encode(&self) -> &Self::Encode {
31                self
32            }
33        }
34
35        $(#[$($meta)*])*
36        impl<'de, M, A, T> $crate::de::Decode<'de, M, A> for $ty<T $(, $alloc)*>
37        where
38            A: $crate::alloc::Allocator,
39            T: $crate::de::Decode<'de, M, A>,
40        {
41            const IS_BITWISE_DECODE: bool = false;
42
43            #[inline]
44            fn decode<D>(decoder: D) -> Result<Self, D::Error>
45            where
46                D: Decoder<'de, Mode = M, Allocator = A>,
47            {
48                struct Builder<'de, M, A, T>
49                where
50                    $($alloc: $crate::alloc::Allocator,)*
51                {
52                    vec: $ty<T $(, $alloc)*>,
53                    _marker: core::marker::PhantomData<(M, A, &'de ())>
54                }
55
56                #[allow(unused_variables)]
57                impl<'de, M, A, T> $crate::de::DecodeSliceBuilder<T, A> for Builder<'de, M, A, T>
58                where
59                    T: $crate::de::Decode<'de, M, A>,
60                    A: $crate::alloc::Allocator,
61                {
62                    #[inline]
63                    fn new<C>($cx: C) -> Result<Self, C::Error>
64                    where
65                        C: $crate::Context<Allocator = A>,
66                    {
67                        Ok(Builder {
68                            vec: $new,
69                            _marker: core::marker::PhantomData
70                        })
71                    }
72
73                    #[inline]
74                    fn with_capacity<C>($cx: C, $capacity: usize) -> Result<Self, C::Error>
75                    where
76                        C: $crate::Context<Allocator = A>,
77                    {
78                        Ok(Builder {
79                            vec: $with_capacity,
80                            _marker: core::marker::PhantomData
81                        })
82                    }
83
84                    #[inline]
85                    fn push<C>(&mut self, $cx: C, $value: T) -> Result<(), C::Error>
86                    where
87                        C: $crate::Context<Allocator = A>,
88                    {
89                        let $vec = &mut self.vec;
90                        $insert;
91                        Ok(())
92                    }
93
94                    #[inline]
95                    fn reserve<C>( &mut self, $cx: C, $reserve_capacity: usize) -> Result<(), C::Error>
96                    where
97                        C: $crate::Context<Allocator = A>,
98                    {
99                        let $reserve_vec = &mut self.vec;
100                        $reserve;
101                        Ok(())
102                    }
103
104                    #[inline]
105                    unsafe fn set_len(&mut self, len: usize) {
106                        unsafe {
107                            self.vec.set_len(len);
108                        }
109                    }
110
111                    #[inline]
112                    fn as_mut_ptr(&mut self) -> *mut T {
113                        self.vec.as_mut_ptr()
114                    }
115                }
116
117                let Builder { vec, _marker: core::marker::PhantomData } = decoder.decode_slice()?;
118                Ok(vec)
119            }
120        }
121
122        $(#[$($meta)*])*
123        impl<M, T $(, $alloc)*> $crate::en::EncodePacked<M> for $ty<T $(, $alloc)*>
124        where
125            T: $crate::en::Encode<M>,
126            $($alloc: $crate::alloc::Allocator,)*
127        {
128            #[inline]
129            fn encode_packed<E>(&self, encoder: E) -> Result<(), E::Error>
130            where
131                E: $crate::en::Encoder<Mode = M>,
132            {
133                encoder.encode_pack_fn(|pack| {
134                    $crate::en::SequenceEncoder::encode_slice(pack, self)
135                })
136            }
137        }
138    }
139}
140
141pub(crate) use __slice_sequence as slice_sequence;
musli_core/internal/macros.rs

musli_core/internal/
macros.rs
