Trait CapacityUpperBound 

pub trait CapacityUpperBound {
    const CAPACITY_UPPER_BOUND: usize;

    // Provided method
    fn capacity_upper_bound(&self) -> usize { ... }
}

See CapacityUpperBound::capacity_upper_bound for more information.

Required Associated Constants

const CAPACITY_UPPER_BOUND: usize

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

Provided Methods

fn capacity_upper_bound(&self) -> usize

Instance method representing Self::CAPACITY_UPPER_BOUND.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl CapacityUpperBound for ()

assert_eq!(cl_aux::CapacityUpperBound::capacity_upper_bound(&()), 0);

const CAPACITY_UPPER_BOUND: usize = 0usize

impl<A> CapacityUpperBound for (A,)

const CAPACITY_UPPER_BOUND: usize = 1usize

impl<A, B> CapacityUpperBound for (A, B)

const CAPACITY_UPPER_BOUND: usize = 2usize

impl<A, B, C> CapacityUpperBound for (A, B, C)

const CAPACITY_UPPER_BOUND: usize = 3usize

impl<A, B, C, D> CapacityUpperBound for (A, B, C, D)

const CAPACITY_UPPER_BOUND: usize = 4usize

impl<A, B, C, D, E> CapacityUpperBound for (A, B, C, D, E)

const CAPACITY_UPPER_BOUND: usize = 5usize

impl<A, B, C, D, E, F> CapacityUpperBound for (A, B, C, D, E, F)

const CAPACITY_UPPER_BOUND: usize = 6usize

impl<A, B, C, D, E, F, G> CapacityUpperBound for (A, B, C, D, E, F, G)

const CAPACITY_UPPER_BOUND: usize = 7usize

impl<A, B, C, D, E, F, G, H> CapacityUpperBound for (A, B, C, D, E, F, G, H)

const CAPACITY_UPPER_BOUND: usize = 8usize

impl<A, B, C, D, E, F, G, H, I> CapacityUpperBound for (A, B, C, D, E, F, G, H, I)

const CAPACITY_UPPER_BOUND: usize = 9usize

impl<A, B, C, D, E, F, G, H, I, J> CapacityUpperBound for (A, B, C, D, E, F, G, H, I, J)

const CAPACITY_UPPER_BOUND: usize = 10usize

impl<A, B, C, D, E, F, G, H, I, J, K> CapacityUpperBound for (A, B, C, D, E, F, G, H, I, J, K)

const CAPACITY_UPPER_BOUND: usize = 11usize

impl<A, B, C, D, E, F, G, H, I, J, K, L> CapacityUpperBound for (A, B, C, D, E, F, G, H, I, J, K, L)

const CAPACITY_UPPER_BOUND: usize = 12usize

impl<T> CapacityUpperBound for &[T]

let structure = cl_aux::doc_tests::slice();
assert_eq!(cl_aux::CapacityUpperBound::capacity_upper_bound(&structure), 2305843009213693951);

const CAPACITY_UPPER_BOUND: usize

impl<T> CapacityUpperBound for &mut [T]

let mut structure = cl_aux::doc_tests::slice_mut!();
assert_eq!(cl_aux::CapacityUpperBound::capacity_upper_bound(&mut structure), 2305843009213693951);

const CAPACITY_UPPER_BOUND: usize

impl<T> CapacityUpperBound for Option<T>

assert_eq!(cl_aux::CapacityUpperBound::capacity_upper_bound(&Some(0)), 1);

const CAPACITY_UPPER_BOUND: usize = 1usize

impl<T> CapacityUpperBound for &T

where T: CapacityUpperBound,

const CAPACITY_UPPER_BOUND: usize = T::CAPACITY_UPPER_BOUND

fn capacity_upper_bound(&self) -> usize

impl<T, const N: usize> CapacityUpperBound for [T; N]

let mut structure = cl_aux::doc_tests::array();
assert_eq!(cl_aux::CapacityUpperBound::capacity_upper_bound(&structure), 3);

const CAPACITY_UPPER_BOUND: usize = N

Implementors

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