Enum Access

pub enum Access<A>
where
    A: Aleo,
{
    Member(Identifier<A>),
    Index(Integer<A, u32>),
}

A helper type for accessing an entry in a register, struct, array, or record.

Variants

Member(Identifier<A>)

Access a member of a register, struct, or record.

Index(Integer<A, u32>)

Access an element of an array.

Trait Implementations

impl<A> Clone for Access<A>

where A: Clone + Aleo,

fn clone(&self) -> Access<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A> Debug for Access<A>

where A: Aleo,

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

Formats the value using the given formatter.

impl<A> Display for Access<A>

where A: Aleo,

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

Prints the identifier as a string.

impl<A> Eject for Access<A>

where A: Aleo,

fn eject_mode(&self) -> Mode

Ejects the mode of the access.

fn eject_value(&self) -> <Access<A> as Eject>::Primitive

Ejects the access.

type Primitive = Access<<A as Environment>::Network>

fn eject(&self) -> (Mode, Self::Primitive)

Ejects the mode and primitive value of the circuit type.

fn is_constant(&self) -> bool

Returns true if the circuit is a constant.

fn is_public(&self) -> bool

Returns true if the circuit is a public.

fn is_private(&self) -> bool

Returns true if the circuit is a private.

impl<A> FromStr for Access<A>

where A: Aleo,

fn from_str(string: &str) -> Result<Access<A>, Error>

Parses a UTF-8 string into an identifier.

type Err = Error

The associated error which can be returned from parsing.

impl<A> Inject for Access<A>

where A: Aleo,

fn new(_m: Mode, plaintext: <Access<A> as Inject>::Primitive) -> Access<A>

Initializes a new access circuit from a primitive. Note: Access types are always Mode::Constant.

type Primitive = Access<<A as Environment>::Network>

fn constant(value: Self::Primitive) -> Self

where Self: Sized,

Initializes a constant of the given primitive value.

impl<A> Parser for Access<A>

where A: Aleo,

fn parse(string: &str) -> Result<(&str, Access<A>), Err<VerboseError<&str>>>

Parses a UTF-8 string into an access.

impl<A> PartialEq for Access<A>

where A: Aleo,

fn eq(&self, other: &Access<A>) -> bool

Implements the Eq trait for the access.

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<A> Eq for Access<A>

where A: Aleo,