Struct Lock

pub struct Lock<T> { /* private fields */ }

A persistent lock, which stores its state (whether it’s locked or unlocked) on-chain, so that the inner value can be accessed depending on the current state of the lock.

Implementations

impl<T> Lock<T>

pub const fn new(locked: bool, value: T) -> Self

pub const fn unlocked(value: T) -> Self

pub const fn locked(value: T) -> Self

pub const fn set_locked(&mut self, locked: bool) -> &mut Self

pub const fn as_inner_unchecked(&self) -> &T

Safety

This method bypasses lock state checks. Use only when you need to access the inner value regardless of lock state, such as for read operations or when implementing higher-level locking logic.

pub const fn as_inner_unchecked_mut(&mut self) -> &mut T

Safety

This method bypasses lock state checks. Use only when you need mutable access to the inner value regardless of lock state. Misuse can compromise locking semantics.

pub fn into_inner_unchecked(self) -> T

pub const fn is_locked(&self) -> bool

pub const fn as_locked(&self) -> Option<&T>

pub const fn as_locked_mut(&mut self) -> Option<&mut T>

pub const fn as_locked_mut_maybe_forced( &mut self, force: bool, ) -> Option<&mut T>

pub fn into_locked(self) -> Option<T>

pub const fn lock(&mut self) -> Option<&mut T>

pub const fn force_lock(&mut self) -> &mut T

pub const fn get(&self) -> Option<&T>

pub const fn get_mut(&mut self) -> Option<&mut T>

pub const fn get_mut_maybe_forced(&mut self, force: bool) -> Option<&mut T>

pub fn into_unlocked(self) -> Option<T>

pub const fn unlock(&mut self) -> Option<&mut T>

pub const fn force_unlock(&mut self) -> &mut T

pub const fn as_ref(&self) -> Lock<&T>

pub const fn as_mut(&mut self) -> Lock<&mut T>

pub fn map_inner_unchecked<U, F>(self, f: F) -> Lock<U>

where F: FnOnce(T) -> U,

Trait Implementations

impl<T> BorshDeserialize for Lock<T>

where T: BorshDeserialize,

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, As> BorshDeserializeAs<Lock<T>> for Lock<As>

where As: BorshDeserializeAs<T>,

fn deserialize_as<R>(reader: &mut R) -> Result<Lock<T>>

where R: Read,

impl<T> BorshSerialize for Lock<T>

where T: BorshSerialize,

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

impl<T, As> BorshSerializeAs<Lock<T>> for Lock<As>

where As: BorshSerializeAs<T>,

fn serialize_as<W>(source: &Lock<T>, writer: &mut W) -> Result<()>

where W: Write,

impl<T: Debug> Debug for Lock<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Lock<T>

fn default() -> Lock<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Lock<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> From<T> for Lock<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for Lock<T>

fn eq(&self, other: &Lock<T>) -> 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> Serialize for Lock<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for Lock<T>

impl<T> StructuralPartialEq for Lock<T>