1#[macro_export]
3#[doc(hidden)]
4macro_rules! manual_braid {
5 (
6 $(#[$meta:meta])*
7
8 $vis:vis struct $Owned:ident;
9 $(#[$_unused_meta:meta])*
10 $visref:vis struct $Borrowed:ident;
11
12 ) => {
13 manual_braid! {
14 @common
15
16 $(#[$meta])*
17
18 $vis struct $Owned;
19 $(#[$_unused_meta])*
20 $visref struct $Borrowed;
21 }
22
23 impl ::std::fmt::Debug for $Owned {
24 #[inline]
25 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
26 <$Borrowed as ::std::fmt::Debug>::fmt(::std::ops::Deref::deref(self), f)
27 }
28 }
29
30 impl ::std::fmt::Debug for $Borrowed {
31 #[inline]
32 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
33 <str as ::std::fmt::Debug>::fmt(&self.0, f)
34 }
35 }
36 };
37
38 (
39 redact($redacted_type:literal);
40
41 $(#[$meta:meta])*
42
43 $vis:vis struct $Owned:ident;
44 $(#[$_unused_meta:meta])*
45 $visref:vis struct $Borrowed:ident;
46
47 ) => {
48 manual_braid! {
49 @common
50
51 $(#[$meta])*
52
53 $vis struct $Owned;
54 $(#[$_unused_meta])*
55 $visref struct $Borrowed;
56 }
57
58 impl ::std::fmt::Debug for $Owned {
59 #[inline]
60 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
61 f.write_str(concat!("[redacted ", $redacted_type, "]"))
62 }
63 }
64
65 impl ::std::fmt::Debug for $Borrowed {
66 #[inline]
67 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
68 f.write_str(concat!("[redacted ", $redacted_type, "]"))
69 }
70 }
71 };
72
73 (
74 @common
75 $(#[$meta:meta])*
76
77 $vis:vis struct $Owned:ident;
78 $(#[$_unused_meta:meta])*
79 $visref:vis struct $Borrowed:ident;
80
81 ) => {
82
83 $(#[$meta])*
84 #[derive(Clone, Hash, PartialEq, Eq)]
85 #[repr(transparent)]
86 pub struct $Owned(String);
87
88 impl $Owned {
89 #[doc = concat!("Constructs a new ", stringify!($Owned))]
90 #[inline]
91 pub const fn new(raw: String) -> Self {
92 Self(raw)
93 }
94 #[inline]
95 #[doc = concat!("Constructs a new", stringify!($Owned), "from a static reference")]
96 #[track_caller]
97 pub fn from_static(raw: &'static str) -> Self {
98 ::std::borrow::ToOwned::to_owned($Borrowed::from_static(raw))
99 }
100 #[doc = concat!("Converts this `", stringify!($Owned), "` into a [`Box<", stringify!($Borrowed), ">`]\n\nThis will drop any excess capacity.")]
101 #[allow(unsafe_code)]
102 #[inline]
103 pub fn into_boxed_ref(self) -> ::std::boxed::Box<$Borrowed> {
104 #[doc = concat!("SAFETY: `", stringify!($Borrowed), "` is `#[repr(transparent)]` around a single `str` field, so a `*mut str` can be safely reinterpreted as a `*mut ", stringify!($Borrowed), "`")]
105 fn _ptr_safety_comment() {}
106
107 let box_str = self.0.into_boxed_str();
108 unsafe {
109 ::std::boxed::Box::from_raw(::std::boxed::Box::into_raw(box_str) as *mut $Borrowed)
110 }
111 }
112 #[doc = "Unwraps the underlying [`String`] value"]
113 #[inline]
114 pub fn take(self) -> String {
115 self.0
116 }
117 }
118
119 impl ::std::convert::From<&'_ $Borrowed> for $Owned {
120 #[inline]
121 fn from(s: &$Borrowed) -> Self {
122 ::std::borrow::ToOwned::to_owned(s)
123 }
124 }
125
126 impl ::std::convert::From<$Owned> for ::std::string::String {
127 #[inline]
128 fn from(s: $Owned) -> Self {
129 s.0
130 }
131 }
132
133 impl ::std::borrow::Borrow<$Borrowed> for $Owned {
134 #[inline]
135 fn borrow(&self) -> &$Borrowed {
136 ::std::ops::Deref::deref(self)
137 }
138 }
139
140 impl ::std::convert::AsRef<$Borrowed> for $Owned {
141 #[inline]
142 fn as_ref(&self) -> &$Borrowed {
143 ::std::ops::Deref::deref(self)
144 }
145 }
146
147 impl ::std::convert::AsRef<str> for $Owned {
148 #[inline]
149 fn as_ref(&self) -> &str {
150 self.as_str()
151 }
152 }
153
154 impl ::std::convert::From<$Owned> for ::std::boxed::Box<$Borrowed> {
155 #[inline]
156 fn from(r: $Owned) -> Self {
157 r.into_boxed_ref()
158 }
159 }
160
161 impl ::std::convert::From<::std::boxed::Box<$Borrowed>> for $Owned {
162 #[inline]
163 fn from(r: ::std::boxed::Box<$Borrowed>) -> Self {
164 r.into_owned()
165 }
166 }
167
168 impl<'a> ::std::convert::From<::std::borrow::Cow<'a, $Borrowed>> for $Owned {
169 #[inline]
170 fn from(r: ::std::borrow::Cow<'a, $Borrowed>) -> Self {
171 match r {
172 ::std::borrow::Cow::Borrowed(b) => ::std::borrow::ToOwned::to_owned(b),
173 ::std::borrow::Cow::Owned(o) => o,
174 }
175 }
176 }
177
178 impl<'a> ::std::convert::From<$Owned> for ::std::borrow::Cow<'a, $Borrowed> {
179 #[inline]
180 fn from(owned: $Owned) -> Self {
181 ::std::borrow::Cow::Owned(owned)
182 }
183 }
184
185 impl ::std::convert::From<::std::string::String> for $Owned {
186 #[inline]
187 fn from(s: ::std::string::String) -> Self {
188 Self::new(s)
189 }
190 }
191
192 impl ::std::convert::From<&'_ str> for $Owned {
193 #[inline]
194 fn from(s: &str) -> Self {
195 Self::new(::std::convert::From::from(s))
196 }
197 }
198
199 impl ::std::convert::From<::std::boxed::Box<str>> for $Owned {
200 #[inline]
201 fn from(s: ::std::boxed::Box<str>) -> Self {
202 Self::new(::std::convert::From::from(s))
203 }
204 }
205
206 impl ::std::str::FromStr for $Owned {
207 type Err = ::std::convert::Infallible;
208 #[inline]
209 fn from_str(s: &str) -> ::std::result::Result<Self, Self::Err> {
210 ::std::result::Result::Ok(::std::convert::From::from(s))
211 }
212 }
213
214 impl ::std::borrow::Borrow<str> for $Owned {
215 #[inline]
216 fn borrow(&self) -> &str {
217 self.as_str()
218 }
219 }
220
221 impl ::std::ops::Deref for $Owned {
222 type Target = $Borrowed;
223 #[inline]
224 fn deref(&self) -> &Self::Target {
225 $Borrowed::from_str(::std::convert::AsRef::as_ref(&self.0))
226 }
227 }
228
229 impl ::std::fmt::Display for $Owned {
230 #[inline]
231 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
232 <$Borrowed as ::std::fmt::Display>::fmt(::std::ops::Deref::deref(self), f)
233 }
234 }
235
236 impl ::std::cmp::Ord for $Owned {
237 #[inline]
238 fn cmp(&self, other: &Self) -> ::std::cmp::Ordering {
239 ::std::cmp::Ord::cmp(&self.0, &other.0)
240 }
241 }
242 impl ::std::cmp::PartialOrd for $Owned {
244 #[inline]
245 #[allow(unknown_lints)]
246 #[allow(clippy::non_canonical_partial_ord_impl)]
247 fn partial_cmp(&self, other: &Self) -> ::std::option::Option<::std::cmp::Ordering> {
248 ::std::option::Option::Some(::std::cmp::Ord::cmp(self, other))
249 }
250 }
251
252 #[cfg(feature = "serde")]
253 impl ::serde::Serialize for $Owned {
254 fn serialize<S: ::serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
255 <String as ::serde::Serialize>::serialize(&self.0, serializer)
256 }
257 }
258
259 #[cfg(feature = "serde")]
260 impl<'de> ::serde::Deserialize<'de> for $Owned {
261 fn deserialize<D: ::serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
262 let raw = <String as ::serde::Deserialize<'de>>::deserialize(deserializer)?;
263 Ok(Self::new(raw))
264 }
265 }
266
267 $(#[$meta])*
268 #[repr(transparent)]
269 #[derive(Hash, PartialEq, Eq, PartialOrd, Ord)]
270 pub struct $Borrowed(str);
271
272 impl $Borrowed {
273 #[allow(unsafe_code)]
274 #[inline]
275 #[doc = concat!("Transparently reinterprets the string slice as a strongly-typed ", stringify!($Borrowed))]
276 pub const fn from_str(raw: &str) -> &Self {
277 let ptr: *const str = raw;
278 #[doc = concat!("SAFETY: `", stringify!($Borrowed), "` is `#[repr(transparent)]` around a single `str` field, so a `*const str` can be safely reinterpreted as a `*const ", stringify!($Borrowed), "`")]
279 fn _ptr_safety_comment() {}
280
281 unsafe { &*(ptr as *const Self) }
282 }
283 #[inline]
284 #[doc = concat!("Transparently reinterprets the static string slice as a strongly-typed ", stringify!($Borrowed))]
285 #[track_caller]
286 pub const fn from_static(raw: &'static str) -> &'static Self {
287 Self::from_str(raw)
288 }
289 #[allow(unsafe_code)]
290 #[inline]
291 #[doc = concat!("Converts a [`Box<", stringify!($Borrowed), ">`] into a [`", stringify!($Owned), "`] without copying or allocating")]
292 pub fn into_owned(self: ::std::boxed::Box<$Borrowed>) -> $Owned {
293 #[doc = concat!("SAFETY: `", stringify!($Borrowed), "` is `#[repr(transparent)]` around a single `str` field, so a `*mut str` can be safely reinterpreted as a `*mut ", stringify!($Borrowed), "`")]
294 fn _ptr_safety_comment() {}
295
296 let raw = ::std::boxed::Box::into_raw(self);
297 let boxed = unsafe { ::std::boxed::Box::from_raw(raw as *mut str) };
298 $Owned::new(::std::convert::From::from(boxed))
299 }
300 #[doc = r" Provides access to the underlying value as a string slice."]
301 #[inline]
302 pub const fn as_str(&self) -> &str {
303 &self.0
304 }
305 }
306
307 impl ::std::borrow::ToOwned for $Borrowed {
308 type Owned = $Owned;
309 #[inline]
310 fn to_owned(&self) -> Self::Owned {
311 $Owned(self.0.into())
312 }
313 }
314
315 impl ::std::cmp::PartialEq<$Borrowed> for $Owned {
316 #[inline]
317 fn eq(&self, other: &$Borrowed) -> bool {
318 self.as_str() == other.as_str()
319 }
320 }
321
322 impl ::std::cmp::PartialEq<&'_ $Owned> for $Owned {
323 #[inline]
324 fn eq(&self, other: &&$Owned) -> bool {
325 self.as_str() == other.as_str()
326 }
327 }
328
329 impl ::std::cmp::PartialEq<$Owned> for $Borrowed {
330 #[inline]
331 fn eq(&self, other: &$Owned) -> bool {
332 self.as_str() == other.as_str()
333 }
334 }
335
336 impl ::std::cmp::PartialEq<&'_ $Borrowed> for $Owned {
337 #[inline]
338 fn eq(&self, other: &&$Borrowed) -> bool {
339 self.as_str() == other.as_str()
340 }
341 }
342
343 impl ::std::cmp::PartialEq<$Owned> for &'_ $Borrowed {
344 #[inline]
345 fn eq(&self, other: &$Owned) -> bool {
346 self.as_str() == other.as_str()
347 }
348 }
349
350 impl<'a> ::std::convert::From<&'a str> for &'a $Borrowed {
351 #[inline]
352 fn from(s: &'a str) -> &'a $Borrowed {
353 $Borrowed::from_str(s)
354 }
355 }
356
357 impl ::std::borrow::Borrow<str> for $Borrowed {
358 #[inline]
359 fn borrow(&self) -> &str {
360 &self.0
361 }
362 }
363
364 impl ::std::convert::AsRef<str> for $Borrowed {
365 #[inline]
366 fn as_ref(&self) -> &str {
367 &self.0
368 }
369 }
370
371 impl<'a> ::std::convert::From<&'a $Borrowed> for ::std::borrow::Cow<'a, $Borrowed> {
372 #[inline]
373 fn from(r: &'a $Borrowed) -> Self {
374 ::std::borrow::Cow::Borrowed(r)
375 }
376 }
377
378 impl<'a, 'b: 'a> ::std::convert::From<&'a ::std::borrow::Cow<'b, $Borrowed>>
379 for &'a $Borrowed
380 {
381 #[inline]
382 fn from(r: &'a ::std::borrow::Cow<'b, $Borrowed>) -> &'a $Borrowed {
383 ::std::borrow::Borrow::borrow(r)
384 }
385 }
386
387 impl ::std::convert::From<&'_ $Borrowed> for ::std::rc::Rc<$Borrowed> {
388 #[allow(unsafe_code)]
389 #[inline]
390 fn from(r: &'_ $Borrowed) -> Self {
391 #[doc = concat!("SAFETY: `", stringify!($Borrowed), "` is `#[repr(transparent)]` around a single `str` field, so a `*const str` can be safely reinterpreted as a `*const ", stringify!($Borrowed), "`")]
392 fn _ptr_safety_comment() {}
393
394 let rc = ::std::rc::Rc::<str>::from(r.as_str());
395 unsafe { ::std::rc::Rc::from_raw(::std::rc::Rc::into_raw(rc) as *const $Borrowed) }
396 }
397 }
398
399 impl ::std::convert::From<&'_ $Borrowed> for ::std::sync::Arc<$Borrowed> {
400 #[allow(unsafe_code)]
401 #[inline]
402 fn from(r: &'_ $Borrowed) -> Self {
403 #[doc = concat!("SAFETY: `", stringify!($Borrowed), "` is `#[repr(transparent)]` around a single `str` field, so a `*const str` can be safely reinterpreted as a `*const ", stringify!($Borrowed), "`")]
404 fn _ptr_safety_comment() {}
405
406 let arc = ::std::sync::Arc::<str>::from(r.as_str());
407 unsafe {
408 ::std::sync::Arc::from_raw(::std::sync::Arc::into_raw(arc) as *const $Borrowed)
409 }
410 }
411 }
412
413 impl ::std::fmt::Display for $Borrowed {
414 #[inline]
415 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
416 <str as ::std::fmt::Display>::fmt(&self.0, f)
417 }
418 }
419
420 #[cfg(feature = "serde")]
421 impl ::serde::Serialize for $Borrowed {
422 fn serialize<S: ::serde::Serializer>(
423 &self,
424 serializer: S,
425 ) -> ::std::result::Result<S::Ok, S::Error> {
426 <str as ::serde::Serialize>::serialize(self.as_str(), serializer)
427 }
428 }
429
430 #[cfg(feature = "serde")]
431 impl<'de: 'a, 'a> ::serde::Deserialize<'de> for &'a $Borrowed {
432 fn deserialize<D: ::serde::Deserializer<'de>>(
433 deserializer: D,
434 ) -> ::std::result::Result<Self, D::Error> {
435 let raw = <&str as ::serde::Deserialize<'de>>::deserialize(deserializer)?;
436 ::std::result::Result::Ok($Borrowed::from_str(raw))
437 }
438 }
439
440 #[cfg(feature = "serde")]
441 impl<'de> ::serde::Deserialize<'de> for ::std::boxed::Box<$Borrowed> {
442 fn deserialize<D: ::serde::Deserializer<'de>>(
443 deserializer: D,
444 ) -> ::std::result::Result<Self, D::Error> {
445 let owned = <$Owned as ::serde::Deserialize<'de>>::deserialize(deserializer)?;
446 ::std::result::Result::Ok(owned.into_boxed_ref())
447 }
448 }
449
450 impl<'a> From<&'a Vec<&'a $Owned>>
451 for $crate::collection::Collection<'a, $Owned>
452 {
453 fn from(v: &'a Vec<&'a $Owned>) -> Self { Self::Borrowed(::std::borrow::Cow::from(v)) }
454 }
455
456 impl<'a> From<&'a Vec<&'a str>>
457 for $crate::collection::Collection<'a, $Owned>
458 {
459 fn from(v: &'a Vec<&'a str>) -> Self { Self::RefStr(::std::borrow::Cow::from(v)) }
460 }
461
462 impl<'a> From<&'a Vec<String>>
463 for $crate::collection::Collection<'a, $Owned>
464 {
465 fn from(v: &'a Vec<String>) -> Self { Self::OwnedString(::std::borrow::Cow::from(v)) }
466 }
467
468 impl<'a> From<Vec<&'a $Borrowed>>
469 for $crate::collection::Collection<'a, $Owned>
470 {
471 fn from(v: Vec<&'a $Borrowed>) -> Self { Self::Ref(::std::borrow::Cow::from(v)) }
472 }
473
474 impl<'a> From<&'a [&'a $Borrowed]>
475 for $crate::collection::Collection<'a, $Owned>
476 {
477 fn from(v: &'a [&'a $Borrowed]) -> Self { Self::Ref(::std::borrow::Cow::from(v)) }
478 }
479
480 impl From<Vec<String>>
481 for $crate::collection::Collection<'_, $Owned>
482 {
483 fn from(v: Vec<String>) -> Self { Self::OwnedString(::std::borrow::Cow::from(v)) }
484 }
485
486 impl<'a> From<&'a [String]>
487 for $crate::collection::Collection<'a, $Owned>
488 {
489 fn from(v: &'a [String]) -> Self { Self::OwnedString(::std::borrow::Cow::from(v)) }
490 }
491
492 impl<'a> From<Vec<&'a String>>
493 for $crate::collection::Collection<'a, $Owned>
494 {
495 fn from(v: Vec<&'a String>) -> Self { Self::BorrowedString(::std::borrow::Cow::from(v)) }
496 }
497
498 impl<'a> From<&'a [&'a String]>
499 for $crate::collection::Collection<'a, $Owned>
500 {
501 fn from(v: &'a [&'a String]) -> Self { Self::BorrowedString(::std::borrow::Cow::from(v)) }
502 }
503
504 impl<'a> From<Vec<&'a str>>
505 for $crate::collection::Collection<'a, $Owned>
506 {
507 fn from(v: Vec<&'a str>) -> Self { Self::RefStr(::std::borrow::Cow::from(v)) }
508 }
509
510 impl<'a> From<&'a [&'a str]>
511 for $crate::collection::Collection<'a, $Owned>
512 {
513 fn from(v: &'a [&'a str]) -> Self { Self::RefStr(::std::borrow::Cow::from(v)) }
514 }
515
516 impl<'a, const N: usize> From<&'a [&'a str; N]>
517 for $crate::collection::Collection<'a, $Owned>
518 {
519 fn from(v: &'a [&'a str; N]) -> Self { Self::RefStr(::std::borrow::Cow::from(v.as_slice())) }
520 }
521
522 impl<'a, const N: usize> From<&'a [$Owned; N]>
523 for $crate::collection::Collection<'a, $Owned>
524 {
525 fn from(v: &'a [$Owned; N]) -> Self { Self::Owned(::std::borrow::Cow::from(v.as_slice())) }
526 }
527
528 impl<'a, const N: usize> From<&'a [String; N]>
529 for $crate::collection::Collection<'a, $Owned>
530 {
531 fn from(v: &'a [String; N]) -> Self { Self::OwnedString(::std::borrow::Cow::from(v.as_slice())) }
532 }
533
534 impl<'a, const N: usize> From<&'a [&'a $Owned; N]>
535 for $crate::collection::Collection<'a, $Owned>
536 {
537 fn from(v: &'a [&'a $Owned; N]) -> Self { Self::Borrowed(::std::borrow::Cow::from(v.as_slice())) }
538 }
539
540 impl<'a, const N: usize> From<&'a [&'a $Borrowed; N]>
541 for $crate::collection::Collection<'a, $Owned>
542 {
543 fn from(v: &'a [&'a $Borrowed; N]) -> Self { Self::Ref(::std::borrow::Cow::Borrowed(v.as_slice())) }
544 }
545
546 impl<'a> From<&'a $Owned>
547 for $crate::collection::Collection<'a, $Owned>
548 {
549 fn from(v: &'a $Owned) -> Self { Self::Owned(::std::borrow::Cow::from(std::slice::from_ref(v))) }
550 }
551
552 impl<'a> From<&'a &'a $Borrowed>
553 for $crate::collection::Collection<'a, $Owned>
554 {
555 fn from(v: &'a &'a $Borrowed) -> Self { Self::Ref(::std::borrow::Cow::from(std::slice::from_ref(v))) }
556 }
557
558 impl<'a> From<&'a &'a str>
559 for $crate::collection::Collection<'a, $Owned>
560 {
561 fn from(v: &'a &'a str) -> Self { Self::RefStr(::std::borrow::Cow::from(std::slice::from_ref(v))) }
562 }
563 }
564}
565
566macro_rules! impl_extra {
567 (validated, $owned:path, $ref:path, $error:path) => {
568 impl<'a> TryFrom<&'a String> for &'a $ref {
569 type Error = $error;
570 fn try_from(string: &'a String) -> Result<Self, $error> {
571 <$ref>::from_str(string.as_str())
572 }
573 }
574
575 impl_extra!(@all, $owned, $ref);
576 };
577 (no_arb, $owned:path, $ref:path) => {
578 impl<'a> From<&'a String> for &'a $ref {
579 fn from(string: &'a String) -> Self {
580 <$ref>::from_str(string.as_str())
581 }
582 }
583
584 impl_extra!(@all, $owned, $ref);
585 };
586
587 (ascii, $owned:path, $ref:path) => {
588 impl<'a> From<&'a String> for &'a $ref {
589 fn from(string: &'a String) -> Self {
590 <$ref>::from_str(string.as_str())
591 }
592 }
593
594 #[cfg(feature = "arbitrary")]
595 impl<'a> arbitrary::Arbitrary<'a> for &'a $ref {
596 fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> Result<Self, arbitrary::Error> {
597 let string: &str = <&str as arbitrary::Arbitrary>::arbitrary(u)?;
598 let string = if let Some(i) = string.find(|b: char| !b.is_ascii_alphanumeric()) {
599 let valid = &string[0..i];
600 valid
601 } else {
602 string
603 };
604 if string.is_empty() {
605 Err(arbitrary::Error::IncorrectFormat)
606 } else {
607 Ok(string.into())
608 }
609 }
610
611 fn arbitrary_take_rest(u: arbitrary::Unstructured<'a>) -> Result<Self, arbitrary::Error> {
612 let string: &str = <&str as arbitrary::Arbitrary>::arbitrary_take_rest(u)?;
613 if string.as_bytes().iter().any(|b| !b.is_ascii_alphanumeric())|| string.is_empty() {
614 Err(arbitrary::Error::IncorrectFormat)
615 } else {
616 Ok(string.into())
617 }
618 }
619
620 #[inline]
621 fn size_hint(depth: usize) -> (usize, Option<usize>) {
622 <&str as arbitrary::Arbitrary>::size_hint(depth)
623 }
624 }
625
626 #[cfg(feature = "arbitrary")]
627 impl<'a> arbitrary::Arbitrary<'a> for $owned {
628 fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> Result<Self, arbitrary::Error> {
629 <&$ref as arbitrary::Arbitrary>::arbitrary(u).map(Into::into)
630 }
631
632 fn arbitrary_take_rest(u: arbitrary::Unstructured<'a>) -> Result<Self, arbitrary::Error> {
633 <&$ref as arbitrary::Arbitrary>::arbitrary_take_rest(u).map(Into::into)
634 }
635
636 #[inline]
637 fn size_hint(depth: usize) -> (usize, Option<usize>) {
638 <&$ref as arbitrary::Arbitrary>::size_hint(depth)
639 }
640 }
641
642 impl_extra!(@all, $owned, $ref);
643 };
644
645 (numeric, $owned:path, $ref:path) => {
646 impl<'a> From<&'a String> for &'a $ref {
647 fn from(string: &'a String) -> Self {
648 <$ref>::from_str(string.as_str())
649 }
650 }
651
652 #[cfg(feature = "arbitrary")]
653 impl<'a> arbitrary::Arbitrary<'a> for &'a $ref {
654 fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> Result<Self, arbitrary::Error> {
655 let string: &str = <&str as arbitrary::Arbitrary>::arbitrary(u)?;
656 let string = if let Some(i) = string.find(|b: char| !b.is_ascii_digit()) {
657 let valid = &string[0..i];
658 valid
659 } else {
660 string
661 };
662 if string.is_empty() {
663 Err(arbitrary::Error::IncorrectFormat)
664 } else {
665 Ok(string.into())
666 }
667 }
668
669 fn arbitrary_take_rest(u: arbitrary::Unstructured<'a>) -> Result<Self, arbitrary::Error> {
670 let string: &str = <&str as arbitrary::Arbitrary>::arbitrary_take_rest(u)?;
671 if string.as_bytes().iter().any(|b| !b.is_ascii_digit()) || string.is_empty() {
672 Err(arbitrary::Error::IncorrectFormat)
673 } else {
674 Ok(string.into())
675 }
676 }
677
678 #[inline]
679 fn size_hint(depth: usize) -> (usize, Option<usize>) {
680 <&str as arbitrary::Arbitrary>::size_hint(depth)
681 }
682 }
683
684 #[cfg(feature = "arbitrary")]
685 impl<'a> arbitrary::Arbitrary<'a> for $owned {
686 fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> Result<Self, arbitrary::Error> {
687 <u32 as arbitrary::Arbitrary>::arbitrary(u).map(|i| format!("{i}").into())
688 }
689
690 fn arbitrary_take_rest(u: arbitrary::Unstructured<'a>) -> Result<Self, arbitrary::Error> {
691 <u32 as arbitrary::Arbitrary>::arbitrary_take_rest(u).map(|i| format!("{i}").into())
692 }
693
694 #[inline]
695 fn size_hint(depth: usize) -> (usize, Option<usize>) {
696 <&$ref as arbitrary::Arbitrary>::size_hint(depth)
697 }
698 }
699
700 impl_extra!(@all, $owned, $ref);
701 };
702
703 ($owned:path, $ref:path) => {
704 impl<'a> From<&'a String> for &'a $ref {
705 fn from(string: &'a String) -> Self {
706 <$ref>::from_str(string.as_str())
707 }
708 }
709
710 #[cfg(feature = "arbitrary")]
711 impl<'a> arbitrary::Arbitrary<'a> for &'a $ref {
712 fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> Result<Self, arbitrary::Error> {
713 <&str as arbitrary::Arbitrary>::arbitrary(u).map(Into::into)
714 }
715
716 fn arbitrary_take_rest(u: arbitrary::Unstructured<'a>) -> Result<Self, arbitrary::Error> {
717 <&str as arbitrary::Arbitrary>::arbitrary_take_rest(u).map(Into::into)
718 }
719
720 #[inline]
721 fn size_hint(depth: usize) -> (usize, Option<usize>) {
722 <&str as arbitrary::Arbitrary>::size_hint(depth)
723 }
724 }
725
726 #[cfg(feature = "arbitrary")]
727 impl<'a> arbitrary::Arbitrary<'a> for $owned {
728 fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> Result<Self, arbitrary::Error> {
729 <&$ref as arbitrary::Arbitrary>::arbitrary(u).map(Into::into)
730 }
731
732 fn arbitrary_take_rest(u: arbitrary::Unstructured<'a>) -> Result<Self, arbitrary::Error> {
733 <&$ref as arbitrary::Arbitrary>::arbitrary_take_rest(u).map(Into::into)
734 }
735
736 #[inline]
737 fn size_hint(depth: usize) -> (usize, Option<usize>) {
738 <&$ref as arbitrary::Arbitrary>::size_hint(depth)
739 }
740 }
741
742 impl_extra!(@all, $owned, $ref);
743 };
744 (@all, $owned:path, $ref:path) => {
745 impl $ref {
746 #[doc = concat!("[`Cow<'_, ", stringify!($ref), ">`](std::borrow::Cow::Borrowed)")]
748 pub fn as_cow(&self) -> ::std::borrow::Cow<'_, $ref> {
749 self.into()
750 }
751 }
752
753 #[cfg(feature = "zerofrom")]
754 impl<'zf> zerofrom::ZeroFrom<'zf, $ref> for &'zf $ref {
755 #[inline]
756 fn zero_from(other: &'zf $ref) -> Self {
757 other
758 }
759 }
760
761 #[cfg(feature = "zerofrom")]
762 impl<'zf> zerofrom::ZeroFrom<'zf, $owned> for &'zf $ref {
763 #[inline]
764 fn zero_from(other: &'zf $owned) -> Self {
765 other
766 }
767 }
768
769 impl<'a> From<&'a $owned> for &'a $ref {
770 fn from(owned: &'a $owned) -> Self {
771 &*owned
772 }
773 }
774
775 impl<'a> From<&'a $owned> for ::std::borrow::Cow<'a, $ref> {
776 fn from(owned: &'a $owned) -> Self {
777 ::std::borrow::Cow::Borrowed(&*owned)
778 }
779 }
780
781 impl<'a> crate::IntoCow<'a, $ref> for &'a $ref {
782 fn into_cow(self) -> ::std::borrow::Cow<'a, $ref> {
783 ::std::borrow::Cow::Borrowed(self)
784 }
785 }
786
787 impl<'a> crate::IntoCow<'a, $ref> for $owned {
788 fn into_cow(self) -> ::std::borrow::Cow<'a, $ref> {
789 ::std::borrow::Cow::Owned(self)
790 }
791 }
792
793 impl<'a> crate::IntoCow<'a, $ref> for &'a $owned {
794 fn into_cow(self) -> ::std::borrow::Cow<'a, $ref> {
795 ::std::borrow::Cow::Borrowed(self.as_ref())
796 }
797 }
798
799 const _: () = {
800 #[cfg(feature = "arbitrary")]
801 fn assert_arbitrary() {
802 fn assert<'a, T: arbitrary::Arbitrary<'a>>() {}
803 assert::<$owned>();
806 }
807
808 #[cfg(feature = "zerofrom")]
809 fn assert_zerofrom() {
810 fn assert_borrowed<'zf, T: zerofrom::ZeroFrom<'zf, $ref>>() {}
811 fn assert_owned<'zf, T: zerofrom::ZeroFrom<'zf, $owned>>() {}
812 assert_borrowed::<&$ref>();
813 assert_owned::<&$ref>();
814 }
815 };
816 };
817}