vendor/memchr/src/cow.rs

   1 use core::ops;
   2
   3 /// A specialized copy-on-write byte string.
   4 ///
   5 /// The purpose of this type is to permit usage of a "borrowed or owned
   6 /// byte string" in a way that keeps std/no-std compatibility. That is, in
   7 /// no-std mode, this type devolves into a simple &[u8] with no owned variant
   8 /// available. We can't just use a plain Cow because Cow is not in core.
   9 #[derive(Clone, Debug)]
  10 pub struct CowBytes<'a>(Imp<'a>);
  11
  12 // N.B. We don't use std::borrow::Cow here since we can get away with a
  13 // Box<[u8]> for our use case, which is 1/3 smaller than the Vec<u8> that
  14 // a Cow<[u8]> would use.
  15 #[cfg(feature = "std")]
  16 #[derive(Clone, Debug)]
  17 enum Imp<'a> {
  18     Borrowed(&'a [u8]),
  19     Owned(Box<[u8]>),
  20 }
  21
  22 #[cfg(not(feature = "std"))]
  23 #[derive(Clone, Debug)]
  24 struct Imp<'a>(&'a [u8]);
  25
  26 impl<'a> ops::Deref for CowBytes<'a> {
  27     type Target = [u8];
  28
  29     #[inline(always)]
  30     fn deref(&self) -> &[u8] {
  31         self.as_slice()
  32     }
  33 }
  34
  35 impl<'a> CowBytes<'a> {
  36     /// Create a new borrowed CowBytes.
  37     #[inline(always)]
  38     pub fn new<B: ?Sized + AsRef<[u8]>>(bytes: &'a B) -> CowBytes<'a> {
  39         CowBytes(Imp::new(bytes.as_ref()))
  40     }
  41
  42     /// Create a new owned CowBytes.
  43     #[cfg(feature = "std")]
  44     #[inline(always)]
  45     pub fn new_owned(bytes: Box<[u8]>) -> CowBytes<'static> {
  46         CowBytes(Imp::Owned(bytes))
  47     }
  48
  49     /// Return a borrowed byte string, regardless of whether this is an owned
  50     /// or borrowed byte string internally.
  51     #[inline(always)]
  52     pub fn as_slice(&self) -> &[u8] {
  53         self.0.as_slice()
  54     }
  55
  56     /// Return an owned version of this copy-on-write byte string.
  57     ///
  58     /// If this is already an owned byte string internally, then this is a
  59     /// no-op. Otherwise, the internal byte string is copied.
  60     #[cfg(feature = "std")]
  61     #[inline(always)]
  62     pub fn into_owned(self) -> CowBytes<'static> {
  63         match self.0 {
  64             Imp::Borrowed(b) => CowBytes::new_owned(Box::from(b)),
  65             Imp::Owned(b) => CowBytes::new_owned(b),
  66         }
  67     }
  68 }
  69
  70 impl<'a> Imp<'a> {
  71     #[cfg(feature = "std")]
  72     #[inline(always)]
  73     pub fn new(bytes: &'a [u8]) -> Imp<'a> {
  74         Imp::Borrowed(bytes)
  75     }
  76
  77     #[cfg(not(feature = "std"))]
  78     #[inline(always)]
  79     pub fn new(bytes: &'a [u8]) -> Imp<'a> {
  80         Imp(bytes)
  81     }
  82
  83     #[cfg(feature = "std")]
  84     #[inline(always)]
  85     pub fn as_slice(&self) -> &[u8] {
  86         match self {
  87             Imp::Owned(ref x) => x,
  88             Imp::Borrowed(x) => x,
  89         }
  90     }
  91
  92     #[cfg(not(feature = "std"))]
  93     #[inline(always)]
  94     pub fn as_slice(&self) -> &[u8] {
  95         self.0
  96     }
  97 }