Enum EventExpr 

pub enum EventExpr<'a> {
    Edge {
        span: Span,
        edge: EdgeIdent,
        value: Expr<'a>,
    },
    Iff {
        span: Span,
        expr: Box<EventExpr<'a>>,
        cond: Expr<'a>,
    },
    Or {
        span: Span,
        lhs: Box<EventExpr<'a>>,
        rhs: Box<EventExpr<'a>>,
    },
}

Variants

Edge

Fields

span: Span

edge: EdgeIdent

value: Expr<'a>

Iff

Fields

span: Span

expr: Box<EventExpr<'a>>

cond: Expr<'a>

Or

Fields

span: Span

lhs: Box<EventExpr<'a>>

rhs: Box<EventExpr<'a>>

Trait Implementations

impl<'a> AcceptVisitor<'a> for EventExpr<'a>

fn accept(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over the contents of self.

impl<'a> Clone for EventExpr<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for EventExpr<'a>

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

Formats the value using the given formatter.

impl<'a> ForEachChild<'a> for EventExpr<'a>

fn for_each_child(&'a self, each: &mut dyn FnMut(&'a dyn AnyNode<'a>))

Apply a function to each child node.

impl<'a> ForEachNode<'a> for EventExpr<'a>

fn for_each_node(&'a self, each: &mut dyn FnMut(&'a dyn AnyNode<'a>))

Apply a function to this node.

impl HasDesc for EventExpr<'_>

fn desc(&self) -> &'static str

Obtain a human-readable descriptive name for this node.

fn desc_full(&self) -> String

Obtain a human-readable description for this node, possibly containing the node’s name.

impl HasSpan for EventExpr<'_>

fn span(&self) -> Span

Obtain the full span of the input file that this node covers.

fn human_span(&self) -> Span

Obtain a span which can be used to refer to this node in error messages presented to humans. This will generally be the name for things like entities, processes, and variables. Defaults to return whatever span() returns.

impl<'a> PartialEq for EventExpr<'a>

fn eq(&self, other: &EventExpr<'a>) -> 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<'a> WalkVisitor<'a> for EventExpr<'a>

fn walk(&'a self, visitor: &mut dyn Visitor<'a>)

Walk a visitor over self.

Calling this function is equivalent to calling:

• visitor.pre_visit_event_expr(self)
• self.accept(visitor)
• visitor.post_visit_event_expr(self);

impl<'a> Eq for EventExpr<'a>

impl<'a> StructuralPartialEq for EventExpr<'a>