Struct sov_state::StateVec

pub struct StateVec<V, Codec = BorshCodec> { /* private fields */ }

Implementations

impl<V> StateVec<V>where BorshCodec: StateValueCodec<V>,

pub fn new(prefix: Prefix) -> Self

Crates a new StateVec with the given prefix and the default StateValueCodec (i.e. BorshCodec).

impl<V, Codec> StateVec<V, Codec>where Codec: StateCodec + Clone, Codec::ValueCodec: StateValueCodec<V> + StateValueCodec<usize>, Codec::KeyCodec: StateKeyCodec<usize>,

pub fn with_codec(prefix: Prefix, codec: Codec) -> Self

Creates a new StateVec with the given prefix and codec.

pub fn prefix(&self) -> &Prefix

Returns the prefix used when this StateVec was created.

pub fn set<S: Storage>( &self, index: usize, value: &V, working_set: &mut WorkingSet<S> ) -> Result<(), Error>

Sets a value in the StateVec. If the index is out of bounds, returns an error. To push a value to the end of the StateVec, use StateVec::push.

pub fn get<S: Storage>( &self, index: usize, working_set: &mut WorkingSet<S> ) -> Option<V>

Returns the value for the given index.

pub fn get_or_err<S: Storage>( &self, index: usize, working_set: &mut WorkingSet<S> ) -> Result<V, Error>

Returns the value for the given index. If the index is out of bounds, returns an error. If the value is absent, returns an error.

pub fn len<S: Storage>(&self, working_set: &mut WorkingSet<S>) -> usize

Returns the length of the StateVec.

pub fn push<S: Storage>(&self, value: &V, working_set: &mut WorkingSet<S>)

Pushes a value to the end of the StateVec.

pub fn pop<S: Storage>(&self, working_set: &mut WorkingSet<S>) -> Option<V>

Pops a value from the end of the StateVec and returns it.

pub fn clear<S: Storage>(&self, working_set: &mut WorkingSet<S>)

pub fn set_all<S: Storage>( &self, values: Vec<V>, working_set: &mut WorkingSet<S> )

Sets all values in the StateVec.

If the length of the provided values is less than the length of the StateVec, the remaining values will be removed from storage.

pub fn iter<'a, 'ws, S: Storage>( &'a self, working_set: &'ws mut WorkingSet<S> ) -> StateVecIter<'a, 'ws, V, Codec, S>

Returns an iterator over all the values in the StateVec.

pub fn last<S: Storage>(&self, working_set: &mut WorkingSet<S>) -> Option<V>

Trait Implementations

impl<V, Codec> BorshDeserialize for StateVec<V, Codec>where PhantomData<V>: BorshDeserialize, Prefix: BorshDeserialize, StateValue<usize, Codec>: BorshDeserialize, StateMap<usize, V, Codec>: BorshDeserialize,

fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>where R: Read,

impl<V, Codec> BorshSerialize for StateVec<V, Codec>where PhantomData<V>: BorshSerialize, Prefix: BorshSerialize, StateValue<usize, Codec>: BorshSerialize, StateMap<usize, V, Codec>: BorshSerialize,

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

fn try_to_vec(&self) -> Result<Vec<u8, Global>, Error>

Serialize this instance into a vector of bytes.

impl<V: Clone, Codec: Clone> Clone for StateVec<V, Codec>

fn clone(&self) -> StateVec<V, Codec>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Debug, Codec: Debug> Debug for StateVec<V, Codec>

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

Formats the value using the given formatter.

impl<'de, V, Codec> Deserialize<'de> for StateVec<V, Codec>where V: Deserialize<'de>, Codec: Deserialize<'de>,

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

Deserialize this value from the given Serde deserializer.

impl<V: PartialEq, Codec: PartialEq> PartialEq<StateVec<V, Codec>> for StateVec<V, Codec>

fn eq(&self, other: &StateVec<V, Codec>) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V, Codec> Serialize for StateVec<V, Codec>where V: Serialize, Codec: Serialize,

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

Serialize this value into the given Serde serializer.

impl<V, Codec> StructuralPartialEq for StateVec<V, Codec>