Struct memtable::prelude::FixedList

pub struct FixedList<T, const N: usize>(_, _)
 where
    T: Default;

Represents a fixed list that can grow up to a specific capacity N

Methods from Deref<Target = [T; N]>

pub fn as_slice(&self) -> &[T]

🔬 This is a nightly-only experimental API. (array_methods)

Returns a slice containing the entire array. Equivalent to &s[..].

pub fn as_mut_slice(&mut self) -> &mut [T]

🔬 This is a nightly-only experimental API. (array_methods)

Returns a mutable slice containing the entire array. Equivalent to &mut s[..].

pub fn each_ref(&self) -> [&T; N]

🔬 This is a nightly-only experimental API. (array_methods)

Borrows each element and returns an array of references with the same size as self.

Example

#![feature(array_methods)]

let floats = [3.1, 2.7, -1.0];
let float_refs: [&f64; 3] = floats.each_ref();
assert_eq!(float_refs, [&3.1, &2.7, &-1.0]);

This method is particularly useful if combined with other methods, like map. This way, you can avoid moving the original array if its elements are not Copy.

#![feature(array_methods, array_map)]

let strings = ["Ferris".to_string(), "♥".to_string(), "Rust".to_string()];
let is_ascii = strings.each_ref().map(|s| s.is_ascii());
assert_eq!(is_ascii, [true, false, true]);

// We can still access the original array: it has not been moved.
assert_eq!(strings.len(), 3);

pub fn each_mut(&mut self) -> [&mut T; N]

🔬 This is a nightly-only experimental API. (array_methods)

Borrows each element mutably and returns an array of mutable references with the same size as self.

Example

#![feature(array_methods)]

let mut floats = [3.1, 2.7, -1.0];
let float_refs: [&mut f64; 3] = floats.each_mut();
*float_refs[0] = 0.0;
assert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);
assert_eq!(floats, [0.0, 2.7, -1.0]);

Trait Implementations

impl<T, const N: usize> Clone for FixedList<T, N> where
    T: Clone + Default, 

pub fn clone(&self) -> FixedList<T, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, const N: usize> Debug for FixedList<T, N> where
    T: Debug + Default, 

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

Formats the value using the given formatter.

impl<T, const N: usize> Deref for FixedList<T, N> where
    T: Default, 

type Target = [T; N]

The resulting type after dereferencing.

pub fn deref(&self) -> &<FixedList<T, N> as Deref>::Target

Dereferences the value.

impl<T, const N: usize> DerefMut for FixedList<T, N> where
    T: Default, 

pub fn deref_mut(&mut self) -> &mut <FixedList<T, N> as Deref>::Target

Mutably dereferences the value.

impl<'de, T, const N: usize> Deserialize<'de> for FixedList<T, N> where
    T: Default + Deserialize<'de>, 

pub fn deserialize<__D>(
    __deserializer: __D
) -> Result<FixedList<T, N>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T, const N: usize> From<FixedList<T, N>> for [T; N] where
    T: Default, 

pub fn from(list: FixedList<T, N>) -> [T; N]

Performs the conversion.

impl<T, const N: usize> Hash for FixedList<T, N> where
    T: Hash + Default, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

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<T, const N: usize> IntoIterator for FixedList<T, N> where
    T: Default, 

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<<FixedList<T, N> as IntoIterator>::Item, N>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> <FixedList<T, N> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, const N: usize> List for FixedList<T, N> where
    T: Default, 

pub fn new_filled_with<F>(n: usize, f: F) -> FixedList<T, N> where
    F: FnMut(usize) -> Option<<FixedList<T, N> as List>::Item>, 

Will make a list that fills up to N, and any additional elements not filled in using the function will be completed with the default value; when the function returns None, the default value will also be used

type Item = T

Represents the type of item within the list

pub fn max_capacity(&self) -> Capacity

Returns the maximum capacity of the list

pub fn len(&self) -> usize

Returns the actual length of the list, which may be less than the actual capacity

pub fn get(&self, index: usize) -> Option<&<FixedList<T, N> as List>::Item>

Returns a reference to an element found at the given index, or None if no element found

pub fn get_mut(
    &mut self,
    index: usize
) -> Option<&mut <FixedList<T, N> as List>::Item>

Returns a mutable reference to an element found at the given index, or None if no element found

pub fn insert(&mut self, index: usize, element: <FixedList<T, N> as List>::Item)

Inserts an element at position index within the vector, shifting all elements after it to the right

pub fn remove(&mut self, index: usize) -> <FixedList<T, N> as List>::Item

Removes and returns the element at position index within the vector, shifting all elements after it to the left.

fn is_empty(&self) -> bool

Returns true if the list is empty

impl<T, const N: usize> Ord for FixedList<T, N> where
    T: Ord + Default, 

pub fn cmp(&self, other: &FixedList<T, N>) -> 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<T, U, const N: usize> PartialEq<[U; N]> for FixedList<T, N> where
    T: PartialEq<U> + Default, 

pub fn eq(&self, other: &[U; N]) -> 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<T, const N: usize> PartialEq<FixedList<T, N>> for FixedList<T, N> where
    T: PartialEq<T> + Default, 

pub fn eq(&self, other: &FixedList<T, N>) -> bool

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

pub fn ne(&self, other: &FixedList<T, N>) -> bool

This method tests for !=.

impl<T, const N: usize> PartialOrd<[T; N]> for FixedList<T, N> where
    T: PartialOrd<T> + Default, 

pub fn partial_cmp(&self, other: &[T; N]) -> 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<T, const N: usize> PartialOrd<FixedList<T, N>> for FixedList<T, N> where
    T: PartialOrd<T> + Default, 

pub fn partial_cmp(&self, other: &FixedList<T, N>) -> 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<T, const N: usize> Serialize for FixedList<T, N> where
    T: Default + Serialize, 

pub fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T, const N: usize> Copy for FixedList<T, N> where
    T: Copy + Default, 

impl<T, const N: usize> Eq for FixedList<T, N> where
    T: Eq + Default, 

impl<T, const N: usize> StructuralEq for FixedList<T, N> where
    T: Default, 

impl<T, const N: usize> StructuralPartialEq for FixedList<T, N> where
    T: Default,