Enum InternalType 

pub enum InternalType {
    AddressPayable(String),
    Contract(String),
    Enum {
        contract: Option<String>,
        ty: String,
    },
    Struct {
        contract: Option<String>,
        ty: String,
    },
    Other {
        contract: Option<String>,
        ty: String,
    },
}

The contract internal type. This could be a regular Solidity type, a user-defined type, an enum, a struct, a contract, or an address payable.

The internal type represents the Solidity definition of the type, stripped of the memory or storage keywords. It is used to convey the application dev and user-facing type, while the json param “type” field is used to convey the underlying ABI type.

Variants

AddressPayable(String)

Address payable.

Contract(String)

Contract.

Enum

Enum. Possibly of the form contract.enum.

Fields

contract: Option<String>

Contract qualifier, if any

ty: String

Enum name

Struct

Struct. Possibly of the form contract.struct.

Fields

contract: Option<String>

Contract qualifier, if any

ty: String

Struct name

Other

Other. Possible of the form contract.other.

Fields

contract: Option<String>

Contract qualifier, if any

ty: String

Struct name

Implementations

impl InternalType

pub fn parse(s: &str) -> Option<Self>

Parse a string into an instance, taking ownership of data

pub const fn is_struct(&self) -> bool

True if the instance is a struct variant.

pub const fn is_enum(&self) -> bool

True if the instance is a enum variant.

pub const fn is_contract(&self) -> bool

True if the instance is a contract variant.

pub const fn is_address_payable(&self) -> bool

True if the instance is a address payable variant.

pub const fn is_other(&self) -> bool

True if the instance is a other variant.

pub fn as_struct(&self) -> Option<(Option<&str>, &str)>

Fallible conversion to a variant.

pub fn as_enum(&self) -> Option<(Option<&str>, &str)>

Fallible conversion to a variant.

pub fn as_contract(&self) -> Option<&str>

Fallible conversion to a variant.

pub fn as_other(&self) -> Option<(Option<&str>, &str)>

Fallible conversion to a variant.

pub fn struct_specifier(&self) -> Option<TypeSpecifier<'_>>

Return a TypeSpecifier describing the struct if this type is a struct.

pub fn enum_specifier(&self) -> Option<TypeSpecifier<'_>>

Return a TypeSpecifier describing the enum if this type is an enum.

pub fn contract_specifier(&self) -> Option<TypeSpecifier<'_>>

Return a TypeSpecifier describing the contract if this type is a contract.

pub fn other_specifier(&self) -> Option<TypeSpecifier<'_>>

Return a TypeSpecifier describing the other if this type is an other. An “other” specifier indicates EITHER a regular Solidity type OR a user-defined type. It is not possible to distinguish between the two without additional context.

Trait Implementations

impl Clone for InternalType

fn clone(&self) -> InternalType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InternalType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for InternalType

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

Deserialize this value from the given Serde deserializer.

impl Display for InternalType

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

Formats the value using the given formatter.

impl Hash for InternalType

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 PartialEq for InternalType

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

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

Serialize this value into the given Serde serializer.

impl Eq for InternalType

impl StructuralPartialEq for InternalType

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: 28 bytes

Size for each variant:

• AddressPayable: 12 bytes
• Contract: 12 bytes
• Enum: 24 bytes
• Struct: 24 bytes
• Other: 24 bytes