Struct alloy_sol_type_parser::RootType

pub struct RootType<'a>(/* private fields */);

A root type, with no array suffixes. Corresponds to a single, non-sequence type. This is the most basic type specifier.

Note that this type might modify the input string, so span() must not be assumed to be the same as the input string.

Examples

let root_type = RootType::parse("uint256")?;
assert_eq!(root_type.span(), "uint256");

// Allows unknown types
assert_eq!(RootType::parse("MyStruct")?.span(), "MyStruct");

// No sequences
assert!(RootType::parse("uint256[2]").is_err());

// No tuples
assert!(RootType::parse("(uint256,uint256)").is_err());

// Input string might get modified
assert_eq!(RootType::parse("uint")?.span(), "uint256");

Implementations

impl<'a> RootType<'a>

pub const unsafe fn new_unchecked(s: &'a str) -> Self

Create a new root type from a string without checking if it’s valid.

Safety

The string passed in must be a valid Solidity identifier. See is_valid_identifier.

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

Parse a root type from a string.

pub fn parser(input: &mut &'a str) -> PResult<Self>

winnow parser for this type.

pub const fn span(self) -> &'a str

The string underlying this type. The type name.

pub fn try_basic_solidity(self) -> Result<()>

Returns Ok(()) if the type is a basic Solidity type.

Trait Implementations

impl AsRef<str> for RootType<'_>

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Clone for RootType<'a>

fn clone(&self) -> RootType<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for RootType<'a>

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

Formats the value using the given formatter.

impl Display for RootType<'_>

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

Formats the value using the given formatter.

impl<'a> Ord for RootType<'a>

fn cmp(&self, other: &RootType<'a>) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl<'a> PartialEq for RootType<'a>

fn eq(&self, other: &RootType<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialOrd for RootType<'a>

fn partial_cmp(&self, other: &RootType<'a>) -> Option<Ordering>

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a> TryFrom<&'a str> for RootType<'a>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &'a str) -> Result<Self>

Performs the conversion.

impl<'a> Copy for RootType<'a>

impl<'a> Eq for RootType<'a>

impl<'a> StructuralPartialEq for RootType<'a>