Enum bos::Abos

#[non_exhaustive]
pub enum Abos<'b, B: ?Sized, O = B, S: ?Sized = O> where
    B: 'static + ?Sized,
    O: 'static,
    S: 'static + ?Sized,  {
    Borrowed(&'b B),
    Owned(O),
    BorrowedArc(&'b Arc<S>),
    Arc(Arc<S>),
}

Atomic Borrowed, Owned or Shared smart pointer.

The enum is currently marked as non_exhaustive and has 'static bounds so we may later add a Static(&'static B) variant or something similar.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Borrowed

Tuple Fields of Borrowed

0: &'b B

Owned

Tuple Fields of Owned

0: O

BorrowedArc

Tuple Fields of BorrowedArc

0: &'b Arc<S>

Arc

Tuple Fields of Arc

0: Arc<S>

Implementations

impl<'b, B: ?Sized, O, S: ?Sized> Abos<'b, B, O, S>

pub fn into_owned(self) -> O where
    B: ToOwned<Owned = O>,
    S: Clone + Into<O>, 

Extracts the owned data.

Clones the data if it is not already owned.

Examples

Calling into_owned on a Abos::Borrowed clones the inner data.

use bos::{Abos, AbosStr};

let abos: AbosStr = Abos::Borrowed("Hello!");
let owned: String = abos.into_owned();
assert_eq!(owned, "Hello!");

Calling into_owned on a Abos::Owned doesn’t clone anything.

use bos::{Abos, AbosStr};

let abos: AbosStr = Abos::Owned("Hello!".to_owned());
let owned: String = abos.into_owned();
assert_eq!(owned, "Hello!");

Calling into_owned on a Abos::Arc only clones the inner data if the reference count is greater than one.

use bos::{Abos, AbosStr};

let bos: AbosStr = Abos::Arc("Hello!".to_owned().into());
let owned: String = bos.into_owned();
assert_eq!(owned, "Hello!");

pub fn to_mut(&mut self) -> &mut O where
    B: ToOwned<Owned = O>,
    S: Clone + BorrowMut<O>, 

Acquires a mutable reference to the owned form of the data.

Clones the data if it is not already owned.

Examples

Calling to_mut on an Abos::Borrowed clones the inner data.

use bos::{Abos, AbosStr};

let mut hello: AbosStr = Abos::Borrowed("Hello");
hello.to_mut().push_str(", Barbara!");
assert_eq!(hello, "Hello, Barbara!");

Calling to_mut on an Abos::Owned doesn’t clone anything.

use bos::{Abos, AbosStr};

let mut hello: AbosStr = Abos::Owned("Hello".to_owned());
hello.to_mut().push_str(", Barbara!");
assert_eq!(hello, "Hello, Barbara!");

Calling to_mut on an Abos::Arc only clones the inner data if the reference count is greater than one.

use bos::{Abos, AbosStr};

let mut hello: AbosStr = Abos::Arc("Hello".to_owned().into());
hello.to_mut().push_str(", Barbara!");
assert_eq!(hello, "Hello, Barbara!");

pub fn into_static(self) -> Abos<'static, B, O, S> where
    B: ToOwned<Owned = O>, 

Convert borrowed variants so that the new Abos has a 'static lifetime.

Examples

let b = AbosStr::Borrowed("a");
let s = b.into_static();
assert_eq!(s, "a");
assert_matches::assert_matches!(s, AbosStr::Owned(_));

pub fn into_arc(self) -> Arc<S> where
    for<'a> &'a B: Into<Arc<S>>,
    O: Into<Arc<S>>, 

Extracts the shared data.

Converting B or O to Arc<S> may clone the data.

pub fn to_borrowed(&self) -> Abos<'_, B, O, S> where
    O: Borrow<B>, 

Convert to a new Abos that borrows from self.

Examples

let o = AbosStr::Owned("a".into());
let b = o.to_borrowed();
assert_eq!(b, "a");
assert_matches::assert_matches!(b, AbosStr::Borrowed(_));

let a = AbosStr::Arc(String::from("a").into());
let b = a.to_borrowed();
assert_eq!(b, "a");
assert_matches::assert_matches!(b, AbosStr::BorrowedArc(_));

pub fn into_shared(self) -> Self where
    O: Into<Arc<S>>, 

Convert Abos::Owned into Abos::Arc.

Examples

let o = AbosStr::Owned("a".into());
let s = o.into_shared();
assert_eq!(s, "a");
assert_matches::assert_matches!(s, AbosStr::Arc(_));

pub fn make_shared(&mut self) where
    O: Default + Into<Arc<S>>, 

Change Abos::Owned into Abos::Arc.

Examples

let mut a = AbosStr::Owned("a".into());
a.make_shared();
assert_eq!(a, "a");
assert_matches::assert_matches!(a, AbosStr::Arc(_));

Trait Implementations

impl<'b, B: ?Sized, O, S: ?Sized, Rhs> Add<Rhs> for Abos<'b, B, O, S> where
    O: Add<Rhs>,
    B: ToOwned<Owned = O>,
    S: Clone + Into<O>, 

type Output = <O as Add<Rhs>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: Rhs) -> <O as Add<Rhs>>::Output

Performs the + operation.

impl<'b, B: ?Sized, O, S: ?Sized, Rhs> AddAssign<Rhs> for Abos<'b, B, O, S> where
    O: AddAssign<Rhs>,
    B: ToOwned<Owned = O>,
    S: Clone + BorrowMut<O>, 

fn add_assign(&mut self, rhs: Rhs)

Performs the += operation.

impl<'b, B: ?Sized, O, S: ?Sized> AsRef<B> for Abos<'b, B, O, S> where
    O: Borrow<B>,
    S: Borrow<B>, 

fn as_ref(&self) -> &B

Performs the conversion.

impl<'b, B: ?Sized, O, S: ?Sized> Borrow<B> for Abos<'b, B, O, S> where
    O: Borrow<B>,
    S: Borrow<B>, 

fn borrow(&self) -> &B

Immutably borrows from an owned value.

impl<'b, B: ?Sized, O, S: ?Sized> Clone for Abos<'b, B, O, S> where
    O: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'b, B: ?Sized, O, S: ?Sized> Debug for Abos<'b, B, O, S> where
    B: Debug,
    O: Debug,
    S: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'b, B: ?Sized, O, S: ?Sized> Default for Abos<'b, B, O, S> where
    O: Default, 

fn default() -> Self

Creates an owned Abos with the default value for the contained owned type.

impl<'b, B: ?Sized, O, S: ?Sized> Deref for Abos<'b, B, O, S> where
    O: Borrow<B>,
    S: Borrow<B>, 

type Target = B

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de, 'b, B: ?Sized, O, S: ?Sized> Deserialize<'de> for Abos<'b, B, O, S> where
    O: Deserialize<'de>, 

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'b, B: ?Sized, O, S: ?Sized> Display for Abos<'b, B, O, S> where
    B: Display,
    O: Display,
    S: Display, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'b, T> From<Abos<'b, [T], Vec<T, Global>, Vec<T, Global>>> for Vec<T> where
    T: Clone,
    [T]: ToOwned<Owned = Vec<T>>,
    Vec<T>: Clone, 

fn from(x: Abos<'b, [T], Vec<T>>) -> Self

Performs the conversion.

impl<'b> From<Abos<'b, CStr, CString, CString>> for CString

fn from(x: Abos<'b, CStr, CString>) -> Self

Performs the conversion.

impl<'b> From<Abos<'b, OsStr, OsString, OsString>> for OsString

fn from(x: Abos<'b, OsStr, OsString>) -> Self

Performs the conversion.

impl<'b> From<Abos<'b, Path, PathBuf, PathBuf>> for PathBuf

fn from(x: Abos<'b, Path, PathBuf>) -> Self

Performs the conversion.

impl<'b> From<Abos<'b, str, String, String>> for String

fn from(x: Abos<'b, str, String>) -> Self

Performs the conversion.

impl<'b, B: ?Sized, O, S: ?Sized> From<Arc<S>> for Abos<'b, B, O, S>

fn from(x: Arc<S>) -> Self

Performs the conversion.

impl<'b> From<CString> for Abos<'b, CStr, CString>

fn from(x: CString) -> Self

Performs the conversion.

impl<'b, B: ToOwned + ?Sized + 'b> From<Cow<'b, B>> for Abos<'b, B, B::Owned, B::Owned>

fn from(p: Cow<'b, B>) -> Self

Performs the conversion.

impl<'b> From<OsString> for Abos<'b, OsStr, OsString>

fn from(x: OsString) -> Self

Performs the conversion.

impl<'b> From<PathBuf> for Abos<'b, Path, PathBuf>

fn from(x: PathBuf) -> Self

Performs the conversion.

impl<'b> From<String> for Abos<'b, str, String>

fn from(x: String) -> Self

Performs the conversion.

impl<'b, T> From<Vec<T, Global>> for Abos<'b, [T], Vec<T>>

fn from(x: Vec<T>) -> Self

Performs the conversion.

impl<'b, B: ?Sized, O, S: ?Sized> Hash for Abos<'b, B, O, S> where
    B: Hash,
    O: Borrow<B>,
    S: Borrow<B>, 

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<'b, B: ?Sized, O, S: ?Sized> IntoStatic for Abos<'b, B, O, S> where
    B: ToOwned<Owned = O>, 

type Static = Abos<'static, B, O, S>

fn into_static(self) -> Abos<'static, B, O, S>

impl<'b, B: ?Sized, O, S: ?Sized> Ord for Abos<'b, B, O, S> where
    B: Ord,
    O: Borrow<B>,
    S: Borrow<B>, 

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<'b, B: ?Sized, O, S: ?Sized> PartialEq<&'_ B> for Abos<'b, B, O, S> where
    B: PartialEq,
    O: Borrow<B>,
    S: Borrow<B>, 

fn eq(&self, other: &&B) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'b, B: ?Sized, O, S: ?Sized> PartialEq<Abos<'b, B, O, S>> for Abos<'b, B, O, S> where
    B: PartialEq,
    O: Borrow<B>,
    S: Borrow<B>, 

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'b, B: ?Sized, O, S: ?Sized> PartialEq<B> for Abos<'b, B, O, S> where
    B: PartialEq,
    O: Borrow<B>,
    S: Borrow<B>, 

fn eq(&self, other: &B) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'b, B: ?Sized, O, S: ?Sized> PartialOrd<&'_ B> for Abos<'b, B, O, S> where
    B: PartialOrd,
    O: Borrow<B>,
    S: Borrow<B>, 

fn partial_cmp(&self, other: &&B) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'b, B: ?Sized, O, S: ?Sized> PartialOrd<Abos<'b, B, O, S>> for Abos<'b, B, O, S> where
    B: PartialOrd,
    O: Borrow<B>,
    S: Borrow<B>, 

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'b, B: ?Sized, O, S: ?Sized> PartialOrd<B> for Abos<'b, B, O, S> where
    B: PartialOrd,
    O: Borrow<B>,
    S: Borrow<B>, 

fn partial_cmp(&self, other: &B) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'b, B: ?Sized, O, S: ?Sized> Serialize for Abos<'b, B, O, S> where
    B: Serialize,
    O: Serialize + Borrow<B>,
    S: Serialize + Borrow<B>, 

fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error> where
    Ser: Serializer, 

Serialize this value into the given Serde serializer.

impl<'r, 'b, B: ?Sized, O, S: ?Sized> ToBorrowed for &'r Abos<'b, B, O, S> where
    O: Borrow<B>, 

type Borrowed = Abos<'r, B, O, S>

fn to_borrowed(self) -> Abos<'r, B, O, S>

impl<'b, B: ?Sized, O, S: ?Sized> Eq for Abos<'b, B, O, S> where
    B: Eq,
    O: Borrow<B>,
    S: Borrow<B>,