spinoso_string/enc/utf8/owned/
impls.rs

1use alloc::borrow::{Cow, ToOwned};
2use alloc::string::String;
3use alloc::vec::Vec;
4use core::borrow::Borrow;
5use core::fmt;
6use core::ops::{Deref, DerefMut};
7
8use super::{Utf8Str, Utf8String};
9use crate::Buf;
10
11impl Default for Utf8String {
12    #[inline]
13    fn default() -> Self {
14        Utf8String::empty()
15    }
16}
17
18impl fmt::Debug for Utf8String {
19    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
20        use bstr::ByteSlice;
21
22        f.debug_struct("Utf8String")
23            .field("buf", &self.as_bytes().as_bstr())
24            .finish()
25    }
26}
27
28impl Clone for Utf8String {
29    fn clone(&self) -> Self {
30        Self::new(self.inner.clone())
31    }
32
33    fn clone_from(&mut self, source: &Self) {
34        self.clear();
35        let bytes = source.as_bytes();
36        self.extend_from_slice(bytes);
37    }
38}
39
40impl Deref for Utf8String {
41    type Target = Utf8Str;
42
43    fn deref(&self) -> &Self::Target {
44        self.as_utf8_str()
45    }
46}
47
48impl DerefMut for Utf8String {
49    fn deref_mut(&mut self) -> &mut Self::Target {
50        self.as_mut_utf8_str()
51    }
52}
53
54impl Borrow<[u8]> for Utf8String {
55    fn borrow(&self) -> &[u8] {
56        self.as_bytes()
57    }
58}
59
60impl Borrow<Utf8Str> for Utf8String {
61    fn borrow(&self) -> &Utf8Str {
62        self.as_utf8_str()
63    }
64}
65
66impl ToOwned for Utf8Str {
67    type Owned = Utf8String;
68
69    fn to_owned(&self) -> Self::Owned {
70        Self::Owned::from(self)
71    }
72
73    fn clone_into(&self, target: &mut Self::Owned) {
74        target.clear();
75        target.extend(self.as_bytes());
76    }
77}
78
79impl AsRef<[u8]> for Utf8String {
80    #[inline]
81    fn as_ref(&self) -> &[u8] {
82        self.as_bytes()
83    }
84}
85
86impl AsMut<[u8]> for Utf8String {
87    #[inline]
88    fn as_mut(&mut self) -> &mut [u8] {
89        self.as_bytes_mut()
90    }
91}
92
93impl AsRef<Utf8Str> for Utf8String {
94    #[inline]
95    fn as_ref(&self) -> &Utf8Str {
96        self.as_utf8_str()
97    }
98}
99
100impl AsMut<Utf8Str> for Utf8String {
101    #[inline]
102    fn as_mut(&mut self) -> &mut Utf8Str {
103        self.as_mut_utf8_str()
104    }
105}
106
107impl Extend<u8> for Utf8String {
108    #[inline]
109    fn extend<I: IntoIterator<Item = u8>>(&mut self, iter: I) {
110        self.inner.extend(iter);
111    }
112}
113
114impl<'a> Extend<&'a u8> for Utf8String {
115    #[inline]
116    fn extend<I: IntoIterator<Item = &'a u8>>(&mut self, iter: I) {
117        self.inner.extend(iter);
118    }
119}
120
121impl From<Buf> for Utf8String {
122    #[inline]
123    fn from(content: Buf) -> Self {
124        Self::new(content)
125    }
126}
127
128impl From<Vec<u8>> for Utf8String {
129    #[inline]
130    fn from(content: Vec<u8>) -> Self {
131        Self::new(content.into())
132    }
133}
134
135impl<const N: usize> From<[u8; N]> for Utf8String {
136    #[inline]
137    fn from(content: [u8; N]) -> Self {
138        Self::new(content.into())
139    }
140}
141
142impl<const N: usize> From<&[u8; N]> for Utf8String {
143    #[inline]
144    fn from(content: &[u8; N]) -> Self {
145        Self::new(content.into())
146    }
147}
148
149impl From<&[u8]> for Utf8String {
150    #[inline]
151    fn from(content: &[u8]) -> Self {
152        Self::new(content.into())
153    }
154}
155
156impl From<&mut [u8]> for Utf8String {
157    #[inline]
158    fn from(content: &mut [u8]) -> Self {
159        Self::new(content.into())
160    }
161}
162
163impl<'a> From<Cow<'a, [u8]>> for Utf8String {
164    #[inline]
165    fn from(content: Cow<'a, [u8]>) -> Self {
166        Self::new(content.into())
167    }
168}
169
170impl From<String> for Utf8String {
171    #[inline]
172    fn from(content: String) -> Self {
173        Self::new(content.into())
174    }
175}
176
177impl From<&str> for Utf8String {
178    #[inline]
179    fn from(content: &str) -> Self {
180        Self::new(content.into())
181    }
182}
183
184impl<'a> From<Cow<'a, str>> for Utf8String {
185    #[inline]
186    fn from(content: Cow<'a, str>) -> Self {
187        Self::new(content.into())
188    }
189}
190
191impl From<&Utf8Str> for Utf8String {
192    #[inline]
193    fn from(content: &Utf8Str) -> Self {
194        Self::new(content.as_bytes().into())
195    }
196}
197
198impl<'a> From<Cow<'a, Utf8Str>> for Utf8String {
199    #[inline]
200    fn from(content: Cow<'a, Utf8Str>) -> Self {
201        content.into_owned()
202    }
203}
204
205impl From<Utf8String> for Buf {
206    #[inline]
207    fn from(content: Utf8String) -> Self {
208        content.into_buf()
209    }
210}
211
212impl From<Utf8String> for Vec<u8> {
213    #[inline]
214    fn from(content: Utf8String) -> Self {
215        content.into_buf().into_inner()
216    }
217}
218
219impl<const N: usize> TryFrom<Utf8String> for [u8; N] {
220    type Error = Utf8String;
221
222    #[inline]
223    fn try_from(content: Utf8String) -> Result<Self, Self::Error> {
224        match content.into_buf().into_inner().try_into() {
225            Ok(array) => Ok(array),
226            Err(vec) => Err(vec.into()),
227        }
228    }
229}
230
231impl From<Utf8String> for Cow<'_, [u8]> {
232    #[inline]
233    fn from(content: Utf8String) -> Self {
234        let buf = content.into();
235        Cow::Owned(buf)
236    }
237}
238
239impl TryFrom<Utf8String> for String {
240    type Error = Utf8String;
241
242    #[inline]
243    fn try_from(s: Utf8String) -> Result<Self, Self::Error> {
244        if s.is_valid_encoding() {
245            let vec = s.into();
246            // SAFETY: `is_valid_encoding` only returns true if the byte
247            // content of the `Utf8String` is valid UTF-8.
248            let s = unsafe { String::from_utf8_unchecked(vec) };
249            Ok(s)
250        } else {
251            Err(s)
252        }
253    }
254}
255
256impl TryFrom<Utf8String> for Cow<'_, str> {
257    type Error = Utf8String;
258
259    #[inline]
260    fn try_from(content: Utf8String) -> Result<Self, Self::Error> {
261        let s = content.try_into()?;
262        Ok(Cow::Owned(s))
263    }
264}
265
266impl From<Utf8String> for Cow<'_, Utf8Str> {
267    #[inline]
268    fn from(content: Utf8String) -> Self {
269        Cow::Owned(content)
270    }
271}
spinoso_string/enc/utf8/owned/impls.rs

spinoso_string/enc/utf8/owned/
impls.rs
