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 = "bytemuck")]
682pub mod bytemuck {
683    use core::{marker::PhantomData, mem::size_of};
684
685    use bytemuck::{Pod, Zeroable};
686
687    pub const fn static_size<T>(_: PhantomData<T>) -> Option<usize>
688    where
689        T: Sized,
690    {
691        None
692    }
693
694    pub const fn min_size<T>(_: PhantomData<T>) -> usize
695    where
696        T: Sized,
697    {
698        size_of::<T>()
699    }
700
701    #[inline]
702    pub fn size<T>(val: &T) -> usize
703    where
704        T: Sized + Pod + Zeroable,
705    {
706        size_of::<T>()
707    }
708
709    #[inline]
710    pub fn convert_to_bytes<T>(item: &T, slice: &mut [u8], cursor: &mut usize)
711    where
712        T: Immutable + Pod + Zeroable + Sized,
713    {
714        let bytes = bytemuck::bytes_of(item);
715        extend(slice, cursor, bytes);
716    }
717
718    #[inline]
719    pub fn try_convert_to_bytes<T>(
720        item: &T,
721        slice: &mut [u8],
722        cursor: &mut usize,
723    ) -> crate::Result<()>
724    where
725        T: Immutable + Pod + Zeroable + Sized,
726    {
727        let bytes = bytemuck::bytes_of(item);
728        try_extend(slice, cursor, bytes)?;
729        Ok(())
730    }
731
732    #[inline]
733    pub fn convert_from_bytes<T>(slice: &[u8], cursor: &mut usize) -> Option<T>
734    where
735        T: Immutable + Pod + Zeroable + Sized,
736    {
737        let bytes = slice.get(*cursor..*cursor + size_of::<T>())?;
738        *cursor += size_of::<T>();
739        Some(bytemuck::from_bytes(bytes))
740    }
741
742    #[inline]
743    pub fn try_convert_from_bytes<T>(slice: &[u8], cursor: &mut usize) -> crate::Result<T>
744    where
745        T: Immutable + Pod + Zeroable + Sized,
746    {
747        let bytes = slice.get(*cursor..*cursor + size_of::<T>())?;
748        *cursor += size_of::<T>();
749        Ok(bytemuck::from_bytes(bytes))
750    }
751}
752
753#[cfg(feature = "postcard")]
754pub mod postcard {
755    use core::{marker::PhantomData, mem::size_of};
756
757    use postcard::{experimental::serialized_size, take_from_bytes, to_slice};
758    use serde::{Serialize, de::DeserializeOwned};
759
760    pub const fn static_size<T>(_: PhantomData<T>) -> Option<usize>
761    where
762        T: Sized,
763    {
764        None
765    }
766
767    pub const fn min_size<T>(_: PhantomData<T>) -> usize
768    where
769        T: Sized,
770    {
771        size_of::<T>()
772    }
773
774    #[inline]
775    pub fn size<T>(val: &T) -> usize
776    where
777        T: Sized + Serialize,
778    {
779        serialized_size(val).unwrap()
780    }
781
782    #[inline]
783    pub fn check_bytes<T>(_: PhantomData<T>, slice: &mut &[u8]) -> crate::Result<()>
784    where
785        T: Sized + DeserializeOwned,
786    {
787        let (_, rem) = take_from_bytes::<T>(slice)?;
788        *slice = rem;
789
790        Ok(())
791    }
792
793    #[inline]
794    pub fn from_slice<T>(slice: &mut &[u8]) -> crate::Result<T>
795    where
796        T: DeserializeOwned + Sized,
797    {
798        let (val, rem) = take_from_bytes::<T>(slice)?;
799        *slice = rem;
800        Ok(val)
801    }
802
803    #[inline]
804    pub fn from_slice_unchecked<T>(slice: &mut &[u8]) -> crate::Result<T>
805    where
806        T: DeserializeOwned + Sized,
807    {
808        from_slice(slice)
809    }
810
811    /// .
812    ///
813    /// # Panics
814    ///
815    /// Panics if .
816    ///
817    /// # Errors
818    ///
819    /// This function will return an error if .
820    ///
821    /// # Safety
822    ///
823    /// .
824    #[inline]
825    pub unsafe fn from_slice_unsafe<T>(slice: &mut &[u8]) -> crate::Result<T>
826    where
827        T: DeserializeOwned + Sized,
828    {
829        from_slice(slice)
830    }
831
832    #[inline]
833    pub fn convert_to_bytes<T>(item: &T, slice: &mut [u8], cursor: &mut usize)
834    where
835        T: Serialize + Sized,
836    {
837        let bytes = slice.get_mut(*cursor..).unwrap();
838        let data = to_slice(item, bytes).unwrap();
839        *cursor += data.len();
840    }
841
842    #[inline]
843    pub fn try_convert_to_bytes<T>(
844        item: &T,
845        slice: &mut [u8],
846        cursor: &mut usize,
847    ) -> crate::Result<()>
848    where
849        T: Serialize + Sized,
850    {
851        let bytes = slice
852            .get_mut(*cursor..)
853            .ok_or(crate::RapiraError::SliceLen)?;
854        let data = to_slice(item, bytes)?;
855        *cursor += data.len();
856        Ok(())
857    }
858}
859
860#[cfg(feature = "serde_json")]
861impl crate::Rapira for serde_json::Value {
862    const MIN_SIZE: usize = 1;
863
864    #[inline]
865    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
866    where
867        Self: Sized,
868    {
869        use serde_json::{Map, Number, Value};
870
871        use crate::byte_rapira;
872
873        let byte = byte_rapira::from_slice(slice)?;
874        match byte {
875            0 => Ok(Value::Null),
876            1 => {
877                let b = bool::from_slice(slice)?;
878                Ok(Value::Bool(b))
879            }
880            2 => {
881                let byte = byte_rapira::from_slice(slice)?;
882                if byte == 0 {
883                    let u = u64::from_slice(slice)?;
884                    Ok(Value::Number(u.into()))
885                } else if byte == 1 {
886                    let i = i64::from_slice(slice)?;
887                    Ok(Value::Number(i.into()))
888                } else if byte == 2 {
889                    let f = f64::from_slice(slice)?;
890                    let number = Number::from_f64(f).ok_or(crate::RapiraError::FloatIsNaN)?;
891                    Ok(Value::Number(number))
892                } else {
893                    Err(crate::RapiraError::EnumVariant)
894                }
895            }
896            3 => {
897                let s = String::from_slice(slice)?;
898                Ok(Value::String(s))
899            }
900            4 => {
901                let vec = Vec::<Value>::from_slice(slice)?;
902                Ok(Value::Array(vec))
903            }
904            5 => {
905                let len = u32::from_slice(slice)? as usize;
906                let mut map = Map::new();
907                for _ in 0..len {
908                    let key = String::from_slice(slice)?;
909                    let val = Value::from_slice(slice)?;
910                    map.insert(key, val);
911                }
912                Ok(Value::Object(map))
913            }
914            _ => Err(crate::RapiraError::EnumVariant),
915        }
916    }
917
918    #[inline]
919    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()>
920    where
921        Self: Sized,
922    {
923        use crate::byte_rapira;
924
925        let byte = byte_rapira::from_slice(slice)?;
926        match byte {
927            0 => {}
928            1 => {
929                bool::check_bytes(slice)?;
930            }
931            2 => {
932                let byte = byte_rapira::from_slice(slice)?;
933                if byte == 0 {
934                    u64::check_bytes(slice)?;
935                } else if byte == 1 {
936                    i64::check_bytes(slice)?;
937                } else if byte == 2 {
938                    f64::check_bytes(slice)?;
939                } else {
940                    return Err(crate::RapiraError::EnumVariant);
941                }
942            }
943            3 => {
944                String::check_bytes(slice)?;
945            }
946            4 => {
947                Vec::<Self>::check_bytes(slice)?;
948            }
949            5 => {
950                let len = u32::from_slice(slice)? as usize;
951                for _ in 0..len {
952                    String::check_bytes(slice)?;
953                    Self::check_bytes(slice)?;
954                }
955            }
956            _ => return Err(crate::RapiraError::EnumVariant),
957        }
958
959        Ok(())
960    }
961
962    #[inline]
963    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
964    where
965        Self: Sized,
966    {
967        use serde_json::{Map, Number};
968
969        use crate::byte_rapira;
970
971        unsafe {
972            let byte = byte_rapira::from_slice_unsafe(slice)?;
973            match byte {
974                0 => Ok(Self::Null),
975                1 => {
976                    let b = bool::from_slice_unsafe(slice)?;
977                    Ok(Self::Bool(b))
978                }
979                2 => {
980                    let byte = byte_rapira::from_slice_unsafe(slice)?;
981                    if byte == 0 {
982                        let u = u64::from_slice_unsafe(slice)?;
983                        Ok(Self::Number(u.into()))
984                    } else if byte == 1 {
985                        let i = i64::from_slice_unsafe(slice)?;
986                        Ok(Self::Number(i.into()))
987                    } else if byte == 2 {
988                        let f = f64::from_slice_unsafe(slice)?;
989                        let number = Number::from_f64(f).ok_or(crate::RapiraError::FloatIsNaN)?;
990                        Ok(Self::Number(number))
991                    } else {
992                        Err(crate::RapiraError::EnumVariant)
993                    }
994                }
995                3 => {
996                    let s = String::from_slice_unsafe(slice)?;
997                    Ok(Self::String(s))
998                }
999                4 => {
1000                    let vec = Vec::<Self>::from_slice_unsafe(slice)?;
1001                    Ok(Self::Array(vec))
1002                }
1003                5 => {
1004                    let len = usize::from_slice_unsafe(slice)?;
1005                    let mut map = Map::new();
1006                    for _ in 0..len {
1007                        let key = String::from_slice_unsafe(slice)?;
1008                        let val = Self::from_slice_unsafe(slice)?;
1009                        map.insert(key, val);
1010                    }
1011                    Ok(Self::Object(map))
1012                }
1013                _ => Err(crate::RapiraError::EnumVariant),
1014            }
1015        }
1016    }
1017
1018    #[inline]
1019    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
1020        use crate::push;
1021
1022        match self {
1023            Self::Null => {
1024                push(slice, cursor, 0);
1025            }
1026            Self::Bool(v) => {
1027                push(slice, cursor, 1);
1028                v.convert_to_bytes(slice, cursor);
1029            }
1030            Self::Number(n) => {
1031                push(slice, cursor, 2);
1032                if let Some(u) = n.as_u64() {
1033                    push(slice, cursor, 0);
1034                    u.convert_to_bytes(slice, cursor);
1035                } else if let Some(i) = n.as_i64() {
1036                    push(slice, cursor, 1);
1037                    i.convert_to_bytes(slice, cursor);
1038                } else if let Some(f) = n.as_f64() {
1039                    push(slice, cursor, 2);
1040                    f.convert_to_bytes(slice, cursor);
1041                }
1042            }
1043            Self::String(s) => {
1044                push(slice, cursor, 3);
1045                s.convert_to_bytes(slice, cursor);
1046            }
1047            Self::Array(a) => {
1048                push(slice, cursor, 4);
1049                a.convert_to_bytes(slice, cursor);
1050            }
1051            Self::Object(o) => {
1052                push(slice, cursor, 5);
1053                let size: u32 = o.len() as u32;
1054                size.convert_to_bytes(slice, cursor);
1055                o.iter().for_each(|(k, v)| {
1056                    k.convert_to_bytes(slice, cursor);
1057                    v.convert_to_bytes(slice, cursor);
1058                });
1059            }
1060        }
1061    }
1062
1063    #[inline]
1064    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
1065        use crate::try_push;
1066
1067        match self {
1068            Self::Null => {
1069                try_push(slice, cursor, 0)?;
1070            }
1071            Self::Bool(v) => {
1072                try_push(slice, cursor, 1)?;
1073                v.convert_to_bytes(slice, cursor);
1074            }
1075            Self::Number(n) => {
1076                try_push(slice, cursor, 2)?;
1077                if let Some(u) = n.as_u64() {
1078                    try_push(slice, cursor, 0)?;
1079                    u.try_convert_to_bytes(slice, cursor)?;
1080                } else if let Some(i) = n.as_i64() {
1081                    try_push(slice, cursor, 1)?;
1082                    i.try_convert_to_bytes(slice, cursor)?;
1083                } else if let Some(f) = n.as_f64() {
1084                    try_push(slice, cursor, 2)?;
1085                    f.try_convert_to_bytes(slice, cursor)?;
1086                }
1087            }
1088            Self::String(s) => {
1089                try_push(slice, cursor, 3)?;
1090                s.try_convert_to_bytes(slice, cursor)?;
1091            }
1092            Self::Array(a) => {
1093                try_push(slice, cursor, 4)?;
1094                a.try_convert_to_bytes(slice, cursor)?;
1095            }
1096            Self::Object(o) => {
1097                try_push(slice, cursor, 5)?;
1098                let size: u32 = o.len() as u32;
1099                size.try_convert_to_bytes(slice, cursor)?;
1100                for (k, v) in o.iter() {
1101                    k.try_convert_to_bytes(slice, cursor)?;
1102                    v.try_convert_to_bytes(slice, cursor)?;
1103                }
1104            }
1105        }
1106        Ok(())
1107    }
1108
1109    #[inline]
1110    fn size(&self) -> usize {
1111        1 + match self {
1112            Self::Null => 0,
1113            Self::Bool(_) => 1,
1114            Self::Number(_) => 1 + 8,
1115            Self::String(s) => s.size(),
1116            Self::Array(vec) => 4 + vec.iter().fold(0, |acc, item| acc + item.size()),
1117            Self::Object(v) => {
1118                4 + v
1119                    .iter()
1120                    .fold(0, |acc, item| acc + item.0.size() + item.1.size())
1121            }
1122        }
1123    }
1124}
1125
1126#[cfg(feature = "rust_decimal")]
1127impl crate::Rapira for rust_decimal::Decimal {
1128    const STATIC_SIZE: Option<usize> = Some(16);
1129    const MIN_SIZE: usize = 16;
1130
1131    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
1132    where
1133        Self: Sized,
1134    {
1135        unsafe {
1136            let bytes = <[u8; 16]>::from_slice_unsafe(slice)?;
1137            Ok(Self::deserialize(bytes))
1138        }
1139    }
1140
1141    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
1142    where
1143        Self: Sized,
1144    {
1145        let bytes = <[u8; 16]>::from_slice(slice)?;
1146        Ok(Self::deserialize(bytes))
1147    }
1148
1149    fn check_bytes(_: &mut &[u8]) -> crate::Result<()> {
1150        Ok(())
1151    }
1152
1153    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
1154        self.serialize().convert_to_bytes(slice, cursor);
1155    }
1156
1157    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
1158        self.serialize().try_convert_to_bytes(slice, cursor)
1159    }
1160
1161    fn size(&self) -> usize {
1162        16
1163    }
1164}
1165
1166#[cfg(feature = "compact_str")]
1167impl crate::Rapira for compact_str::CompactString {
1168    const MIN_SIZE: usize = LEN_SIZE;
1169
1170    fn size(&self) -> usize {
1171        4 + self.len()
1172    }
1173
1174    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()> {
1175        crate::str_rapira::check_bytes::<()>(core::marker::PhantomData, slice)
1176    }
1177
1178    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
1179    where
1180        Self: Sized,
1181    {
1182        let s = crate::str_rapira::from_slice(slice)?;
1183        let s = Self::new(s);
1184        Ok(s)
1185    }
1186
1187    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
1188    where
1189        Self: Sized,
1190    {
1191        unsafe {
1192            let s = crate::str_rapira::from_slice_unsafe(slice)?;
1193            let s = Self::new(s);
1194            Ok(s)
1195        }
1196    }
1197
1198    unsafe fn from_slice_unchecked(slice: &mut &[u8]) -> crate::Result<Self>
1199    where
1200        Self: Sized,
1201    {
1202        unsafe {
1203            let s = crate::str_rapira::from_slice_unchecked(slice)?;
1204            let s = Self::new(s);
1205            Ok(s)
1206        }
1207    }
1208
1209    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
1210        crate::str_rapira::convert_to_bytes(self, slice, cursor);
1211    }
1212
1213    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
1214        crate::str_rapira::try_convert_to_bytes(self, slice, cursor)
1215    }
1216}
1217
1218#[cfg(feature = "smol_str")]
1219impl crate::Rapira for smol_str::SmolStr {
1220    const MIN_SIZE: usize = LEN_SIZE;
1221
1222    fn size(&self) -> usize {
1223        4 + self.len()
1224    }
1225
1226    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()> {
1227        crate::str_rapira::check_bytes::<()>(core::marker::PhantomData, slice)
1228    }
1229
1230    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
1231    where
1232        Self: Sized,
1233    {
1234        let s = crate::str_rapira::from_slice(slice)?;
1235        let s = Self::new(s);
1236        Ok(s)
1237    }
1238
1239    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
1240    where
1241        Self: Sized,
1242    {
1243        unsafe {
1244            let s = crate::str_rapira::from_slice_unsafe(slice)?;
1245            let s = Self::new(s);
1246            Ok(s)
1247        }
1248    }
1249
1250    unsafe fn from_slice_unchecked(slice: &mut &[u8]) -> crate::Result<Self>
1251    where
1252        Self: Sized,
1253    {
1254        unsafe {
1255            let s = crate::str_rapira::from_slice_unchecked(slice)?;
1256            let s = Self::new(s);
1257            Ok(s)
1258        }
1259    }
1260
1261    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
1262        crate::str_rapira::convert_to_bytes(self, slice, cursor);
1263    }
1264
1265    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
1266        crate::str_rapira::try_convert_to_bytes(self, slice, cursor)
1267    }
1268}
1269
1270#[cfg(feature = "ecow")]
1271impl crate::Rapira for ecow::EcoString {
1272    const MIN_SIZE: usize = LEN_SIZE;
1273
1274    fn size(&self) -> usize {
1275        4 + self.len()
1276    }
1277
1278    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()> {
1279        crate::str_rapira::check_bytes::<()>(core::marker::PhantomData, slice)
1280    }
1281
1282    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
1283    where
1284        Self: Sized,
1285    {
1286        let s = crate::str_rapira::from_slice(slice)?;
1287        let s = Self::from(s);
1288        Ok(s)
1289    }
1290
1291    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
1292    where
1293        Self: Sized,
1294    {
1295        unsafe {
1296            let s = crate::str_rapira::from_slice_unsafe(slice)?;
1297            let s = Self::from(s);
1298            Ok(s)
1299        }
1300    }
1301
1302    unsafe fn from_slice_unchecked(slice: &mut &[u8]) -> crate::Result<Self>
1303    where
1304        Self: Sized,
1305    {
1306        unsafe {
1307            let s = crate::str_rapira::from_slice_unchecked(slice)?;
1308            let s = Self::from(s);
1309            Ok(s)
1310        }
1311    }
1312
1313    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
1314        crate::str_rapira::convert_to_bytes(self, slice, cursor);
1315    }
1316
1317    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
1318        crate::str_rapira::try_convert_to_bytes(self, slice, cursor)
1319    }
1320}
1321
1322#[cfg(feature = "ecow")]
1323impl<T> crate::Rapira for ecow::EcoVec<T>
1324where
1325    T: crate::Rapira + Clone,
1326{
1327    const MIN_SIZE: usize = LEN_SIZE;
1328
1329    #[inline]
1330    fn size(&self) -> usize {
1331        4 + match T::STATIC_SIZE {
1332            Some(size) => size * self.len(),
1333            None => self.iter().fold(0, |b, v| b + v.size()),
1334        }
1335    }
1336
1337    #[inline]
1338    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()>
1339    where
1340        Self: Sized,
1341    {
1342        let len = u32::from_slice(slice)? as usize;
1343
1344        for _ in 0..len {
1345            T::check_bytes(slice)?;
1346        }
1347
1348        Ok(())
1349    }
1350
1351    #[inline]
1352    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
1353    where
1354        Self: Sized,
1355    {
1356        use crate::max_cap::{SMALLVEC_MAX_CAP, SMALLVEC_MAX_SIZE_OF};
1357
1358        let len = u32::from_slice(slice)? as usize;
1359
1360        if len > SMALLVEC_MAX_CAP {
1361            return Err(crate::RapiraError::MaxCapacity);
1362        }
1363
1364        let size = std::mem::size_of::<Self>() * len;
1365
1366        if size > SMALLVEC_MAX_SIZE_OF {
1367            return Err(crate::RapiraError::MaxSize);
1368        }
1369
1370        let mut vec = Self::with_capacity(len);
1371
1372        for _ in 0..len {
1373            let val = T::from_slice(slice)?;
1374            vec.push(val);
1375        }
1376
1377        Ok(vec)
1378    }
1379
1380    #[inline]
1381    unsafe fn from_slice_unchecked(slice: &mut &[u8]) -> crate::Result<Self>
1382    where
1383        Self: Sized,
1384    {
1385        let len = u32::from_slice(slice)? as usize;
1386        let mut vec = Self::with_capacity(len);
1387
1388        for _ in 0..len {
1389            let val = unsafe { T::from_slice_unchecked(slice)? };
1390            vec.push(val);
1391        }
1392
1393        Ok(vec)
1394    }
1395
1396    #[inline]
1397    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
1398    where
1399        Self: Sized,
1400    {
1401        unsafe {
1402            let len = usize::from_slice_unsafe(slice)?;
1403            let mut vec = Self::with_capacity(len);
1404
1405            let iter = core::iter::repeat_with(|| T::from_slice_unsafe(slice)).take(len);
1406
1407            for item in iter {
1408                let val = item?;
1409                vec.push(val);
1410            }
1411
1412            Ok(vec)
1413        }
1414    }
1415
1416    #[inline]
1417    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
1418        let len = self.len() as u32;
1419        len.try_convert_to_bytes(slice, cursor)?;
1420
1421        for val in self.iter() {
1422            val.try_convert_to_bytes(slice, cursor)?;
1423        }
1424
1425        Ok(())
1426    }
1427
1428    #[inline]
1429    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
1430        let len = self.len() as u32;
1431        len.convert_to_bytes(slice, cursor);
1432
1433        for val in self.iter() {
1434            val.convert_to_bytes(slice, cursor);
1435        }
1436    }
1437}
1438
1439#[cfg(feature = "indexmap")]
1440impl<K: crate::Rapira, V: crate::Rapira, S> crate::Rapira
1441    for indexmap::IndexMap<K, V, core::hash::BuildHasherDefault<S>>
1442where
1443    K: Eq + core::hash::Hash,
1444    S: core::hash::Hasher + core::default::Default,
1445{
1446    const MIN_SIZE: usize = LEN_SIZE;
1447
1448    #[inline]
1449    fn size(&self) -> usize {
1450        if let Some(k) = K::STATIC_SIZE {
1451            if let Some(v) = V::STATIC_SIZE {
1452                4 + (self.len() * (k + v))
1453            } else {
1454                4 + (k * self.len()) + self.iter().fold(0, |b, (_, v)| b + v.size())
1455            }
1456        } else {
1457            4 + self.iter().fold(0, |b, (k, v)| {
1458                b + k.size() + V::STATIC_SIZE.unwrap_or_else(|| v.size())
1459            })
1460        }
1461    }
1462
1463    #[inline]
1464    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()>
1465    where
1466        Self: Sized,
1467    {
1468        let len = u32::from_slice(slice)? as usize;
1469        for _ in 0..len {
1470            K::check_bytes(slice)?;
1471            V::check_bytes(slice)?;
1472        }
1473        Ok(())
1474    }
1475
1476    #[inline]
1477    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
1478    where
1479        Self: Sized,
1480    {
1481        use crate::max_cap::{VEC_MAX_CAP, VEC_MAX_SIZE_OF};
1482
1483        let len = u32::from_slice(slice)? as usize;
1484
1485        if len > VEC_MAX_CAP {
1486            return Err(crate::RapiraError::MaxCapacity);
1487        }
1488
1489        let size = std::mem::size_of::<Self>() * len;
1490
1491        if size > VEC_MAX_SIZE_OF {
1492            return Err(crate::RapiraError::MaxSize);
1493        }
1494
1495        let mut map = Self::with_capacity_and_hasher(len, Default::default());
1496        for _ in 0..len {
1497            let key = K::from_slice(slice)?;
1498            let value = V::from_slice(slice)?;
1499            map.insert(key, value);
1500        }
1501        Ok(map)
1502    }
1503
1504    #[inline]
1505    unsafe fn from_slice_unchecked(slice: &mut &[u8]) -> crate::Result<Self>
1506    where
1507        Self: Sized,
1508    {
1509        let len = u32::from_slice(slice)? as usize;
1510        let mut map = Self::with_capacity_and_hasher(len, Default::default());
1511        for _ in 0..len {
1512            unsafe {
1513                let key = K::from_slice_unchecked(slice)?;
1514                let value = V::from_slice_unchecked(slice)?;
1515                map.insert(key, value);
1516            }
1517        }
1518        Ok(map)
1519    }
1520
1521    #[inline]
1522    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
1523    where
1524        Self: Sized,
1525    {
1526        unsafe {
1527            let len = u32::from_slice_unsafe(slice)? as usize;
1528            let mut map = Self::with_capacity_and_hasher(len, Default::default());
1529            for _ in 0..len {
1530                let key = K::from_slice_unsafe(slice)?;
1531                let value = V::from_slice_unsafe(slice)?;
1532                map.insert(key, value);
1533            }
1534            Ok(map)
1535        }
1536    }
1537
1538    #[inline]
1539    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
1540        let len = self.len() as u32;
1541        len.try_convert_to_bytes(slice, cursor)?;
1542        for (key, value) in self {
1543            key.try_convert_to_bytes(slice, cursor)?;
1544            value.try_convert_to_bytes(slice, cursor)?;
1545        }
1546        Ok(())
1547    }
1548
1549    #[inline]
1550    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
1551        let len = self.len() as u32;
1552        len.convert_to_bytes(slice, cursor);
1553        for (key, value) in self {
1554            key.convert_to_bytes(slice, cursor);
1555            value.convert_to_bytes(slice, cursor);
1556        }
1557    }
1558}
1559
1560#[cfg(feature = "uuid")]
1561impl crate::Rapira for uuid::Uuid {
1562    const STATIC_SIZE: Option<usize> = Some(16);
1563    const MIN_SIZE: usize = 16;
1564
1565    fn size(&self) -> usize {
1566        16
1567    }
1568
1569    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()> {
1570        <[u8; 16]>::check_bytes(slice)
1571    }
1572
1573    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
1574    where
1575        Self: Sized,
1576    {
1577        let bytes = uuid::Bytes::from_slice(slice)?;
1578        Ok(Self::from_bytes(bytes))
1579    }
1580
1581    unsafe fn from_slice_unsafe(slice: &mut &[u8]) -> crate::Result<Self>
1582    where
1583        Self: Sized,
1584    {
1585        unsafe {
1586            let bytes = <[u8; 16]>::from_slice_unsafe(slice)?;
1587            Ok(Self::from_bytes(bytes))
1588        }
1589    }
1590
1591    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
1592        let bytes = self.as_bytes();
1593        bytes.convert_to_bytes(slice, cursor);
1594    }
1595
1596    fn try_convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) -> crate::Result<()> {
1597        let bytes = self.as_bytes();
1598        bytes.try_convert_to_bytes(slice, cursor)
1599    }
1600}
1601
1602#[cfg(feature = "time")]
1603impl Rapira for time::Date {
1604    const STATIC_SIZE: Option<usize> = Some(4);
1605    const MIN_SIZE: usize = 4;
1606
1607    fn size(&self) -> usize {
1608        4
1609    }
1610
1611    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()> {
1612        let val = i32::from_slice(slice)?;
1613        Self::from_julian_day(val).map_err(|_| crate::RapiraError::Datetime)?;
1614        Ok(())
1615    }
1616
1617    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
1618    where
1619        Self: Sized,
1620    {
1621        let julian_day = i32::from_slice(slice)?;
1622        Self::from_julian_day(julian_day).map_err(|_| crate::RapiraError::Datetime)
1623    }
1624
1625    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
1626        self.to_julian_day().convert_to_bytes(slice, cursor);
1627    }
1628}
1629
1630#[cfg(feature = "solana")]
1631impl Rapira for solana_pubkey::Pubkey {
1632    const STATIC_SIZE: Option<usize> = Some(32);
1633    const MIN_SIZE: usize = 32;
1634
1635    fn size(&self) -> usize {
1636        32
1637    }
1638
1639    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()> {
1640        <[u8; 32]>::check_bytes(slice)
1641    }
1642
1643    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
1644    where
1645        Self: Sized,
1646    {
1647        let bytes = <[u8; 32]>::from_slice(slice)?;
1648        Ok(Self::from(bytes))
1649    }
1650
1651    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
1652        self.as_array().convert_to_bytes(slice, cursor);
1653    }
1654}
1655
1656#[cfg(feature = "solana")]
1657impl Rapira for solana_signature::Signature {
1658    const STATIC_SIZE: Option<usize> = Some(64);
1659    const MIN_SIZE: usize = 64;
1660
1661    fn size(&self) -> usize {
1662        64
1663    }
1664
1665    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()> {
1666        <[u8; 64]>::check_bytes(slice)
1667    }
1668
1669    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
1670    where
1671        Self: Sized,
1672    {
1673        let bytes = <[u8; 64]>::from_slice(slice)?;
1674        Ok(Self::from(bytes))
1675    }
1676
1677    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
1678        let end = *cursor + 64;
1679        slice[*cursor..end].copy_from_slice(self.as_ref());
1680        *cursor = end;
1681    }
1682}
1683
1684#[cfg(feature = "rmp")]
1685impl Rapira for rmpv::Value {
1686    const MIN_SIZE: usize = 1;
1687
1688    fn size(&self) -> usize {
1689        1 + match self {
1690            rmpv::Value::Nil => 0,
1691            rmpv::Value::Boolean(_) => 1,
1692            rmpv::Value::Integer(_) => 8,
1693            rmpv::Value::F32(_) => 4,
1694            rmpv::Value::F64(_) => 8,
1695            rmpv::Value::String(s) => 4 + s.as_bytes().len(),
1696            rmpv::Value::Binary(items) => Rapira::size(items),
1697            rmpv::Value::Array(values) => Rapira::size(values),
1698            rmpv::Value::Map(items) => Rapira::size(items),
1699            rmpv::Value::Ext(_, items) => 1 + Rapira::size(items),
1700        }
1701    }
1702
1703    fn check_bytes(slice: &mut &[u8]) -> crate::Result<()> {
1704        todo!()
1705    }
1706
1707    fn from_slice(slice: &mut &[u8]) -> crate::Result<Self>
1708    where
1709        Self: Sized,
1710    {
1711        todo!()
1712    }
1713
1714    fn convert_to_bytes(&self, slice: &mut [u8], cursor: &mut usize) {
1715        todo!()
1716    }
1717}
rapira/implements.rs

rapira/
implements.rs
