Struct frame_support::storage::weak_bounded_vec::WeakBoundedVec

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

A weakly 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.

The length of the vec is not strictly bounded. Decoding a vec with more element that the bound is accepted, and some method allow to bypass the restriction with warnings.

Implementations

impl<T, S> WeakBoundedVec<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 WeakBoundedVec.

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>> WeakBoundedVec<T, S>

pub fn bound() -> usize

Get the bound of the type in usize.

pub fn force_from(t: Vec<T>, scope: Option<&'static str>) -> Self

Create Self from t without any checks. Logs warnings if the bound is not being respected. The additional scope can be used to indicate where a potential overflow is happening.

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 WeakBoundedVec<T, S>

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

impl<T, S> Clone for WeakBoundedVec<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 WeakBoundedVec<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 WeakBoundedVec<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 WeakBoundedVec<T, S>

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

Return the number of elements in self_encoded.

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

fn default() -> Self

Returns the “default value” for a type.

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

type Target = Vec<T>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, S> Encode for WeakBoundedVec<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, I> Index<I> for WeakBoundedVec<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 WeakBoundedVec<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 WeakBoundedVec<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 WeakBoundedVec<T, S> where
    T: MaxEncodedLen,
    S: Get<u32>,
    WeakBoundedVec<T, S>: Encode, 

fn max_encoded_len() -> usize

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

impl<T: PartialEq, S: Get<u32>> PartialEq<Vec<T, Global>> for WeakBoundedVec<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> PartialEq<WeakBoundedVec<T, S>> for WeakBoundedVec<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, S> StorageDecodeLength for WeakBoundedVec<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 WeakBoundedVec<T, S>

fn bound() -> usize

impl<T, S: Get<u32>> TryFrom<Vec<T, Global>> for WeakBoundedVec<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<WeakBoundedVec<T, S>> for WeakBoundedVec<T, S> where
    Vec<T>: Encode,
    Vec<T>: Encode,
    PhantomData<S>: Encode,
    PhantomData<S>: Encode, 

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