Struct Lazy

pub struct Lazy<T>
where
    T: BorshSerialize,
{ /* private fields */ }

An persistent lazily loaded value, that stores a value in the storage.

This will only write to the underlying store if the value has changed, and will only read the existing value from storage once.

Examples

use near_sdk::store::Lazy;

let mut a = Lazy::new(b"a", "test string".to_string());
assert_eq!(*a, "test string");

*a = "new string".to_string();
assert_eq!(a.get(), "new string");

Implementations

impl<T> Lazy<T>

where T: BorshSerialize,

pub fn new<S>(key: S, value: T) -> Self

where S: IntoStorageKey,

Initializes new lazily loaded value with a given storage prefix and the value to initialize it with.

This prefix can be anything that implements IntoStorageKey. The prefix is used when storing and looking up values in storage to ensure no collisions with other collections.

pub fn set(&mut self, value: T)

Updates the value with a new value. This does not load the current value from storage.

pub fn flush(&mut self)

Writes any changes to the value to storage. This will automatically be done when the value is dropped through Drop so this should only be used when the changes need to be reflected in the underlying storage before then.

pub fn remove(&mut self) -> bool

Removes the underlying storage item. Useful for deprecating the obsolete Lazy values.

impl<T> Lazy<T>

where T: BorshSerialize + BorshDeserialize,

pub fn get(&self) -> &T

Returns a reference to the lazily loaded storage value. The load from storage only happens once, and if the value is already cached, it will not be reloaded.

This function will panic if the cache is not loaded and the value at the key does not exist.

pub fn get_mut(&mut self) -> &mut T

Returns a reference to the lazily loaded storage value. The load from storage only happens once, and if the value is already cached, it will not be reloaded.

This function will panic if the cache is not loaded and the value at the key does not exist.

Trait Implementations

impl<T> AsMut<T> for Lazy<T>

where T: BorshSerialize + BorshDeserialize,

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsRef<T> for Lazy<T>

where T: BorshSerialize + BorshDeserialize,

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> BorshDeserialize for Lazy<T>

where T: BorshSerialize,

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<T> BorshSchema for Lazy<T>

where T: BorshSerialize,

fn declaration() -> Declaration

Get the name of the type without brackets.

fn add_definitions_recursively( definitions: &mut BTreeMap<Declaration, Definition>, )

Recursively, using DFS, add type definitions required for this type. Type definition partially explains how to serialize/deserialize a type.

impl<T> BorshSerialize for Lazy<T>

where T: BorshSerialize,

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

impl<T> Debug for Lazy<T>

where T: Debug + BorshSerialize + BorshDeserialize,

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

Formats the value using the given formatter.

impl<T> Deref for Lazy<T>

where T: BorshSerialize + BorshDeserialize,

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T> DerefMut for Lazy<T>

where T: BorshSerialize + BorshDeserialize,

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

Mutably dereferences the value.

impl<T> Drop for Lazy<T>

where T: BorshSerialize,

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Ord for Lazy<T>

where T: Ord + BorshSerialize + BorshDeserialize,

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl<T> PartialEq for Lazy<T>

where T: PartialEq + BorshSerialize + BorshDeserialize,

fn eq(&self, other: &Self) -> 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<T> PartialOrd for Lazy<T>

where T: PartialOrd + BorshSerialize + BorshDeserialize,

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

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

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

Tests greater than (for self and other) and is used by the > operator.

impl<T> Eq for Lazy<T>

where T: Eq + BorshSerialize + BorshDeserialize,