Struct StateWithExtensionsMut

pub struct StateWithExtensionsMut<'data, S: BaseState> {
    pub base: S,
    /* private fields */
}

Encapsulates mutable base state data (mint or account) with possible extensions

Fields

base: S

Unpacked base data

Implementations

impl<'data, S: BaseState> StateWithExtensionsMut<'data, S>

pub fn unpack(input: &'data mut [u8]) -> Result<Self, ProgramError>

Unpack base state, leaving the extension data as a mutable slice

Fails if the base state is not initialized.

pub fn unpack_uninitialized( input: &'data mut [u8], ) -> Result<Self, ProgramError>

Unpack an uninitialized base state, leaving the extension data as a mutable slice

Fails if the base state has already been initialized.

pub fn get_extension_mut<V: Extension>( &mut self, ) -> Result<&mut V, ProgramError>

Unpack a portion of the TLV data as the desired type that allows modifying the type

pub fn pack_base(&mut self)

Packs base state data into the base data portion

pub fn init_extension<V: Extension>( &mut self, overwrite: bool, ) -> Result<&mut V, ProgramError>

Packs the default extension data into an open slot if not already found in the data buffer. If extension is already found in the buffer, it overwrites the existing extension with the default state if overwrite is set. If extension found, but overwrite is not set, it returns error.

pub fn init_account_extension_from_type( &mut self, extension_type: ExtensionType, ) -> Result<(), ProgramError>

If extension_type is an Account-associated ExtensionType that requires initialization on InitializeAccount, this method packs the default relevant Extension of an ExtensionType into an open slot if not already found in the data buffer, otherwise overwrites the existing extension with the default state. For all other ExtensionTypes, this is a no-op.

pub fn init_account_type(&mut self) -> Result<(), ProgramError>

Write the account type into the buffer, done during the base state initialization Noops if there is no room for an extension in the account, needed for pure base mints / accounts.

Trait Implementations

impl<'a, S: BaseState> BaseStateWithExtensions<S> for StateWithExtensionsMut<'a, S>

fn get_tlv_data(&self) -> &[u8]

Get the buffer containing all extension data

fn get_extension<V: Extension>(&self) -> Result<&V, ProgramError>

Unpack a portion of the TLV data as the desired type

fn get_extension_types(&self) -> Result<Vec<ExtensionType>, ProgramError>

Iterates through the TLV entries, returning only the types

fn get_first_extension_type( &self, ) -> Result<Option<ExtensionType>, ProgramError>

Get just the first extension type, useful to track mixed initializations

impl<'data, S: Debug + BaseState> Debug for StateWithExtensionsMut<'data, S>

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

Formats the value using the given formatter.

impl<'data, S: PartialEq + BaseState> PartialEq for StateWithExtensionsMut<'data, S>

fn eq(&self, other: &StateWithExtensionsMut<'data, S>) -> 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<'data, S: BaseState> StructuralPartialEq for StateWithExtensionsMut<'data, S>