Struct mop_structs::vec::VecArray

pub struct VecArray<A> { /* fields omitted */ }

A structure just like Vec, the difference is the inner storage provided by an array.

Methods

impl<A> VecArray<A> where
    A: Array, 

pub fn new(array: A, len: usize) -> Self

Creates a new VecArray from a provided array and length.

Arguments

• array - The array storage

Examples

use mop_structs::vec::VecArray;
let _ = VecArray::new([1, 2, 3, 4, 5], 2);

pub fn new_rnd<F, R>(len: usize, rng: &mut R, cb: F) -> Self where
    F: FnMut(&mut R, usize) -> A::Item,
    R: Rng, 

pub fn with_array(array: A) -> Self

Creates a new VecArray from a provided array. Then length of Self will be the length of array.

Examples

use mop_structs::vec::VecArray;
let _ = VecArray::with_array([0; 10]);

pub fn with_capacity() -> Self

Creates a new empty VecArray from an array type.

Examples

use mop_structs::vec::VecArray;
let _ = VecArray::<[i32; 10]>::with_capacity();

pub fn array(&self) -> &A

pub fn len(&self) -> usize

pub fn try_push(&mut self, item: A::Item) -> bool

Trait Implementations

impl<A> DynDenseSto for VecArray<A> where
    A: Array, 

fn new() -> Self

impl<A> DynDenseStoMut for VecArray<A> where
    A: Array, 

fn clear(&mut self)

Examples

use mop_structs::{
    doc_tests::vec_array,
    prelude::*,
};
let mut a = vec_array();
a.clear();
assert_eq!(&a, &[]);

fn extend(&mut self, other: &[Self::Item]) where
    Self::Item: Copy, 

Examples

use mop_structs::{
    doc_tests::vec_array,
    prelude::*,
};
let mut a = vec_array();
a.extend(&[1, 2]);
assert_eq!(&a, &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2]);

fn extend_from_clone(&mut self, other: &[Self::Item]) where
    Self::Item: Clone, 

Examples

use mop_structs::{
    doc_tests::vec_array,
    prelude::*,
};
let mut a = vec_array();
a.extend_from_clone(&[1, 2]);
assert_eq!(&a, &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2]);

fn push(&mut self, item: A::Item)

Examples

use mop_structs::{
    doc_tests::vec_array,
    prelude::*,
};
let mut a = vec_array();
a.push(100);
assert_eq!(&a, &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100]);

fn swap(&mut self, a: usize, b: usize)

Examples

use mop_structs::{
    doc_tests::vec_array,
    prelude::*,
};
let mut a = vec_array();
a.swap(0, 2);
assert_eq!(&a, &[3, 2, 1, 4, 5, 6, 7, 8, 9, 10]);

fn truncate(&mut self, idx: usize)

Examples

use mop_structs::{
    doc_tests::vec_array,
    prelude::*,
};
let mut a = vec_array();
a.truncate(2);
assert_eq!(&a, &[1, 2]);

impl<A> DynDenseStoRef for VecArray<A> where
    A: Array, 

fn capacity(&self) -> usize

Examples

use mop_structs::{
    doc_tests::vec_array,
    prelude::*,
};
assert_eq!(vec_array().capacity(), 16);

impl<A> StDenseStoMut for VecArray<A> where
    A: Array, 

fn as_mut_slice(&mut self) -> &mut [A::Item]

Examples

use mop_structs::{
    doc_tests::vec_array,
    prelude::*,
};
assert_eq!(vec_array().as_mut_slice(), &mut [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

impl<A> StDenseStoRef for VecArray<A> where
    A: Array, 

type Item = A::Item

fn as_slice(&self) -> &[A::Item]

Examples

use mop_structs::{
    doc_tests::vec_array,
    prelude::*,
};
assert_eq!(&vec_array(), &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

impl<A> AsRef<[<A as Array>::Item]> for VecArray<A> where
    A: Array, 

fn as_ref(&self) -> &[A::Item]

Performs the conversion.

impl<A> AsMut<[<A as Array>::Item]> for VecArray<A> where
    A: Array, 

fn as_mut(&mut self) -> &mut [A::Item]

Performs the conversion.

impl<A: Eq> Eq for VecArray<A>

impl<A: Copy> Copy for VecArray<A>

impl<A: Clone> Clone for VecArray<A>

fn clone(&self) -> VecArray<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: PartialEq> PartialEq<VecArray<A>> for VecArray<A>

fn eq(&self, other: &VecArray<A>) -> bool

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

fn ne(&self, other: &VecArray<A>) -> bool

This method tests for !=.

impl<A: PartialOrd> PartialOrd<VecArray<A>> for VecArray<A>

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

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

fn lt(&self, other: &VecArray<A>) -> bool

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

fn le(&self, other: &VecArray<A>) -> bool

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

fn gt(&self, other: &VecArray<A>) -> bool

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

fn ge(&self, other: &VecArray<A>) -> bool

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

impl<A: Default> Default for VecArray<A>

fn default() -> VecArray<A>

Returns the "default value" for a type.

impl<'a, A> IntoIterator for &'a VecArray<A> where
    A: Array, 

type Item = &'a A::Item

The type of the elements being iterated over.

type IntoIter = Iter<'a, A::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, A> IntoIterator for &'a mut VecArray<A> where
    A: Array, 

type Item = &'a mut A::Item

The type of the elements being iterated over.

type IntoIter = IterMut<'a, A::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A: Hash> Hash for VecArray<A>

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

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<A> Deref for VecArray<A> where
    A: Array, 

type Target = [A::Item]

The resulting type after dereferencing.

fn deref(&self) -> &[A::Item]

Dereferences the value.

impl<A> DerefMut for VecArray<A> where
    A: Array, 

fn deref_mut(&mut self) -> &mut [A::Item]

Mutably dereferences the value.

impl<A> Debug for VecArray<A> where
    A: Array,
    A::Item: Debug, 

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

Formats the value using the given formatter.

impl<A> FromIterator<<A as Array>::Item> for VecArray<A> where
    A: Array, 

fn from_iter<I>(iter: I) -> Self where
    I: IntoIterator<Item = A::Item>, 

Creates a value from an iterator.

impl<A> Borrow<[<A as Array>::Item]> for VecArray<A> where
    A: Array, 

fn borrow(&self) -> &[A::Item]

Immutably borrows from an owned value.

impl<A> BorrowMut<[<A as Array>::Item]> for VecArray<A> where
    A: Array, 

fn borrow_mut(&mut self) -> &mut [A::Item]

Mutably borrows from an owned value.

impl<A> Serialize for VecArray<A> where
    A: Array,
    A::Item: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<'de, A> Deserialize<'de> for VecArray<A> where
    A: Array,
    A::Item: Deserialize<'de>, 

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

Deserialize this value from the given Serde deserializer.