Struct Param 

pub struct Param {
    pub components: Vec<Param>,
    pub internal_type: Option<InternalType>,
    /* private fields */
}

JSON specification of a parameter.

Parameters are the inputs and outputs of Functions, and the fields of Errors.

Fields

components: Vec<Param>

If the parameter is a compound type (a struct or tuple), a list of the parameter’s components, in order. Empty otherwise

internal_type: Option<InternalType>

The internal type of the parameter. This type represents the type that the author of the Solidity contract specified. E.g. for a contract, this will be contract MyContract while the type field will be address.

Implementations

impl Param

pub fn parse(input: &str) -> Result<Self>

Parse a parameter from a Solidity parameter string.

Examples

assert_eq!(
    Param::parse("uint256[] foo"),
    Ok(Param {
        name: "foo".into(),
        ty: "uint256[]".into(),
        components: vec![],
        internal_type: None,
    })
);

pub fn new( name: &str, ty: &str, components: Vec<Self>, internal_type: Option<InternalType>, ) -> Result<Self>

Validate and create new instance of Param.

pub fn name(&self) -> &str

The name of the parameter. This function always returns either an empty slice, or a valid Solidity identifier.

pub const fn internal_type(&self) -> Option<&InternalType>

The internal type of the parameter.

pub fn is_udt(&self) -> bool

True if the parameter is a UDT (user-defined type).

A UDT will have

• an internal type that does not match its canonical type
• no space in its internal type (as it does not have a keyword body)

Any Other specifier will definitely be a UDT if it contains a contract.

pub const fn is_struct(&self) -> bool

True if the parameter is a struct.

pub const fn is_enum(&self) -> bool

True if the parameter is an enum.

pub const fn is_contract(&self) -> bool

True if the parameter is a contract.

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

The UDT specifier is a TypeSpecifier containing the UDT name and any array sizes. It is computed from the internal_type. If this param is not a UDT, this function will return None.

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

The struct specifier is a TypeSpecifier containing the struct name and any array sizes. It is computed from the internal_type If this param is not a struct, this function will return None.

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

The enum specifier is a TypeSpecifier containing the enum name and any array sizes. It is computed from the internal_type. If this param is not a enum, this function will return None.

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

The struct specifier is a TypeSpecifier containing the contract name and any array sizes. It is computed from the internal_type If this param is not a struct, this function will return None.

pub fn is_simple_type(&self) -> bool

True if the type is simple

pub fn is_complex_type(&self) -> bool

True if the type is complex (tuple or struct)

pub fn selector_type_raw(&self, s: &mut String)

Formats the canonical type of this parameter into the given string.

This is used to encode the preimage of a function or error selector.

pub fn full_selector_type_raw(&self, s: &mut String)

Formats the canonical type of this parameter into the given string including then names of the params.

pub fn selector_type(&self) -> Cow<'_, str>

Returns the canonical type of this parameter.

This is used to encode the preimage of a function or error selector.

Trait Implementations

impl Clone for Param

fn clone(&self) -> Param

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Param

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

Formats the value using the given formatter.

impl Default for Param

fn default() -> Param

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Param

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

Deserialize this value from the given Serde deserializer.

impl Display for Param

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

Formats the value using the given formatter.

impl FromStr for Param

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Param

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 Param

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

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

Serialize this value into the given Serde serializer.

impl Eq for Param

impl StructuralPartialEq for Param

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