Struct ink_storage::Pack

pub struct Pack<T> { /* fields omitted */ }

Packs the inner T so that it only occupies a single contract storage cell.

Note

This is an important modular building stone in order to manage contract storage occupation. By default types try to distribute themselves onto their respective contract storage area. However, upon packing them into Pack<T> they will be compressed to only ever make use of a single contract storage cell. Sometimes this can be advantageous for performance reasons.

Usage

• A Pack<i32> is equivalent to i32 in its storage occupation.
• A Pack<(i32, i32)> will occupy a single cell compared to (i32, i32) which occupies a cell per i32.
• A Lazy<Pack<[u8; 8]>> lazily loads a Pack<[u8; 8]> which occupies a single cell whereas a [u8; 8] would occupy 8 cells in total - one for each u8.
• Rust collections will never use more than a single cell. So Pack<LinkedList<T>> and LinkedList<T> will occupy the same amount of cells, namely 1.
• Packs can be packed. So for example a Pack<(Pack<(i32, i32)>, Pack<[u8; 8]>) uses just one cell instead of two cells which is the case for (Pack<(i32, i32)>, Pack<[u8; 8]>).
• Not all storage types can be packed. Only those that are implementing the PackedLayout trait. For example storage::Vec<T> does not implement this trait and thus cannot be packed.

As a general advice pack values together that are frequently used together. Also pack many very small elements (e.g. u8, bool, u16) together.

Implementations

impl<T> Pack<T>

pub fn new(value: T) -> Self

Creates a new packed value.

pub fn into_inner(pack: Self) -> T

Returns the packed value.

pub fn as_inner(pack: &Pack<T>) -> &T

Returns a shared reference to the packed value.

pub fn as_inner_mut(pack: &mut Pack<T>) -> &mut T

Returns an exclusive reference to the packed value.

Trait Implementations

impl<T> AsMut<T> for Pack<T>

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

Performs the conversion.

impl<T> AsRef<T> for Pack<T>

fn as_ref(&self) -> &T

Performs the conversion.

impl<T> Borrow<T> for Pack<T>

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T> BorrowMut<T> for Pack<T>

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value.

impl<T: Clone> Clone for Pack<T>

fn clone(&self) -> Pack<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for Pack<T>

impl<T: Debug> Debug for Pack<T>

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

Formats the value using the given formatter.

impl<T> Decode for Pack<T> where
    T: Decode,
    T: Decode, 

fn decode<__CodecInputEdqy: Input>(
    __codec_input_edqy: &mut __CodecInputEdqy
) -> Result<Self, Error>

Attempt to deserialise the value from input.

impl<T> Default for Pack<T> where
    T: Default, 

fn default() -> Self

Returns the "default value" for a type.

impl<T> Deref for Pack<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for Pack<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T> Display for Pack<T> where
    T: Display, 

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

Formats the value using the given formatter.

impl<T> Encode for Pack<T> where
    T: Encode,
    T: Encode, 

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

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

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

Convert self to an owned vector.

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

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

fn size_hint(&self) -> usize

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

impl<T> EncodeLike<Pack<T>> for Pack<T> where
    T: Encode,
    T: Encode, 

impl<T> Eq for Pack<T> where
    T: Eq, 

impl<T> From<T> for Pack<T>

fn from(value: T) -> Self

Performs the conversion.

impl<T> Hash for Pack<T> where
    T: Hash, 

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<T> Ord for Pack<T> where
    T: Ord, 

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

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

Restrict a value to a certain interval.

impl<T> PackedLayout for Pack<T> where
    T: PackedLayout, 

fn pull_packed(&mut self, at: &Key)

Indicates to self that is has just been pulled from the storage.

fn push_packed(&self, at: &Key)

Indicates to self that it is about to be pushed to contract storage.

fn clear_packed(&self, at: &Key)

Indicates to self that it is about to be cleared from contract storage.

impl<T> PartialEq<Pack<T>> for Pack<T> where
    T: PartialEq, 

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> PartialOrd<Pack<T>> for Pack<T> where
    T: PartialOrd, 

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Self) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Self) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn ge(&self, other: &Self) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

fn gt(&self, other: &Self) -> bool

This method tests greater than (for self and other) and is used by the > operator.

impl<T> SpreadLayout for Pack<T> where
    T: PackedLayout, 

const FOOTPRINT: u64

The footprint of the type.

fn pull_spread(ptr: &mut KeyPtr) -> Self

Pulls an instance of Self from the contract storage.

fn push_spread(&self, ptr: &mut KeyPtr)

Pushes an instance of Self to the contract storage.

fn clear_spread(&self, ptr: &mut KeyPtr)

Clears an instance of Self from the contract storage.

const REQUIRES_DEEP_CLEAN_UP: bool

Indicates whether a type requires deep clean-up of its state meaning that a clean-up routine has to decode an entity into an instance in order to eventually recurse upon its tear-down. This is not required for the majority of primitive data types such as i32, however types such as storage::Box that might want to forward the clean-up procedure to their inner T require a deep clean-up.

impl<T> StorageLayout for Pack<T> where
    T: TypeInfo + 'static, 

fn layout(key_ptr: &mut KeyPtr) -> Layout

Returns the static storage layout of Self.