Struct Composite 

pub struct Composite {
    pub type_path: String,
    pub inners: Vec<CompositeInner>,
    pub generic_args: Vec<(String, Token)>,
    pub type: CompositeType,
    pub is_event: bool,
    pub alias: Option<String>,
}

Fields

type_path: String

inners: Vec<CompositeInner>

generic_args: Vec<(String, Token)>

type: CompositeType

is_event: bool

alias: Option<String>

Implementations

impl Composite

pub fn parse(type_path: &str) -> CainomeResult<Self>

Parses a composite type from a type path. Since the composite can be named arbitrarily, by the user, the parsing of the composite is not checking if the type path is a core basic type, an array or something else.

In cainome the type path is first parsed as any other token, and Composite is the last token that is parsed (which accepts every path).

You may use Composite::is_builtin to check if the type path is a known Cairo builtin type.

Arguments

• type_path - The type path to parse.

Returns

Returns a Composite token if the type path is a composite. Returns an error otherwise.

pub fn type_path_no_generic(&self) -> String

pub fn is_generic(&self) -> bool

pub fn is_builtin(&self) -> bool

Returns true if the current composite is considered as Cairo builtin. This is useful to avoid expanding the structure if already managed by the backend (like Option and Result for instance). Spans and Arrays are handled by array.

pub fn type_name(&self) -> String

pub fn type_name_or_alias(&self) -> String

pub fn apply_alias(&mut self, type_path: &str, alias: &str)

Trait Implementations

impl Clone for Composite

fn clone(&self) -> Composite

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Composite

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

Formats the value using the given formatter.

impl PartialEq for Composite

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