Struct BoundedVec 

pub struct BoundedVec<T, const L: usize, const U: usize, W = NonEmpty<L, U>> { /* private fields */ }

Non-empty Vec bounded with minimal (L - lower bound) and maximal (U - upper bound) items quantity.

Type Parameters

• W - witness type to prove vector ranges and shape of interface accordingly

Implementations

impl<T, const U: usize> BoundedVec<T, 0, U, Empty<U>>

pub fn from_vec( items: Vec<T>, ) -> Result<BoundedVec<T, 0, U, Empty<U>>, BoundedVecOutOfBounds>

Creates new BoundedVec or returns error if items count is out of bounds

Parameters

• items - vector of items within bounds

Errors

• UpperBoundError - if `items`` len is more than U (upper bound)

Example

use bounded_vec::BoundedVec;
use bounded_vec::witnesses;
let data: BoundedVec<_, 0, 8, witnesses::Empty<8>> =
    BoundedVec::<_, 0, 8, witnesses::Empty<8>>::from_vec(vec![1u8, 2]).unwrap();

pub fn first(&self) -> Option<&T>

Returns the first element of the vector, or None if it is empty

Example

use bounded_vec::BoundedVec;
use bounded_vec::witnesses;
use std::convert::TryInto;

let data: BoundedVec<u8, 0, 8, witnesses::Empty<8>> = vec![1u8, 2].try_into().unwrap();
assert_eq!(data.first(), Some(&1u8));

pub fn is_empty(&self) -> bool

Returns true if the vector contains no elements

Example

use bounded_vec::BoundedVec;
use bounded_vec::witnesses;
use std::convert::TryInto;

let data: BoundedVec<u8, 0, 8, witnesses::Empty<8>> = vec![1u8, 2].try_into().unwrap();
assert_eq!(data.is_empty(), false);

pub fn last(&self) -> Option<&T>

Returns the last element of the vector, or None if it is empty

Example

use bounded_vec::BoundedVec;
use bounded_vec::witnesses;
use std::convert::TryInto;

let data: BoundedVec<u8, 0, 8, witnesses::Empty<8>> = vec![1u8, 2].try_into().unwrap();
assert_eq!(data.last(), Some(&2u8));

impl<T, const L: usize, const U: usize, W> BoundedVec<T, L, U, W>

Methods which works for all witnesses

pub fn as_vec(&self) -> &Vec<T>

Returns a reference to underlying `Vec``

Example

use bounded_vec::BoundedVec;
use std::convert::TryInto;

let data: BoundedVec<_, 2, 8> = vec![1u8, 2].try_into().unwrap();
assert_eq!(data.as_vec(), &vec![1u8,2]);

pub fn to_vec(self) -> Vec<T>

Returns an underlying `Vec``

Example

use bounded_vec::BoundedVec;
use std::convert::TryInto;

let data: BoundedVec<_, 2, 8> = vec![1u8, 2].try_into().unwrap();
assert_eq!(data.to_vec(), vec![1u8,2]);

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

Extracts a slice containing the entire vector.

Example

use bounded_vec::BoundedVec;
use std::convert::TryInto;

let data: BoundedVec<_, 2, 8> = vec![1u8, 2].try_into().unwrap();
assert_eq!(data.as_slice(), &[1u8,2]);

pub fn get(&self, index: usize) -> Option<&T>

Returns a reference for an element at index or None if out of bounds

Example

use bounded_vec::BoundedVec;
let data: BoundedVec<u8, 2, 8> = [1u8,2].into();
let elem = *data.get(1).unwrap();
assert_eq!(elem, 2);

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows to modify each value

impl<T, const L: usize, const U: usize> BoundedVec<T, L, U>

pub fn from_vec( items: Vec<T>, ) -> Result<BoundedVec<T, L, U>, BoundedVecOutOfBounds>

Creates new BoundedVec or returns error if items count is out of bounds

Parameters

• items - vector of items within bounds

Errors

• LowerBoundError - if `items`` len is less than L (lower bound)
• UpperBoundError - if `items`` len is more than U (upper bound)

Example

use bounded_vec::BoundedVec;
use bounded_vec::witnesses;
let data: BoundedVec<_, 2, 8, witnesses::NonEmpty<2, 8>> =
    BoundedVec::<_, 2, 8, witnesses::NonEmpty<2, 8>>::from_vec(vec![1u8, 2]).unwrap();

pub fn len(&self) -> usize

Returns the number of elements in the vector

Example

use bounded_vec::BoundedVec;
use std::convert::TryInto;

let data: BoundedVec<u8, 2, 4> = vec![1u8,2].try_into().unwrap();
assert_eq!(data.len(), 2);

pub fn first(&self) -> &T

Returns the first element of non-empty Vec

Example

use bounded_vec::BoundedVec;
use std::convert::TryInto;

let data: BoundedVec<_, 2, 8> = vec![1u8, 2].try_into().unwrap();
assert_eq!(*data.first(), 1);

pub fn last(&self) -> &T

Returns the last element of non-empty Vec

Example

use bounded_vec::BoundedVec;
use std::convert::TryInto;

let data: BoundedVec<_, 2, 8> = vec![1u8, 2].try_into().unwrap();
assert_eq!(*data.last(), 2);

pub fn mapped<F, N>(self, map_fn: F) -> BoundedVec<N, L, U>

where F: FnMut(T) -> N,

Create a new BoundedVec by consuming self and mapping each element.

This is useful as it keeps the knowledge that the length is >= U, <= L, even through the old BoundedVec is consumed and turned into an iterator.

Example

use bounded_vec::BoundedVec;
let data: BoundedVec<u8, 2, 8> = [1u8,2].into();
let data = data.mapped(|x|x*2);
assert_eq!(data, [2u8,4].into());

pub fn mapped_ref<F, N>(&self, map_fn: F) -> BoundedVec<N, L, U>

where F: FnMut(&T) -> N,

Create a new BoundedVec by mapping references to the elements of self

This is useful as it keeps the knowledge that the length is >= U, <= L, will still hold for new BoundedVec

Example

use bounded_vec::BoundedVec;
let data: BoundedVec<u8, 2, 8> = [1u8,2].into();
let data = data.mapped_ref(|x|x*2);
assert_eq!(data, [2u8,4].into());

pub fn try_mapped<F, N, E>(self, map_fn: F) -> Result<BoundedVec<N, L, U>, E>

where F: FnMut(T) -> Result<N, E>,

Create a new BoundedVec by consuming self and mapping each element to a Result.

This is useful as it keeps the knowledge that the length is preserved even through the old BoundedVec is consumed and turned into an iterator.

As this method consumes self, returning an error means that this vec is dropped. I.e. this method behaves roughly like using a chain of into_iter(), map, collect::<Result<Vec<N>,E>> and then converting the Vec back to a Vec1.

Errors

Once any call to map_fn returns a error that error is directly returned by this method.

Example

use bounded_vec::BoundedVec;
let data: BoundedVec<u8, 2, 8> = [1u8,2].into();
let data: Result<BoundedVec<u8, 2, 8>, _> = data.try_mapped(|x| Err("failed"));
assert_eq!(data, Err("failed"));

pub fn try_mapped_ref<F, N, E>( &self, map_fn: F, ) -> Result<BoundedVec<N, L, U>, E>

where F: FnMut(&T) -> Result<N, E>,

Create a new BoundedVec by mapping references of self elements to a Result.

This is useful as it keeps the knowledge that the length is preserved even through the old BoundedVec is consumed and turned into an iterator.

Errors

Once any call to map_fn returns a error that error is directly returned by this method.

Example

use bounded_vec::BoundedVec;
let data: BoundedVec<u8, 2, 8> = [1u8,2].into();
let data: Result<BoundedVec<u8, 2, 8>, _> = data.try_mapped_ref(|x| Err("failed"));
assert_eq!(data, Err("failed"));

pub fn split_last(&self) -> (&T, &[T])

Returns the last and all the rest of the elements

pub fn enumerated(self) -> BoundedVec<(usize, T), L, U>

Return a new BoundedVec with indices included

pub fn opt_empty_vec( v: Vec<T>, ) -> Result<Option<BoundedVec<T, L, U>>, BoundedVecOutOfBounds>

Return a Some(BoundedVec) or None if v is empty

Example

use bounded_vec::BoundedVec;
use bounded_vec::OptBoundedVecToVec;

let opt_bv_none = BoundedVec::<u8, 2, 8>::opt_empty_vec(vec![]).unwrap();
assert!(opt_bv_none.is_none());
assert_eq!(opt_bv_none.to_vec(), Vec::<u8>::new());
let opt_bv_some = BoundedVec::<u8, 2, 8>::opt_empty_vec(vec![0u8, 2]).unwrap();
assert!(opt_bv_some.is_some());
assert_eq!(opt_bv_some.to_vec(), vec![0u8, 2]);

Trait Implementations

impl<T, const L: usize, const U: usize, W> AsMut<[T]> for BoundedVec<T, L, U, W>

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

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

impl<T, const L: usize, const U: usize, W> AsMut<Vec<T>> for BoundedVec<T, L, U, W>

fn as_mut(&mut self) -> &mut Vec<T>

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

impl<T, const L: usize, const U: usize, W> AsRef<[T]> for BoundedVec<T, L, U, W>

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

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

impl<T, const L: usize, const U: usize, W> AsRef<Vec<T>> for BoundedVec<T, L, U, W>

fn as_ref(&self) -> &Vec<T>

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

impl<T, const L: usize, const U: usize, W> Clone for BoundedVec<T, L, U, W>

where T: Clone, W: Clone,

fn clone(&self) -> BoundedVec<T, L, U, W>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, const L: usize, const U: usize, W> Debug for BoundedVec<T, L, U, W>

where T: Debug, W: Debug,

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

Formats the value using the given formatter.

impl<'de, T, const U: usize> Deserialize<'de> for BoundedVec<T, 0, U, Empty<U>>

where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D, ) -> Result<BoundedVec<T, 0, U, Empty<U>>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T, const L: usize, const U: usize> Deserialize<'de> for BoundedVec<T, L, U>

where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D, ) -> Result<BoundedVec<T, L, U>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, const L: usize, const U: usize> From<[T; L]> for BoundedVec<T, L, U>

fn from(arr: [T; L]) -> BoundedVec<T, L, U>

Converts to this type from the input type.

impl<T, const L: usize, const U: usize> From<BoundedVec<T, L, U>> for Vec<T>

fn from(v: BoundedVec<T, L, U>) -> Vec<T>

Converts to this type from the input type.

impl<T, const L: usize, const U: usize, W> Hash for BoundedVec<T, L, U, W>

where T: Hash, W: Hash,

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, T, const L: usize, const U: usize, W> IntoIterator for &'a BoundedVec<T, L, U, W>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a BoundedVec<T, L, U, W> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const L: usize, const U: usize, W> IntoIterator for &'a mut BoundedVec<T, L, U, W>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a mut BoundedVec<T, L, U, W> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, const L: usize, const U: usize, W> IntoIterator for BoundedVec<T, L, U, W>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <BoundedVec<T, L, U, W> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, const L: usize, const U: usize, W> Ord for BoundedVec<T, L, U, W>

where T: Ord, W: Ord,

fn cmp(&self, other: &BoundedVec<T, L, U, W>) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl<T, const L: usize, const U: usize, W> PartialEq for BoundedVec<T, L, U, W>

where T: PartialEq, W: PartialEq,

fn eq(&self, other: &BoundedVec<T, L, U, W>) -> 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, const L: usize, const U: usize, W> PartialOrd for BoundedVec<T, L, U, W>

where T: PartialOrd, W: PartialOrd,

fn partial_cmp(&self, other: &BoundedVec<T, L, U, W>) -> 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, const L: usize, const U: usize, W> Serialize for BoundedVec<T, L, U, W>

where T: Serialize,

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 U: usize> TryFrom<Vec<T>> for BoundedVec<T, 0, U, Empty<U>>

type Error = BoundedVecOutOfBounds

The type returned in the event of a conversion error.

fn try_from( value: Vec<T>, ) -> Result<BoundedVec<T, 0, U, Empty<U>>, <BoundedVec<T, 0, U, Empty<U>> as TryFrom<Vec<T>>>::Error>

Performs the conversion.

impl<T, const L: usize, const U: usize> TryFrom<Vec<T>> for BoundedVec<T, L, U>

type Error = BoundedVecOutOfBounds

The type returned in the event of a conversion error.

fn try_from( value: Vec<T>, ) -> Result<BoundedVec<T, L, U>, <BoundedVec<T, L, U> as TryFrom<Vec<T>>>::Error>

Performs the conversion.

impl<T, const L: usize, const U: usize, W> Eq for BoundedVec<T, L, U, W>

where T: Eq, W: Eq,

impl<T, const L: usize, const U: usize, W> StructuralPartialEq for BoundedVec<T, L, U, W>