Struct ink_storage::Pack

pub struct Pack<T> where
    T: PackedLayout,  { /* 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> instance is equivalent to i32 in its storage occupation.
• A Pack<(i32, i32)> instance 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] array 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> where
    T: PackedLayout, 

pub fn new(value: T) -> Self

Creates a new 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> where
    T: PackedLayout, 

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

Performs the conversion.

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

fn as_ref(&self) -> &T

Performs the conversion.

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

fn borrow(&self) -> &T

Immutably borrows from an owned value.

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

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

Mutably borrows from an owned value.

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

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: Debug> Debug for Pack<T> where
    T: PackedLayout, 

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

Formats the value using the given formatter.

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

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn skip<I>(input: &mut I) -> Result<(), Error> where
    I: Input, 

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

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

fn default() -> Self

Returns the “default value” for a type.

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

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

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

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

Mutably dereferences the value.

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

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

Formats the value using the given formatter.

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

fn drop(&mut self)

Executes the destructor for this type.

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

fn size_hint(&self) -> usize

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

fn encode_to<O: Output + ?Sized>(&self, dest: &mut O)

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 encoded_size(&self) -> usize

Calculates the encoded size.

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

fn from(value: T) -> Self

Performs the conversion.

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

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 + PackedLayout, 

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

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 + PackedLayout, 

fn eq(&self, other: &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> PartialOrd<Pack<T>> for Pack<T> where
    T: PartialOrd + PackedLayout, 

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: PackedLayout + TypeInfo + 'static, 

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

Returns the static storage layout of Self.

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