Enum LiteralType 

pub enum LiteralType {
    Address,
    Boolean,
    Field,
    Group,
    I8,
    I16,
    I32,
    I64,
    I128,
    U8,
    U16,
    U32,
    U64,
    U128,
    Scalar,
    Signature,
    String,
}

Variants

Address

The Aleo address type.

Boolean

The boolean type.

Field

The field type (base field).

Group

The group type (affine).

I8

The 8-bit signed integer type.

I16

The 16-bit signed integer type.

I32

The 32-bit signed integer type.

I64

The 64-bit signed integer type.

I128

The 128-bit signed integer type.

U8

The 8-bit unsigned integer type.

U16

The 16-bit unsigned integer type.

U32

The 32-bit unsigned integer type.

U64

The 64-bit unsigned integer type.

U128

The 128-bit unsigned integer type.

Scalar

The scalar type (scalar field).

Signature

The signature type.

String

The string type.

Implementations

impl LiteralType

pub fn size_in_bits<N: Network>(&self) -> u16

Returns the number of bits of this literal type.

For string literals, this method returns the maximum number of bits that can be stored in the string.

impl LiteralType

pub fn size_in_bytes<N: Network>(&self) -> u16

Returns the number of bytes of this literal.

For string literals, this method returns the maximum number of bytes that can be stored in the string.

impl LiteralType

pub const fn type_name(&self) -> &str

Returns the literal type name.

pub fn type_id(&self) -> u8

Returns the unique numeric identifier for the literal type.

Trait Implementations

impl Clone for LiteralType

fn clone(&self) -> LiteralType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LiteralType

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

Prints the literal type as a string.

impl<'de> Deserialize<'de> for LiteralType

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserializes the literal type from a string or bytes.

impl Display for LiteralType

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

Prints the literal type as a string.

impl<N: Network> From<LiteralType> for PlaintextType<N>

fn from(literal: LiteralType) -> Self

Initializes a plaintext type from a literal type.

impl FromBytes for LiteralType

fn read_le<R: Read>(reader: R) -> IoResult<Self>

Reads Self from reader as little-endian bytes.

fn from_bytes_le(bytes: &[u8]) -> Result<Self, Error>

where Self: Sized,

Returns Self from a byte array in little-endian order.

fn from_bytes_le_unchecked(bytes: &[u8]) -> Result<Self, Error>

where Self: Sized,

Same behavior as Self::from_bytes_le but avoids costly checks. This shall only be called when deserializing from a trusted source, such as local storage.

fn read_le_unchecked<R>(reader: R) -> Result<Self, Error>

where R: Read, Self: Sized,

Same behavior as Self::read_le but avoids costly checks. This shall only be called when deserializing from a trusted source, such as local storage.

fn read_le_with_unchecked<R>(reader: R, unchecked: bool) -> Result<Self, Error>

where R: Read, Self: Sized,

Helper function that deserializes either unchecked or checked based on the given boolean flag.

impl FromPrimitive for LiteralType

fn from_i64(n: i64) -> Option<Self>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u64(n: u64) -> Option<Self>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_isize(n: isize) -> Option<Self>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i8(n: i8) -> Option<Self>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i16(n: i16) -> Option<Self>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i32(n: i32) -> Option<Self>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i128(n: i128) -> Option<Self>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_usize(n: usize) -> Option<Self>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u8(n: u8) -> Option<Self>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u16(n: u16) -> Option<Self>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u32(n: u32) -> Option<Self>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u128(n: u128) -> Option<Self>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f32(n: f32) -> Option<Self>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f64(n: f64) -> Option<Self>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl FromStr for LiteralType

fn from_str(string: &str) -> Result<Self>

Returns a literal type from a string literal.

type Err = Error

The associated error which can be returned from parsing.

impl Hash for LiteralType

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Parser for LiteralType

fn parse(string: &str) -> ParserResult<'_, Self>

Parses a string into a literal type.

impl PartialEq for LiteralType

fn eq(&self, other: &LiteralType) -> 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 Sequence for LiteralType

const CARDINALITY: usize = 17usize

Number of values of type Self.

fn next(&self) -> Option<Self>

Returns value following *self or None if this was the end.

fn previous(&self) -> Option<Self>

Returns value preceding *self or None if this was the beginning.

fn first() -> Option<Self>

Returns the first value of type Self.

fn last() -> Option<Self>

Returns the last value of type Self.

impl Serialize for LiteralType

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serializes the literal type into string or bytes.

impl ToBytes for LiteralType

fn write_le<W: Write>(&self, writer: W) -> IoResult<()>

Writes self into writer as little-endian bytes.

fn to_bytes_le(&self) -> Result<Vec<u8>, Error>

where Self: Sized,

Returns self as a byte array in little-endian order.

impl Copy for LiteralType

impl Eq for LiteralType

impl StructuralPartialEq for LiteralType