Struct frame_support::storage::bounded_vec::BoundedVec

pub struct BoundedVec<T, S>(_, _);

A bounded vector.

It has implementations for efficient append and length decoding, as with a normal Vec<_>, once put into storage as a raw value, map or double-map.

As the name suggests, the length of the queue is always bounded. All internal operations ensure this bound is respected.

Implementations

impl<T, S> BoundedVec<T, S>

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

Consume self, and return the inner Vec. Henceforth, the Vec<_> can be altered in an arbitrary way. At some point, if the reverse conversion is required, TryFrom<Vec<_>> can be used.

This is useful for cases if you need access to an internal API of the inner Vec<_> which is not provided by the wrapper BoundedVec.

pub fn remove(&mut self, index: usize) -> T

Exactly the same semantics as Vec::remove.

Panics

Panics if index is out of bounds.

pub fn swap_remove(&mut self, index: usize) -> T

Exactly the same semantics as Vec::swap_remove.

Panics

Panics if index is out of bounds.

pub fn retain<F: FnMut(&T) -> bool>(&mut self, f: F)

Exactly the same semantics as Vec::retain.

pub fn get_mut<I: SliceIndex<[T]>>(
    &mut self,
    index: I
) -> Option<&mut <I as SliceIndex<[T]>>::Output>

Exactly the same semantics as [Vec::get_mut].

impl<T, S: Get<u32>> BoundedVec<T, S>

pub fn bound() -> usize

Get the bound of the type in usize.

pub fn try_mutate(self, mutate: impl FnMut(&mut Vec<T>)) -> Option<Self>

Consumes self and mutates self via the given mutate function.

If the outcome of mutation is within bounds, Some(Self) is returned. Else, None is returned.

This is essentially a consuming shorthand Self::into_inner -> ... -> Self::try_from.

pub fn try_insert(&mut self, index: usize, element: T) -> Result<(), ()>

Exactly the same semantics as Vec::insert, but returns an Err (and is a noop) if the new length of the vector exceeds S.

Panics

Panics if index > len.

pub fn try_push(&mut self, element: T) -> Result<(), ()>

Exactly the same semantics as Vec::push, but returns an Err (and is a noop) if the new length of the vector exceeds S.

Panics

Panics if the new capacity exceeds isize::MAX bytes.

Methods from Deref<Target = Vec<T>>

pub fn capacity(&self) -> usize

Returns the number of elements the vector can hold without reallocating.

Examples

let vec: Vec<i32> = Vec::with_capacity(10);
assert_eq!(vec.capacity(), 10);

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

Extracts a slice containing the entire vector.

Equivalent to &s[..].

Examples

use std::io::{self, Write};
let buffer = vec![1, 2, 3, 5, 8];
io::sink().write(buffer.as_slice()).unwrap();

pub fn as_ptr(&self) -> *const T

Returns a raw pointer to the vector’s buffer.

The caller must ensure that the vector outlives the pointer this function returns, or else it will end up pointing to garbage. Modifying the vector may cause its buffer to be reallocated, which would also make any pointers to it invalid.

The caller must also ensure that the memory the pointer (non-transitively) points to is never written to (except inside an UnsafeCell) using this pointer or any pointer derived from it. If you need to mutate the contents of the slice, use as_mut_ptr.

Examples

let x = vec![1, 2, 4];
let x_ptr = x.as_ptr();

unsafe {
    for i in 0..x.len() {
        assert_eq!(*x_ptr.add(i), 1 << i);
    }
}

pub fn allocator(&self) -> &A

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

Returns a reference to the underlying allocator.

pub fn len(&self) -> usize

Returns the number of elements in the vector, also referred to as its ‘length’.

Examples

let a = vec![1, 2, 3];
assert_eq!(a.len(), 3);

pub fn is_empty(&self) -> bool

Returns true if the vector contains no elements.

Examples

let mut v = Vec::new();
assert!(v.is_empty());

v.push(1);
assert!(!v.is_empty());

Trait Implementations

impl<T, S> AsMut<[T]> for BoundedVec<T, S>

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

Performs the conversion.

impl<T, S> AsRef<[T]> for BoundedVec<T, S>

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

Performs the conversion.

impl<T, S> AsRef<Vec<T, Global>> for BoundedVec<T, S>

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

Performs the conversion.

impl<T, S> Clone for BoundedVec<T, S> where
    T: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, S> Debug for BoundedVec<T, S> where
    T: Debug,
    S: Get<u32>, 

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

Formats the value using the given formatter.

impl<T: Decode, S: Get<u32>> Decode for BoundedVec<T, S>

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn skip<I: Input>(input: &mut I) -> Result<(), Error>

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<T, S> DecodeLength for BoundedVec<T, S>

fn len(self_encoded: &[u8]) -> Result<usize, Error>

Return the number of elements in self_encoded.

impl<T, S> Default for BoundedVec<T, S>

fn default() -> Self

Returns the “default value” for a type.

impl<T, S> Deref for BoundedVec<T, S>

type Target = Vec<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, S> Encode for BoundedVec<T, S> where
    Vec<T>: Encode,
    Vec<T>: Encode,
    PhantomData<S>: Encode,
    PhantomData<S>: Encode, 

fn encode_to<__CodecOutputEdqy: Output + ?Sized>(
    &self,
    __codec_dest_edqy: &mut __CodecOutputEdqy
)

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R where
    F: FnOnce(&[u8]) -> R, 

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<T, S: Get<u32>> From<BoundedVec<T, S>> for Vec<T>

fn from(x: BoundedVec<T, S>) -> Vec<T>

Performs the conversion.

impl<T, S, I> Index<I> for BoundedVec<T, S> where
    I: SliceIndex<[T]>, 

type Output = I::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, S, I> IndexMut<I> for BoundedVec<T, S> where
    I: SliceIndex<[T]>, 

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T, S> IntoIterator for BoundedVec<T, S>

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) -> Self::IntoIter

Creates an iterator from a value.

impl<T, S> MaxEncodedLen for BoundedVec<T, S> where
    T: MaxEncodedLen,
    S: Get<u32>,
    BoundedVec<T, S>: Encode, 

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<T, S> PartialEq<BoundedVec<T, S>> for BoundedVec<T, S> where
    T: PartialEq, 

fn eq(&self, rhs: &Self) -> 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: PartialEq, S: Get<u32>> PartialEq<Vec<T, Global>> for BoundedVec<T, S>

fn eq(&self, other: &Vec<T>) -> 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, S> StorageDecodeLength for BoundedVec<T, S>

fn decode_len(key: &[u8]) -> Option<usize>

Decode the length of the storage value at key.

impl<T, S: Get<u32>> StorageTryAppend<T> for BoundedVec<T, S>

fn bound() -> usize

impl<T, S: Get<u32>> TryFrom<Vec<T, Global>> for BoundedVec<T, S>

type Error = ()

The type returned in the event of a conversion error.

fn try_from(t: Vec<T>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, S> EncodeLike<BoundedVec<T, S>> for BoundedVec<T, S> where
    Vec<T>: Encode,
    Vec<T>: Encode,
    PhantomData<S>: Encode,
    PhantomData<S>: Encode, 

impl<'a, T: Encode + Decode, S: Get<u32>> EncodeLike<BoundedVec<T, S>> for BoundedSlice<'a, T, S>

impl<T: Encode + Decode, S: Get<u32>> EncodeLike<Vec<T, Global>> for BoundedVec<T, S>

impl<T, S> Eq for BoundedVec<T, S> where
    T: Eq,