Struct FlaggedStorage

pub struct FlaggedStorage {
    pub value: Uint<256, 4>,
    pub is_private: bool,
}

A storage value that can be either private or public.

Fields

value: Uint<256, 4>

The value of the storage.

is_private: bool

Whether the storage is private.

Implementations

impl FlaggedStorage

pub const ZERO: FlaggedStorage

The default word for a flagged storage slot when no state has been set. Importantly, this slot is public by default

pub fn new<T>(value: T, is_private: bool) -> FlaggedStorage

where Uint<256, 4>: UintTryFrom<T>,

Create a new FlaggedStorage value from a given value and visibility.

pub fn new_from_tuple<T>(_: (T, bool)) -> FlaggedStorage

where Uint<256, 4>: UintTryFrom<T>,

Create a new FlaggedStorage value from a tuple of (value, is_private).

pub fn new_from_value<T>(value: T) -> FlaggedStorage

where Uint<256, 4>: UintTryFrom<T>,

Create a new FlaggedStorage value from a given value.

pub fn collect_value<S>( container: HashMap<FixedBytes<32>, FlaggedStorage, S>, ) -> HashMap<FixedBytes<32>, Uint<256, 4>, S>

where S: BuildHasher + Default,

Collect the values from a HashMap of FlaggedStorage values.

pub fn is_private(&self) -> bool

Check if the storage is private.

pub fn is_public(&self) -> bool

Check if the storage is public.

pub fn set_visibility(&self, is_private: bool) -> FlaggedStorage

Set the visibility of the storage.

pub fn mark_private(&self) -> FlaggedStorage

Mark the storage as private.

pub fn mark_public(&self) -> FlaggedStorage

Mark the storage as public.

pub fn is_zero(&self) -> bool

Check if the storage is zero.

pub fn equals_u256(&self, other: &Uint<256, 4>) -> bool

Compare FlaggedStorage == U256 We do not impl PartialEq for FlaggedStorage because it ends up conflicting with other PartialEq impls

Trait Implementations

impl Arbitrary for FlaggedStorage

type Parameters = (<Uint<256, 4> as Arbitrary>::Parameters, <bool as Arbitrary>::Parameters)

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = Map<(<Uint<256, 4> as Arbitrary>::Strategy, <bool as Arbitrary>::Strategy), fn((Uint<256, 4>, bool)) -> FlaggedStorage>

The type of Strategy used to generate values of type Self.

fn arbitrary_with( _top: <FlaggedStorage as Arbitrary>::Parameters, ) -> <FlaggedStorage as Arbitrary>::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for FlaggedStorage

fn clone(&self) -> FlaggedStorage

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FlaggedStorage

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

Formats the value using the given formatter.

impl Decodable for FlaggedStorage

fn decode(buf: &mut &[u8]) -> Result<FlaggedStorage, Error>

Decodes the blob into the appropriate type. buf must be advanced past the decoded object.

impl Default for FlaggedStorage

fn default() -> FlaggedStorage

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for FlaggedStorage

fn deserialize<__D>( __deserializer: __D, ) -> Result<FlaggedStorage, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodable for FlaggedStorage

fn length(&self) -> usize

Returns the length of the encoding of this type in bytes.

fn encode(&self, out: &mut dyn BufMut)

Encodes the type into the out buffer.

impl From<&FlaggedStorage> for Uint<256, 4>

fn from(storage: &FlaggedStorage) -> Uint<256, 4>

Converts to this type from the input type.

impl From<FlaggedStorage> for FixedBytes<32>

fn from(storage: FlaggedStorage) -> FixedBytes<32>

Converts to this type from the input type.

impl From<FlaggedStorage> for Uint<256, 4>

fn from(storage: FlaggedStorage) -> Uint<256, 4>

Converts to this type from the input type.

impl From<StorageEntry> for FlaggedStorage

fn from(entry: StorageEntry) -> FlaggedStorage

Converts to this type from the input type.

impl<T> From<T> for FlaggedStorage

where Uint<256, 4>: UintTryFrom<T>,

fn from(value: T) -> FlaggedStorage

Converts to this type from the input type.

impl Hash for FlaggedStorage

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

where __H: Hasher,

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl MaxEncodedLenAssoc for FlaggedStorage

const LEN: usize = 34usize

The maximum length.

impl Ord for FlaggedStorage

fn cmp(&self, other: &FlaggedStorage) -> 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 PartialEq for FlaggedStorage

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

Tests for self and other values to be equal, and is used by ==.

const 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 PartialOrd for FlaggedStorage

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

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

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

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

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

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

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

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

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

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

impl PrivateSlot for FlaggedStorage

fn is_private(&self) -> bool

whether the slot is private storage

impl Serialize for FlaggedStorage

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StorageSlot for FlaggedStorage

fn value(self) -> Uint<256, 4>

The underlying value in the storage slot

fn zero() -> Self

The Below should return zeroed out, default words

fn is_zero(&self) -> bool

checks if the storage slot equals the zero() value

impl Copy for FlaggedStorage

impl Eq for FlaggedStorage

impl MaxEncodedLen<alloy_primitives::::storage::flagged_storage::rlp::{impl#2}::{constant#0}> for FlaggedStorage

impl StructuralPartialEq for FlaggedStorage

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 40 bytes