hipstr/bytes/
convert.rs

1//! Conversion trait implementations for `HipByt`.
2
3use alloc::borrow::Cow;
4use alloc::boxed::Box;
5use alloc::vec::Vec;
6
7use super::HipByt;
8use crate::Backend;
9
10impl<B> AsRef<[u8]> for HipByt<'_, B>
11where
12    B: Backend,
13{
14    #[inline]
15    fn as_ref(&self) -> &[u8] {
16        self.as_slice()
17    }
18}
19
20// Infallible conversions
21
22impl<B> From<&[u8]> for HipByt<'_, B>
23where
24    B: Backend,
25{
26    #[inline]
27    fn from(value: &[u8]) -> Self {
28        Self::from_slice(value)
29    }
30}
31
32impl<B, const N: usize> From<&[u8; N]> for HipByt<'_, B>
33where
34    B: Backend,
35{
36    #[inline]
37    fn from(value: &[u8; N]) -> Self {
38        Self::from_slice(value)
39    }
40}
41
42impl<B> From<Box<[u8]>> for HipByt<'_, B>
43where
44    B: Backend,
45{
46    #[inline]
47    fn from(value: Box<[u8]>) -> Self {
48        Self::normalized_from_vec(value.into_vec())
49    }
50}
51
52impl<B> From<Vec<u8>> for HipByt<'_, B>
53where
54    B: Backend,
55{
56    #[inline]
57    fn from(value: Vec<u8>) -> Self {
58        Self::normalized_from_vec(value)
59    }
60}
61
62impl<'borrow, B> From<Cow<'borrow, [u8]>> for HipByt<'borrow, B>
63where
64    B: Backend,
65{
66    #[inline]
67    fn from(value: Cow<'borrow, [u8]>) -> Self {
68        match value {
69            Cow::Borrowed(borrow) => Self::borrowed(borrow),
70            Cow::Owned(owned) => Self::from(owned),
71        }
72    }
73}
74
75impl<B> From<HipByt<'_, B>> for Vec<u8>
76where
77    B: Backend,
78{
79    #[inline]
80    fn from(value: HipByt<B>) -> Self {
81        value
82            .into_vec()
83            .unwrap_or_else(|err| err.as_slice().to_vec())
84    }
85}
86
87impl<'borrow, B> From<HipByt<'borrow, B>> for Cow<'borrow, [u8]>
88where
89    B: Backend,
90{
91    #[inline]
92    fn from(value: HipByt<'borrow, B>) -> Self {
93        value
94            .into_borrowed()
95            .map_or_else(|value| Cow::Owned(value.into()), Cow::Borrowed)
96    }
97}
98
99// Fallible conversions
100
101// => none for now
102
103#[cfg(test)]
104mod tests {
105    use alloc::borrow::Cow;
106    use alloc::vec;
107    use core::ptr;
108
109    use super::*;
110    use crate::{Arc, HipByt};
111
112    #[test]
113    fn test_as_ref() {
114        let a = HipByt::from(b"abc");
115        assert!(ptr::eq(a.as_slice(), a.as_ref()));
116    }
117
118    #[test]
119    fn test_from() {
120        let a = [32; 32];
121        let v = Vec::from(a);
122        let ptr_v = v.as_ptr();
123        let b: Box<[u8]> = a.into();
124        let ptr_b = b.as_ptr();
125        let c1: Cow<[u8]> = a.as_slice().into();
126        let c2: Cow<[u8]> = Vec::from(a).into();
127        let ptr_c2 = c2.as_ptr();
128
129        let fa = HipByt::from(&a);
130        assert_eq!(fa.as_slice(), &a);
131
132        let fs = HipByt::from(a.as_slice());
133        assert_eq!(fs.as_slice(), &a);
134
135        let fv = HipByt::from(v);
136        assert_eq!(fv.as_slice(), &a);
137        assert!(ptr::eq(fv.as_ptr(), ptr_v));
138
139        let fv = HipByt::from(b);
140        assert_eq!(fv.as_slice(), &a);
141        assert!(ptr::eq(fv.as_ptr(), ptr_b));
142
143        type H<'a> = crate::bytes::HipByt<'a, Arc>;
144        let fc1 = H::from(c1);
145        assert_eq!(fc1.as_slice(), &a);
146
147        let fc2 = H::from(c2);
148        assert_eq!(fc2.as_slice(), &a);
149        assert!(ptr::eq(fc2.as_ptr(), ptr_c2));
150    }
151
152    #[test]
153    fn test_into() {
154        let v = vec![42; 42];
155        let p = v.as_ptr();
156        let a = HipByt::from(v);
157        let v: Vec<_> = a.into();
158        assert_eq!(v.as_ptr(), p);
159
160        let arr = [1, 2, 3];
161        let a = HipByt::from(&arr);
162        let v: Vec<_> = a.into();
163        assert_eq!(v.as_slice(), &arr);
164    }
165
166    #[test]
167    fn test_into_cow() {
168        let h = HipByt::from_static(b"abc");
169        let c: Cow<'static, [u8]> = h.into();
170        assert_eq!(c, Cow::Borrowed(b"abc"));
171
172        let h = HipByt::from(b"abc");
173        let c: Cow<'static, [u8]> = h.into();
174        assert_eq!(c, Cow::<'static, [u8]>::Owned(b"abc".into()));
175    }
176}
hipstr/bytes/convert.rs

hipstr/bytes/
convert.rs
