rapira/
implements.rs

1use crate::{LEN_SIZE, Rapira};
2
3#[cfg(feature = "arrayvec")]
4impl<T: crate::Rapira, const CAP: usize> crate::Rapira for arrayvec::ArrayVec<T, CAP> {
5    const MIN_SIZE: usize = LEN_SIZE;
6
7    #[inline]
8    fn size(&self) -> usize {
9        4 + match T::STATIC_SIZE {
10            Some(size) => size * self.len(),
11            None => self.iter().fold(0, |b, v| b + v.size()),
12        }
13    }
14
15    #[inline]
16    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()>
17    where
18        Self: Sized,
19    {
20        let len = u32::from_slice(slice)? as usize;
21        for _ in 0..len {
22            T::check_bytes(slice)?;
23        }
24        Ok(())
25    }
26
27    #[inline]
28    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
29    where
30        Self: Sized,
31    {
32        let len = usize::from_slice(slice)?;
33        if len > CAP {
34            return Err(crate::RapiraError::SliceLen);
35        }
36        let mut vec = Self::new_const();
37        for _ in 0..len {
38            let val = T::from_slice(slice)?;
39            vec.push(val);
40        }
41        Ok(vec)
42    }
43
44    #[inline]
45    unsafe fn from_slice_unchecked(slice: &mut &[u8]) -> crate::Result<Self>
46    where
47        Self: Sized,
48    {
49        unsafe {
50            let len = u32::from_slice_unchecked(slice)? as usize;
51            if len > CAP {
52                return Err(crate::RapiraError::SliceLen);
53            }
54            let mut vec = Self::new_const();
55            for _ in 0..len {
56                let val = T::from_slice_unchecked(slice)?;
57                vec.push_unchecked(val);
58            }
59            Ok(vec)
60        }
61    }
62
63    #[inline]
64    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
65    where
66        Self: Sized,
67    {
68        unsafe {
69            let len = usize::from_slice_unsafe(slice)?;
70            let mut vec = Self::new_const();
71            for _ in 0..len {
72                let val = T::from_slice_unsafe(slice)?;
73                vec.push_unchecked(val);
74            }
75
76            Ok(vec)
77        }
78    }
79
80    #[inline]
81    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
82        let len = self.len() as u32;
83        len.try_convert_to_bytes(slice, cursor)?;
84
85        for val in self.iter() {
86            val.try_convert_to_bytes(slice, cursor)?;
87        }
88
89        Ok(())
90    }
91
92    #[inline]
93    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
94        let len = self.len() as u32;
95        len.convert_to_bytes(slice, cursor);
96
97        for val in self.iter() {
98            val.convert_to_bytes(slice, cursor);
99        }
100    }
101}
102
103#[cfg(feature = "arrayvec")]
104impl<const CAP: usize> crate::Rapira for arrayvec::ArrayString<CAP> {
105    const MIN_SIZE: usize = LEN_SIZE;
106
107    #[inline]
108    fn size(&self) -> usize {
109        4 + self.len()
110    }
111
112    #[inline]
113    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()>
114    where
115        Self: Sized,
116    {
117        let len = slice.len();
118        crate::str_rapira::check_bytes::<()>(core::marker::PhantomData, slice)?;
119        let size = len - slice.len();
120        if size > CAP {
121            Err(crate::RapiraError::SliceLen)
122        } else {
123            Ok(())
124        }
125    }
126
127    #[inline]
128    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
129    where
130        Self: Sized,
131    {
132        let s = crate::str_rapira::from_slice(slice)?;
133        let s = Self::from(s).map_err(|_| crate::RapiraError::SliceLen)?;
134        Ok(s)
135    }
136
137    #[inline]
138    unsafe fn from_slice_unchecked(slice: &mut &[u8]) -> crate::Result<Self>
139    where
140        Self: Sized,
141    {
142        let s = unsafe { crate::str_rapira::from_slice_unchecked(slice)? };
143        let s = Self::from(s).map_err(|_| crate::RapiraError::SliceLen)?;
144        Ok(s)
145    }
146
147    #[inline]
148    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
149    where
150        Self: Sized,
151    {
152        let s = unsafe { crate::str_rapira::from_slice_unsafe(slice)? };
153        let s = Self::from(s).map_err(|_| crate::RapiraError::SliceLen)?;
154        Ok(s)
155    }
156
157    #[inline]
158    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
159        crate::str_rapira::convert_to_bytes(self, slice, cursor);
160    }
161
162    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
163        crate::str_rapira::try_convert_to_bytes(self, slice, cursor)
164    }
165}
166
167#[cfg(feature = "smallvec")]
168impl<T: crate::Rapira, const CAP: usize> crate::Rapira for smallvec::SmallVec<[T; CAP]> {
169    const MIN_SIZE: usize = LEN_SIZE;
170
171    #[inline]
172    fn size(&self) -> usize {
173        4 + match T::STATIC_SIZE {
174            Some(size) => size * self.len(),
175            None => self.iter().fold(0, |b, v| b + v.size()),
176        }
177    }
178
179    #[inline]
180    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()>
181    where
182        Self: Sized,
183    {
184        let len = u32::from_slice(slice)? as usize;
185
186        for _ in 0..len {
187            T::check_bytes(slice)?;
188        }
189
190        Ok(())
191    }
192
193    #[inline]
194    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
195    where
196        Self: Sized,
197    {
198        use crate::max_cap::{SMALLVEC_MAX_CAP, SMALLVEC_MAX_SIZE_OF};
199
200        let len = u32::from_slice(slice)? as usize;
201
202        if len > SMALLVEC_MAX_CAP {
203            return Err(crate::RapiraError::MaxCapacity);
204        }
205
206        let size = std::mem::size_of::<Self>() * len;
207
208        if size > SMALLVEC_MAX_SIZE_OF {
209            return Err(crate::RapiraError::MaxSize);
210        }
211
212        let mut vec = Self::with_capacity(len);
213
214        for _ in 0..len {
215            let val = T::from_slice(slice)?;
216            vec.push(val);
217        }
218
219        Ok(vec)
220    }
221
222    #[inline]
223    unsafe fn from_slice_unchecked(slice: &mut &[u8]) -> crate::Result<Self>
224    where
225        Self: Sized,
226    {
227        let len = u32::from_slice(slice)? as usize;
228        let mut vec = Self::with_capacity(len);
229
230        for _ in 0..len {
231            let val = unsafe { T::from_slice_unchecked(slice)? };
232            vec.push(val);
233        }
234
235        Ok(vec)
236    }
237
238    #[inline]
239    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
240    where
241        Self: Sized,
242    {
243        unsafe {
244            let len = usize::from_slice_unsafe(slice)?;
245            let mut vec = Self::with_capacity(len);
246
247            for _ in 0..len {
248                let val = T::from_slice_unsafe(slice)?;
249                vec.push(val);
250            }
251
252            Ok(vec)
253        }
254    }
255
256    #[inline]
257    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
258        let len = self.len() as u32;
259        len.try_convert_to_bytes(slice, cursor)?;
260
261        for val in self.iter() {
262            val.try_convert_to_bytes(slice, cursor)?;
263        }
264
265        Ok(())
266    }
267
268    #[inline]
269    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
270        let len = self.len() as u32;
271        len.convert_to_bytes(slice, cursor);
272
273        for val in self.iter() {
274            val.convert_to_bytes(slice, cursor);
275        }
276    }
277}
278
279#[cfg(feature = "bytes")]
280impl crate::Rapira for bytes::Bytes {
281    const MIN_SIZE: usize = LEN_SIZE;
282
283    #[inline]
284    fn size(&self) -> usize {
285        use crate::bytes_rapira;
286
287        bytes_rapira::size(self)
288    }
289
290    #[inline]
291    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()> {
292        use crate::bytes_rapira;
293
294        bytes_rapira::check_bytes::<()>(core::marker::PhantomData, slice)
295    }
296
297    #[inline]
298    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
299        use crate::bytes_rapira;
300
301        bytes_rapira::convert_to_bytes(self, slice, cursor);
302    }
303
304    #[inline]
305    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
306        use crate::bytes_rapira;
307
308        bytes_rapira::try_convert_to_bytes(self, slice, cursor)
309    }
310
311    #[inline]
312    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
313    where
314        Self: Sized,
315    {
316        use crate::bytes_rapira;
317
318        let bytes = bytes_rapira::from_slice(slice)?;
319        Ok(Self::copy_from_slice(bytes))
320    }
321
322    #[inline]
323    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
324    where
325        Self: Sized,
326    {
327        use crate::bytes_rapira;
328
329        unsafe {
330            let bytes = bytes_rapira::from_slice_unsafe(slice)?;
331            Ok(Self::copy_from_slice(bytes))
332        }
333    }
334}
335
336#[cfg(feature = "byteview")]
337impl crate::Rapira for byteview::StrView {
338    const MIN_SIZE: usize = LEN_SIZE;
339
340    #[inline]
341    fn size(&self) -> usize {
342        use crate::str_rapira;
343
344        str_rapira::size(self)
345    }
346
347    #[inline]
348    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()> {
349        use crate::str_rapira;
350
351        str_rapira::check_bytes::<()>(core::marker::PhantomData, slice)
352    }
353
354    #[inline]
355    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
356        use crate::str_rapira;
357
358        str_rapira::convert_to_bytes(self, slice, cursor);
359    }
360
361    #[inline]
362    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
363        use crate::str_rapira;
364
365        str_rapira::try_convert_to_bytes(self, slice, cursor)
366    }
367
368    #[inline]
369    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
370    where
371        Self: Sized,
372    {
373        use crate::str_rapira;
374
375        let bytes = str_rapira::from_slice(slice)?;
376        Ok(Self::from(bytes))
377    }
378
379    #[inline]
380    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
381    where
382        Self: Sized,
383    {
384        use crate::str_rapira;
385
386        unsafe {
387            let bytes = str_rapira::from_slice_unsafe(slice)?;
388            Ok(Self::from(bytes))
389        }
390    }
391}
392
393#[cfg(feature = "byteview")]
394impl crate::Rapira for byteview::ByteView {
395    const MIN_SIZE: usize = LEN_SIZE;
396
397    #[inline]
398    fn size(&self) -> usize {
399        use crate::bytes_rapira;
400
401        bytes_rapira::size(self)
402    }
403
404    #[inline]
405    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()> {
406        use crate::bytes_rapira;
407
408        bytes_rapira::check_bytes::<()>(core::marker::PhantomData, slice)
409    }
410
411    #[inline]
412    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
413        use crate::bytes_rapira;
414
415        bytes_rapira::convert_to_bytes(self, slice, cursor);
416    }
417
418    #[inline]
419    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
420        use crate::bytes_rapira;
421
422        bytes_rapira::try_convert_to_bytes(self, slice, cursor)
423    }
424
425    #[inline]
426    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
427    where
428        Self: Sized,
429    {
430        use crate::bytes_rapira;
431
432        let bytes = bytes_rapira::from_slice(slice)?;
433        Ok(Self::from(bytes))
434    }
435
436    #[inline]
437    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
438    where
439        Self: Sized,
440    {
441        use crate::bytes_rapira;
442
443        unsafe {
444            let bytes = bytes_rapira::from_slice_unsafe(slice)?;
445            Ok(Self::from(bytes))
446        }
447    }
448}
449
450#[cfg(feature = "fjall")]
451impl crate::Rapira for fjall::Slice {
452    const MIN_SIZE: usize = LEN_SIZE;
453
454    #[inline]
455    fn size(&self) -> usize {
456        use crate::bytes_rapira;
457
458        bytes_rapira::size(self)
459    }
460
461    #[inline]
462    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()> {
463        use crate::bytes_rapira;
464
465        bytes_rapira::check_bytes::<()>(core::marker::PhantomData, slice)
466    }
467
468    #[inline]
469    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
470        use crate::bytes_rapira;
471
472        bytes_rapira::convert_to_bytes(self, slice, cursor);
473    }
474
475    #[inline]
476    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
477        use crate::bytes_rapira;
478
479        bytes_rapira::try_convert_to_bytes(self, slice, cursor)
480    }
481
482    #[inline]
483    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
484    where
485        Self: Sized,
486    {
487        use crate::bytes_rapira;
488
489        let bytes = bytes_rapira::from_slice(slice)?;
490        Ok(Self::from(bytes))
491    }
492
493    #[inline]
494    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
495    where
496        Self: Sized,
497    {
498        use crate::bytes_rapira;
499
500        unsafe {
501            let bytes = bytes_rapira::from_slice_unsafe(slice)?;
502            Ok(Self::from(bytes))
503        }
504    }
505}
506
507#[cfg(feature = "inline-array")]
508impl crate::Rapira for inline_array::InlineArray {
509    const MIN_SIZE: usize = LEN_SIZE;
510
511    #[inline]
512    fn size(&self) -> usize {
513        use crate::bytes_rapira;
514
515        bytes_rapira::size(self)
516    }
517
518    #[inline]
519    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()> {
520        use crate::bytes_rapira;
521
522        bytes_rapira::check_bytes::<()>(core::marker::PhantomData, slice)
523    }
524
525    #[inline]
526    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
527        use crate::bytes_rapira;
528
529        bytes_rapira::convert_to_bytes(self, slice, cursor);
530    }
531
532    #[inline]
533    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
534        use crate::bytes_rapira;
535
536        bytes_rapira::try_convert_to_bytes(self, slice, cursor)
537    }
538
539    #[inline]
540    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
541    where
542        Self: Sized,
543    {
544        use crate::bytes_rapira;
545
546        let bytes = bytes_rapira::from_slice(slice)?;
547        Ok(Self::from(bytes))
548    }
549
550    #[inline]
551    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
552    where
553        Self: Sized,
554    {
555        use crate::bytes_rapira;
556
557        unsafe {
558            let bytes = bytes_rapira::from_slice_unsafe(slice)?;
559            Ok(Self::from(bytes))
560        }
561    }
562}
563
564#[cfg(feature = "zerocopy")]
565pub mod zero {
566    use core::{marker::PhantomData, mem::size_of};
567
568    use zerocopy::{FromBytes, Immutable, IntoBytes};
569
570    use crate::{extend, try_extend};
571
572    pub const fn static_size<T>(_: PhantomData<T>) -> Option<usize>
573    where
574        T: Sized,
575    {
576        Some(size_of::<T>())
577    }
578
579    pub const fn min_size<T>(_: PhantomData<T>) -> usize
580    where
581        T: Sized,
582    {
583        size_of::<T>()
584    }
585
586    #[inline]
587    pub fn size<T>(_: &T) -> usize
588    where
589        T: Sized,
590    {
591        size_of::<T>()
592    }
593
594    #[inline]
595    pub fn check_bytes<T>(_: PhantomData<T>, slice: &mut &[u8]) -> crate::Result<()>
596    where
597        T: Sized,
598    {
599        let size = size_of::<T>();
600
601        *slice = slice.get(size..).ok_or(crate::RapiraError::SliceLen)?;
602
603        Ok(())
604    }
605
606    #[inline]
607    pub fn from_slice<T>(slice: &mut &[u8]) -> crate::Result<T>
608    where
609        T: FromBytes + Sized,
610    {
611        let size = size_of::<T>();
612        let bytes: &[u8] = slice.get(..size).ok_or(crate::RapiraError::SliceLen)?;
613
614        *slice = slice.get(size..).ok_or(crate::RapiraError::SliceLen)?;
615
616        let t: T = FromBytes::read_from_bytes(bytes)
617            .map_err(|_| crate::RapiraError::Other("zerocopy error"))?;
618        Ok(t)
619    }
620
621    #[inline]
622    pub fn from_slice_unchecked<T>(slice: &mut &[u8]) -> crate::Result<T>
623    where
624        T: FromBytes + Sized,
625    {
626        from_slice(slice)
627    }
628
629    /// .
630    ///
631    /// # Panics
632    ///
633    /// Panics if .
634    ///
635    /// # Errors
636    ///
637    /// This function will return an error if .
638    ///
639    /// # Safety
640    ///
641    /// .
642    #[inline]
643    pub unsafe fn from_slice_unsafe<T>(slice: &mut &[u8]) -> crate::Result<T>
644    where
645        T: FromBytes + Sized,
646    {
647        unsafe {
648            let size = size_of::<T>();
649            let bytes: &[u8] = slice.get_unchecked(..size);
650            *slice = slice.get_unchecked(size..);
651            let t: T = FromBytes::read_from_bytes(bytes)
652                .map_err(|_| crate::RapiraError::Other("zerocopy error"))?;
653            Ok(t)
654        }
655    }
656
657    #[inline]
658    pub fn convert_to_bytes<T>(item: &T, slice: &mut [u8], cursor: &mut usize)
659    where
660        T: Immutable + IntoBytes + Sized,
661    {
662        let bytes = item.as_bytes();
663        extend(slice, cursor, bytes);
664    }
665
666    #[inline]
667    pub fn try_convert_to_bytes<T>(
668        item: &T,
669        slice: &mut [u8],
670        cursor: &mut usize,
671    ) -> crate::Result<()>
672    where
673        T: Immutable + IntoBytes + Sized,
674    {
675        let bytes = item.as_bytes();
676        try_extend(slice, cursor, bytes)?;
677        Ok(())
678    }
679}
680
681#[cfg(feature = "serde_json")]
682impl crate::Rapira for serde_json::Value {
683    const MIN_SIZE: usize = 1;
684
685    #[inline]
686    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
687    where
688        Self: Sized,
689    {
690        use serde_json::{Map, Number, Value};
691
692        use crate::byte_rapira;
693
694        let byte = byte_rapira::from_slice(slice)?;
695        match byte {
696            0 => Ok(Value::Null),
697            1 => {
698                let b = bool::from_slice(slice)?;
699                Ok(Value::Bool(b))
700            }
701            2 => {
702                let byte = byte_rapira::from_slice(slice)?;
703                if byte == 0 {
704                    let u = u64::from_slice(slice)?;
705                    Ok(Value::Number(u.into()))
706                } else if byte == 1 {
707                    let i = i64::from_slice(slice)?;
708                    Ok(Value::Number(i.into()))
709                } else if byte == 2 {
710                    let f = f64::from_slice(slice)?;
711                    let number = Number::from_f64(f).ok_or(crate::RapiraError::FloatIsNaN)?;
712                    Ok(Value::Number(number))
713                } else {
714                    Err(crate::RapiraError::EnumVariant)
715                }
716            }
717            3 => {
718                let s = String::from_slice(slice)?;
719                Ok(Value::String(s))
720            }
721            4 => {
722                let vec = Vec::<Value>::from_slice(slice)?;
723                Ok(Value::Array(vec))
724            }
725            5 => {
726                let len = u32::from_slice(slice)? as usize;
727                let mut map = Map::new();
728                for _ in 0..len {
729                    let key = String::from_slice(slice)?;
730                    let val = Value::from_slice(slice)?;
731                    map.insert(key, val);
732                }
733                Ok(Value::Object(map))
734            }
735            _ => Err(crate::RapiraError::EnumVariant),
736        }
737    }
738
739    #[inline]
740    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()>
741    where
742        Self: Sized,
743    {
744        use crate::byte_rapira;
745
746        let byte = byte_rapira::from_slice(slice)?;
747        match byte {
748            0 => {}
749            1 => {
750                bool::check_bytes(slice)?;
751            }
752            2 => {
753                let byte = byte_rapira::from_slice(slice)?;
754                if byte == 0 {
755                    u64::check_bytes(slice)?;
756                } else if byte == 1 {
757                    i64::check_bytes(slice)?;
758                } else if byte == 2 {
759                    f64::check_bytes(slice)?;
760                } else {
761                    return Err(crate::RapiraError::EnumVariant);
762                }
763            }
764            3 => {
765                String::check_bytes(slice)?;
766            }
767            4 => {
768                Vec::<Self>::check_bytes(slice)?;
769            }
770            5 => {
771                let len = u32::from_slice(slice)? as usize;
772                for _ in 0..len {
773                    String::check_bytes(slice)?;
774                    Self::check_bytes(slice)?;
775                }
776            }
777            _ => return Err(crate::RapiraError::EnumVariant),
778        }
779
780        Ok(())
781    }
782
783    #[inline]
784    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
785    where
786        Self: Sized,
787    {
788        use serde_json::{Map, Number};
789
790        use crate::byte_rapira;
791
792        unsafe {
793            let byte = byte_rapira::from_slice_unsafe(slice)?;
794            match byte {
795                0 => Ok(Self::Null),
796                1 => {
797                    let b = bool::from_slice_unsafe(slice)?;
798                    Ok(Self::Bool(b))
799                }
800                2 => {
801                    let byte = byte_rapira::from_slice_unsafe(slice)?;
802                    if byte == 0 {
803                        let u = u64::from_slice_unsafe(slice)?;
804                        Ok(Self::Number(u.into()))
805                    } else if byte == 1 {
806                        let i = i64::from_slice_unsafe(slice)?;
807                        Ok(Self::Number(i.into()))
808                    } else if byte == 2 {
809                        let f = f64::from_slice_unsafe(slice)?;
810                        let number = Number::from_f64(f).ok_or(crate::RapiraError::FloatIsNaN)?;
811                        Ok(Self::Number(number))
812                    } else {
813                        Err(crate::RapiraError::EnumVariant)
814                    }
815                }
816                3 => {
817                    let s = String::from_slice_unsafe(slice)?;
818                    Ok(Self::String(s))
819                }
820                4 => {
821                    let vec = Vec::<Self>::from_slice_unsafe(slice)?;
822                    Ok(Self::Array(vec))
823                }
824                5 => {
825                    let len = usize::from_slice_unsafe(slice)?;
826                    let mut map = Map::new();
827                    for _ in 0..len {
828                        let key = String::from_slice_unsafe(slice)?;
829                        let val = Self::from_slice_unsafe(slice)?;
830                        map.insert(key, val);
831                    }
832                    Ok(Self::Object(map))
833                }
834                _ => Err(crate::RapiraError::EnumVariant),
835            }
836        }
837    }
838
839    #[inline]
840    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
841        use crate::push;
842
843        match self {
844            Self::Null => {
845                push(slice, cursor, 0);
846            }
847            Self::Bool(v) => {
848                push(slice, cursor, 1);
849                v.convert_to_bytes(slice, cursor);
850            }
851            Self::Number(n) => {
852                push(slice, cursor, 2);
853                if let Some(u) = n.as_u64() {
854                    push(slice, cursor, 0);
855                    u.convert_to_bytes(slice, cursor);
856                } else if let Some(i) = n.as_i64() {
857                    push(slice, cursor, 1);
858                    i.convert_to_bytes(slice, cursor);
859                } else if let Some(f) = n.as_f64() {
860                    push(slice, cursor, 2);
861                    f.convert_to_bytes(slice, cursor);
862                }
863            }
864            Self::String(s) => {
865                push(slice, cursor, 3);
866                s.convert_to_bytes(slice, cursor);
867            }
868            Self::Array(a) => {
869                push(slice, cursor, 4);
870                a.convert_to_bytes(slice, cursor);
871            }
872            Self::Object(o) => {
873                push(slice, cursor, 5);
874                let size: u32 = o.len() as u32;
875                size.convert_to_bytes(slice, cursor);
876                o.iter().for_each(|(k, v)| {
877                    k.convert_to_bytes(slice, cursor);
878                    v.convert_to_bytes(slice, cursor);
879                });
880            }
881        }
882    }
883
884    #[inline]
885    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
886        use crate::try_push;
887
888        match self {
889            Self::Null => {
890                try_push(slice, cursor, 0)?;
891            }
892            Self::Bool(v) => {
893                try_push(slice, cursor, 1)?;
894                v.convert_to_bytes(slice, cursor);
895            }
896            Self::Number(n) => {
897                try_push(slice, cursor, 2)?;
898                if let Some(u) = n.as_u64() {
899                    try_push(slice, cursor, 0)?;
900                    u.try_convert_to_bytes(slice, cursor)?;
901                } else if let Some(i) = n.as_i64() {
902                    try_push(slice, cursor, 1)?;
903                    i.try_convert_to_bytes(slice, cursor)?;
904                } else if let Some(f) = n.as_f64() {
905                    try_push(slice, cursor, 2)?;
906                    f.try_convert_to_bytes(slice, cursor)?;
907                }
908            }
909            Self::String(s) => {
910                try_push(slice, cursor, 3)?;
911                s.try_convert_to_bytes(slice, cursor)?;
912            }
913            Self::Array(a) => {
914                try_push(slice, cursor, 4)?;
915                a.try_convert_to_bytes(slice, cursor)?;
916            }
917            Self::Object(o) => {
918                try_push(slice, cursor, 5)?;
919                let size: u32 = o.len() as u32;
920                size.try_convert_to_bytes(slice, cursor)?;
921                for (k, v) in o.iter() {
922                    k.try_convert_to_bytes(slice, cursor)?;
923                    v.try_convert_to_bytes(slice, cursor)?;
924                }
925            }
926        }
927        Ok(())
928    }
929
930    #[inline]
931    fn size(&self) -> usize {
932        1 + match self {
933            Self::Null => 0,
934            Self::Bool(_) => 1,
935            Self::Number(_) => 1 + 8,
936            Self::String(s) => s.size(),
937            Self::Array(vec) => 4 + vec.iter().fold(0, |acc, item| acc + item.size()),
938            Self::Object(v) => {
939                4 + v
940                    .iter()
941                    .fold(0, |acc, item| acc + item.0.size() + item.1.size())
942            }
943        }
944    }
945}
946
947#[cfg(feature = "rust_decimal")]
948impl crate::Rapira for rust_decimal::Decimal {
949    const STATIC_SIZE: Option<usize> = Some(16);
950    const MIN_SIZE: usize = 16;
951
952    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
953    where
954        Self: Sized,
955    {
956        unsafe {
957            let bytes = <[u8; 16]>::from_slice_unsafe(slice)?;
958            Ok(Self::deserialize(bytes))
959        }
960    }
961
962    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
963    where
964        Self: Sized,
965    {
966        let bytes = <[u8; 16]>::from_slice(slice)?;
967        Ok(Self::deserialize(bytes))
968    }
969
970    fn check_bytes(_: &mut &[u8]) -> crate::Result<()> {
971        Ok(())
972    }
973
974    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
975        self.serialize().convert_to_bytes(slice, cursor);
976    }
977
978    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
979        self.serialize().try_convert_to_bytes(slice, cursor)
980    }
981
982    fn size(&self) -> usize {
983        16
984    }
985}
986
987#[cfg(feature = "compact_str")]
988impl crate::Rapira for compact_str::CompactString {
989    const MIN_SIZE: usize = LEN_SIZE;
990
991    fn size(&self) -> usize {
992        4 + self.len()
993    }
994
995    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()> {
996        crate::str_rapira::check_bytes::<()>(core::marker::PhantomData, slice)
997    }
998
999    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
1000    where
1001        Self: Sized,
1002    {
1003        let s = crate::str_rapira::from_slice(slice)?;
1004        let s = Self::new(s);
1005        Ok(s)
1006    }
1007
1008    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
1009    where
1010        Self: Sized,
1011    {
1012        unsafe {
1013            let s = crate::str_rapira::from_slice_unsafe(slice)?;
1014            let s = Self::new(s);
1015            Ok(s)
1016        }
1017    }
1018
1019    unsafe fn from_slice_unchecked(slice: &mut &[u8]) -> crate::Result<Self>
1020    where
1021        Self: Sized,
1022    {
1023        unsafe {
1024            let s = crate::str_rapira::from_slice_unchecked(slice)?;
1025            let s = Self::new(s);
1026            Ok(s)
1027        }
1028    }
1029
1030    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
1031        crate::str_rapira::convert_to_bytes(self, slice, cursor);
1032    }
1033
1034    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
1035        crate::str_rapira::try_convert_to_bytes(self, slice, cursor)
1036    }
1037}
1038
1039#[cfg(feature = "ecow")]
1040impl crate::Rapira for ecow::EcoString {
1041    const MIN_SIZE: usize = LEN_SIZE;
1042
1043    fn size(&self) -> usize {
1044        4 + self.len()
1045    }
1046
1047    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()> {
1048        crate::str_rapira::check_bytes::<()>(core::marker::PhantomData, slice)
1049    }
1050
1051    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
1052    where
1053        Self: Sized,
1054    {
1055        let s = crate::str_rapira::from_slice(slice)?;
1056        let s = Self::from(s);
1057        Ok(s)
1058    }
1059
1060    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
1061    where
1062        Self: Sized,
1063    {
1064        unsafe {
1065            let s = crate::str_rapira::from_slice_unsafe(slice)?;
1066            let s = Self::from(s);
1067            Ok(s)
1068        }
1069    }
1070
1071    unsafe fn from_slice_unchecked(slice: &mut &[u8]) -> crate::Result<Self>
1072    where
1073        Self: Sized,
1074    {
1075        unsafe {
1076            let s = crate::str_rapira::from_slice_unchecked(slice)?;
1077            let s = Self::from(s);
1078            Ok(s)
1079        }
1080    }
1081
1082    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
1083        crate::str_rapira::convert_to_bytes(self, slice, cursor);
1084    }
1085
1086    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
1087        crate::str_rapira::try_convert_to_bytes(self, slice, cursor)
1088    }
1089}
1090
1091#[cfg(feature = "ecow")]
1092impl<T> crate::Rapira for ecow::EcoVec<T>
1093where
1094    T: crate::Rapira + Clone,
1095{
1096    const MIN_SIZE: usize = LEN_SIZE;
1097
1098    #[inline]
1099    fn size(&self) -> usize {
1100        4 + match T::STATIC_SIZE {
1101            Some(size) => size * self.len(),
1102            None => self.iter().fold(0, |b, v| b + v.size()),
1103        }
1104    }
1105
1106    #[inline]
1107    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()>
1108    where
1109        Self: Sized,
1110    {
1111        let len = u32::from_slice(slice)? as usize;
1112
1113        for _ in 0..len {
1114            T::check_bytes(slice)?;
1115        }
1116
1117        Ok(())
1118    }
1119
1120    #[inline]
1121    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
1122    where
1123        Self: Sized,
1124    {
1125        use crate::max_cap::{SMALLVEC_MAX_CAP, SMALLVEC_MAX_SIZE_OF};
1126
1127        let len = u32::from_slice(slice)? as usize;
1128
1129        if len > SMALLVEC_MAX_CAP {
1130            return Err(crate::RapiraError::MaxCapacity);
1131        }
1132
1133        let size = std::mem::size_of::<Self>() * len;
1134
1135        if size > SMALLVEC_MAX_SIZE_OF {
1136            return Err(crate::RapiraError::MaxSize);
1137        }
1138
1139        let mut vec = Self::with_capacity(len);
1140
1141        for _ in 0..len {
1142            let val = T::from_slice(slice)?;
1143            vec.push(val);
1144        }
1145
1146        Ok(vec)
1147    }
1148
1149    #[inline]
1150    unsafe fn from_slice_unchecked(slice: &mut &[u8]) -> crate::Result<Self>
1151    where
1152        Self: Sized,
1153    {
1154        let len = u32::from_slice(slice)? as usize;
1155        let mut vec = Self::with_capacity(len);
1156
1157        for _ in 0..len {
1158            let val = unsafe { T::from_slice_unchecked(slice)? };
1159            vec.push(val);
1160        }
1161
1162        Ok(vec)
1163    }
1164
1165    #[inline]
1166    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
1167    where
1168        Self: Sized,
1169    {
1170        unsafe {
1171            let len = usize::from_slice_unsafe(slice)?;
1172            let mut vec = Self::with_capacity(len);
1173
1174            let iter = core::iter::repeat_with(|| T::from_slice_unsafe(slice)).take(len);
1175
1176            for item in iter {
1177                let val = item?;
1178                vec.push(val);
1179            }
1180
1181            Ok(vec)
1182        }
1183    }
1184
1185    #[inline]
1186    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
1187        let len = self.len() as u32;
1188        len.try_convert_to_bytes(slice, cursor)?;
1189
1190        for val in self.iter() {
1191            val.try_convert_to_bytes(slice, cursor)?;
1192        }
1193
1194        Ok(())
1195    }
1196
1197    #[inline]
1198    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
1199        let len = self.len() as u32;
1200        len.convert_to_bytes(slice, cursor);
1201
1202        for val in self.iter() {
1203            val.convert_to_bytes(slice, cursor);
1204        }
1205    }
1206}
1207
1208#[cfg(feature = "indexmap")]
1209impl<K: crate::Rapira, V: crate::Rapira, S> crate::Rapira
1210    for indexmap::IndexMap<K, V, core::hash::BuildHasherDefault<S>>
1211where
1212    K: Eq + core::hash::Hash,
1213    S: core::hash::Hasher + core::default::Default,
1214{
1215    const MIN_SIZE: usize = LEN_SIZE;
1216
1217    #[inline]
1218    fn size(&self) -> usize {
1219        if let Some(k) = K::STATIC_SIZE {
1220            if let Some(v) = V::STATIC_SIZE {
1221                4 + (self.len() * (k + v))
1222            } else {
1223                4 + (k * self.len()) + self.iter().fold(0, |b, (_, v)| b + v.size())
1224            }
1225        } else {
1226            4 + self.iter().fold(0, |b, (k, v)| {
1227                b + k.size() + V::STATIC_SIZE.unwrap_or_else(|| v.size())
1228            })
1229        }
1230    }
1231
1232    #[inline]
1233    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()>
1234    where
1235        Self: Sized,
1236    {
1237        let len = u32::from_slice(slice)? as usize;
1238        for _ in 0..len {
1239            K::check_bytes(slice)?;
1240            V::check_bytes(slice)?;
1241        }
1242        Ok(())
1243    }
1244
1245    #[inline]
1246    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
1247    where
1248        Self: Sized,
1249    {
1250        use crate::max_cap::{VEC_MAX_CAP, VEC_MAX_SIZE_OF};
1251
1252        let len = u32::from_slice(slice)? as usize;
1253
1254        if len > VEC_MAX_CAP {
1255            return Err(crate::RapiraError::MaxCapacity);
1256        }
1257
1258        let size = std::mem::size_of::<Self>() * len;
1259
1260        if size > VEC_MAX_SIZE_OF {
1261            return Err(crate::RapiraError::MaxSize);
1262        }
1263
1264        let mut map = Self::with_capacity_and_hasher(len, Default::default());
1265        for _ in 0..len {
1266            let key = K::from_slice(slice)?;
1267            let value = V::from_slice(slice)?;
1268            map.insert(key, value);
1269        }
1270        Ok(map)
1271    }
1272
1273    #[inline]
1274    unsafe fn from_slice_unchecked(slice: &mut &[u8]) -> crate::Result<Self>
1275    where
1276        Self: Sized,
1277    {
1278        let len = u32::from_slice(slice)? as usize;
1279        let mut map = Self::with_capacity_and_hasher(len, Default::default());
1280        for _ in 0..len {
1281            unsafe {
1282                let key = K::from_slice_unchecked(slice)?;
1283                let value = V::from_slice_unchecked(slice)?;
1284                map.insert(key, value);
1285            }
1286        }
1287        Ok(map)
1288    }
1289
1290    #[inline]
1291    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
1292    where
1293        Self: Sized,
1294    {
1295        unsafe {
1296            let len = u32::from_slice_unsafe(slice)? as usize;
1297            let mut map = Self::with_capacity_and_hasher(len, Default::default());
1298            for _ in 0..len {
1299                let key = K::from_slice_unsafe(slice)?;
1300                let value = V::from_slice_unsafe(slice)?;
1301                map.insert(key, value);
1302            }
1303            Ok(map)
1304        }
1305    }
1306
1307    #[inline]
1308    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
1309        let len = self.len() as u32;
1310        len.try_convert_to_bytes(slice, cursor)?;
1311        for (key, value) in self {
1312            key.try_convert_to_bytes(slice, cursor)?;
1313            value.try_convert_to_bytes(slice, cursor)?;
1314        }
1315        Ok(())
1316    }
1317
1318    #[inline]
1319    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
1320        let len = self.len() as u32;
1321        len.convert_to_bytes(slice, cursor);
1322        for (key, value) in self {
1323            key.convert_to_bytes(slice, cursor);
1324            value.convert_to_bytes(slice, cursor);
1325        }
1326    }
1327}
1328
1329#[cfg(feature = "uuid")]
1330impl crate::Rapira for uuid::Uuid {
1331    const STATIC_SIZE: Option<usize> = Some(16);
1332    const MIN_SIZE: usize = 16;
1333
1334    fn size(&self) -> usize {
1335        16
1336    }
1337
1338    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()> {
1339        <[u8; 16]>::check_bytes(slice)
1340    }
1341
1342    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
1343    where
1344        Self: Sized,
1345    {
1346        let bytes = uuid::Bytes::from_slice(slice)?;
1347        Ok(Self::from_bytes(bytes))
1348    }
1349
1350    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
1351    where
1352        Self: Sized,
1353    {
1354        unsafe {
1355            let bytes = <[u8; 16]>::from_slice_unsafe(slice)?;
1356            Ok(Self::from_bytes(bytes))
1357        }
1358    }
1359
1360    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
1361        let bytes = self.as_bytes();
1362        bytes.convert_to_bytes(slice, cursor);
1363    }
1364
1365    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
1366        let bytes = self.as_bytes();
1367        bytes.try_convert_to_bytes(slice, cursor)
1368    }
1369}
1370
1371#[cfg(feature = "time")]
1372impl Rapira for time::Date {
1373    const STATIC_SIZE: Option<usize> = Some(4);
1374    const MIN_SIZE: usize = 4;
1375
1376    fn size(&self) -> usize {
1377        4
1378    }
1379
1380    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()> {
1381        let val = i32::from_slice(slice)?;
1382        Self::from_julian_day(val).map_err(|_| crate::RapiraError::Datetime)?;
1383        Ok(())
1384    }
1385
1386    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
1387    where
1388        Self: Sized,
1389    {
1390        let julian_day = i32::from_slice(slice)?;
1391        Self::from_julian_day(julian_day).map_err(|_| crate::RapiraError::Datetime)
1392    }
1393
1394    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
1395        self.to_julian_day().convert_to_bytes(slice, cursor);
1396    }
1397}
rapira/implements.rs

rapira/
implements.rs
