Struct PodStateWithExtensionsMut

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

Encapsulates mutable base state data (mint or account) with possible extensions, where the base state is Pod for zero-copy serde.

Fields

base: &'data mut S

Unpacked base data

Implementations

impl<'data, S: BaseState + Pod> PodStateWithExtensionsMut<'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.

Trait Implementations

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

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

Get the buffer containing all extension data

fn get_extension_bytes<V: Extension>(&self) -> Result<&[u8], ProgramError>

Fetch the bytes for a TLV entry

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

Unpack a portion of the TLV data as the desired type

fn get_variable_len_extension<V: Extension + VariableLenPack>( &self, ) -> Result<V, ProgramError>

Unpacks a portion of the TLV data as the desired variable-length 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

fn try_get_account_len(&self) -> Result<usize, ProgramError>

Get the total number of bytes used by TLV entries and the base type

fn try_get_new_account_len<V: Extension + Pod>( &self, ) -> Result<usize, ProgramError>

Calculate the new expected size if the state allocates the given fixed-length extension instance. If the state already has the extension, the resulting account length will be unchanged.

fn try_get_new_account_len_for_variable_len_extension<V: Extension + VariableLenPack>( &self, new_extension: &V, ) -> Result<usize, ProgramError>

Calculate the new expected size if the state allocates the given variable-length extension instance.

impl<'a, S: BaseState> BaseStateWithExtensionsMut<S> for PodStateWithExtensionsMut<'a, S>

fn get_tlv_data_mut(&mut self) -> &mut [u8]

Get the underlying TLV data as mutable

fn get_account_type_mut(&mut self) -> &mut [u8]

Get the underlying account type as mutable

fn get_extension_bytes_mut<V: Extension>( &mut self, ) -> Result<&mut [u8], ProgramError>

Unpack a portion of the TLV data as the base mutable bytes

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

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

fn pack_variable_len_extension<V: Extension + VariableLenPack>( &mut self, extension: &V, ) -> Result<(), ProgramError>

Packs a variable-length extension into its appropriate data segment. Fails if space hasn’t already been allocated for the given extension

fn init_extension<V: Extension + Pod + Default>( &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.

fn realloc_variable_len_extension<V: Extension + VariableLenPack>( &mut self, new_extension: &V, ) -> Result<(), ProgramError>

Reallocate and overwrite the TLV entry for the given variable-length extension.

fn realloc<V: Extension + VariableLenPack>( &mut self, length: usize, ) -> Result<&mut [u8], ProgramError>

Reallocate the TLV entry for the given extension to the given number of bytes.

fn init_variable_len_extension<V: Extension + VariableLenPack>( &mut self, extension: &V, overwrite: bool, ) -> Result<(), ProgramError>

Allocate the given number of bytes for the given variable-length extension and write its contents into the TLV buffer.

fn alloc<V: Extension>( &mut self, length: usize, overwrite: bool, ) -> Result<&mut [u8], ProgramError>

Allocate some space for the extension in the TLV data

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.

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.

fn check_account_type_matches_extension_type(&self) -> Result<(), ProgramError>

Check that the account type on the account (if initialized) matches the account type for any extensions initialized on the TLV data

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

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

Formats the value using the given formatter.

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

fn eq(&self, other: &PodStateWithExtensionsMut<'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 PodStateWithExtensionsMut<'data, S>