Struct orzir_core::OpObj

pub struct OpObj(/* private fields */);

Implementations

impl OpObj

pub fn is_a<T: Op>(&self) -> bool

Check if the type object is a concrete type.

pub fn as_a<T: Op>(&self) -> Option<&T>

Try to downcast the type object to a concrete type.

pub fn impls<T: ?Sized + 'static>(&self, ctx: &Context) -> bool

Check if the type object implements a trait.

pub fn cast_ref<T: ?Sized + 'static>(&self, ctx: &Context) -> Option<&T>

Try to cast the type object to another trait.

pub fn cast_mut<T: ?Sized + 'static>(&mut self, ctx: &Context) -> Option<&mut T>

Trait Implementations

impl AsMut<dyn Op> for OpObj

fn as_mut(&mut self) -> &mut dyn Op

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

impl AsRef<dyn Op> for OpObj

fn as_ref(&self) -> &dyn Op

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

impl<T> From<T> for OpObj

where T: Op,

fn from(t: T) -> Self

Converts to this type from the input type.

impl Parse for OpObj

fn parse( ctx: &mut Context, state: &mut ParseState<'_> ) -> ParseResult<Self::Item>

The top-level parsing for an operation.

This function will parse the operation result, push the names to the state, then parse the mnemonic and the dialect-specific text.

e.g. for the oepration text below:

%0, %1 = dialect.agnostic_op %2, %3 : (int<32>, int<32>)

The result part %0, %1 will be saved as names, then the = will be consumed and the mnemonic will be parsed. According to the mnemonic, the parse function will be looked up from the context and called.

The dialect-specific parse function should only parse the rest of the text.

Syntax

<result_name_list> `=` <mnemonic> <dialect_specific_text>

Notes

The components of an operation needs to accept the corresponding ArenaPtr<OpObj>, and thus it is necessary to call ctx.ops.reserve() to get the ArenaPtr<OpObj> and then enter the parsing process. Of course, after the operation is constructed, the slot should be filled.

type Item = ArenaPtr<OpObj>

impl Print for OpObj

fn print(&self, ctx: &Context, state: &mut PrintState) -> PrintResult<()>

Print the operation.

This is actually symmetric to the parsing process.