Struct SingleItemStorage 

pub struct SingleItemStorage<T>(pub T);

A structure that holds one, and only one T.

Behaves like [T; 1] but has additional Default and From implementations.

Tuple Fields

0: T

Trait Implementations

impl<T> AsMut<[T]> for SingleItemStorage<T>

fn as_mut(&mut self) -> &mut [T]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsRef<[T]> for SingleItemStorage<T>

fn as_ref(&self) -> &[T]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> Capacity for SingleItemStorage<T>

let mut structure = cl_aux::doc_tests::single_item_storage();
assert_eq!(cl_aux::Capacity::capacity(&structure), 1);

fn capacity(&self) -> usize

The number of elements the implementation has pre-allocated as an internal buffer. Not necessarily the current number of inserted elements.

impl<T> CapacityUpperBound for SingleItemStorage<T>

let mut structure = cl_aux::doc_tests::single_item_storage();
assert_eq!(cl_aux::Capacity::capacity(&structure), 1);

const CAPACITY_UPPER_BOUND: usize = 1usize

The maximum theoretical number of elements a type implementation is able to store.

fn capacity_upper_bound(&self) -> usize

Instance method representing Self::CAPACITY_UPPER_BOUND.

impl<T: Debug> Debug for SingleItemStorage<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for SingleItemStorage<T>

fn default() -> SingleItemStorage<T>

Returns the “default value” for a type.

impl<T> From<T> for SingleItemStorage<T>

fn from(from: T) -> Self

Converts to this type from the input type.

impl<T> Get for SingleItemStorage<T>

let structure = cl_aux::doc_tests::single_item_storage();
assert_eq!(cl_aux::Get::get(&structure, 0), Ok(&1));

type Error = Error

Error

type Input = usize

Input

type Output<'output> = &'output T where Self: 'output

Output

fn get(&self, _: Self::Input) -> Result<Self::Output<'_>, Self::Error>

Returns an immutable inner reference of a derived element.

impl<T> GetMut for SingleItemStorage<T>

let mut structure = cl_aux::doc_tests::single_item_storage();
assert_eq!(cl_aux::GetMut::get_mut(&mut structure, 0), Ok(&mut 1));

type Error = Error

Error

type Input = usize

Input

type Output<'output> = &'output mut T where Self: 'output

Output

fn get_mut( &mut self, input: Self::Input, ) -> Result<Self::Output<'_>, Self::Error>

Returns an mutable inner reference of a derived element.

impl<T> Iter for SingleItemStorage<T>

let structure = cl_aux::doc_tests::single_item_storage();
assert_eq!(cl_aux::Iter::iter(&structure).next().unwrap(), &1);

type Output<'iter> = Iter<'iter, T> where T: 'iter

Iterator

fn iter(&self) -> Self::Output<'_>

Returns a new iterator that refers inner elements.

impl<T> Length for SingleItemStorage<T>

let structure = cl_aux::doc_tests::single_item_storage();
assert_eq!(cl_aux::Length::length(&structure), 1);

fn length(&self) -> usize

Holds a certain number of elements.

impl<T: PartialEq> PartialEq for SingleItemStorage<T>

fn eq(&self, other: &SingleItemStorage<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd> PartialOrd for SingleItemStorage<T>

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<T> SingleTypeStorage for SingleItemStorage<T>

type Item = T

Storage item

impl<T> SizeHint for SingleItemStorage<T>

let structure = cl_aux::doc_tests::single_item_storage();
assert_eq!(cl_aux::SizeHint::size_hint(&structure), (1, Some(1)));

fn size_hint(&self) -> (usize, Option<usize>)

Has the same semantics of Iterator::size_hint.

impl<T: Eq> Eq for SingleItemStorage<T>

impl<T> StructuralPartialEq for SingleItemStorage<T>