Enum calyx::ir::Guard

pub enum Guard {
    Or(Box<Guard>, Box<Guard>),
    And(Box<Guard>, Box<Guard>),
    Not(Box<Guard>),
    True,
    CompOp(PortComp, RRC<Port>, RRC<Port>),
    Port(RRC<Port>),
}

An assignment guard which has pointers to the various ports from which it reads.

Variants

Or(Box<Guard>, Box<Guard>)

Represents c1 || c2.

And(Box<Guard>, Box<Guard>)

Represents c1 && c2.

Not(Box<Guard>)

Represents !c1

True

The constant true

CompOp(PortComp, RRC<Port>, RRC<Port>)

Comparison operator.

Port(RRC<Port>)

Uses the value on a port as the condition. Same as p1 == true

Implementations

impl Guard

Helper functions for the guard.

pub fn for_each<F>(&mut self, f: &mut F) where
    F: FnMut(RRC<Port>) -> Option<Guard>, 

Mutates a guard by calling f on every leaf in the guard tree and replacing the leaf with the guard that f returns.

pub fn all_ports(&self) -> Vec<RRC<Port>>

Returns all the ports used by this guard.

pub fn is_true(&self) -> bool

Returns true if this is a Guard::True.

pub fn update<F>(&mut self, upd: F) where
    F: FnOnce(Guard) -> Guard, 

Update the guard in place. Replaces this guard with upd(self). Uses std::mem::take for the in-place update.

pub fn op_str(&self) -> String

Return the string corresponding to the guard operation.

pub fn port(p: RRC<Port>) -> Self

pub fn and(self, rhs: Guard) -> Self

pub fn or(self, rhs: Guard) -> Self

pub fn eq(self, other: Guard) -> Self

pub fn neq(self, other: Guard) -> Self

pub fn le(self, other: Guard) -> Self

pub fn lt(self, other: Guard) -> Self

pub fn ge(self, other: Guard) -> Self

pub fn gt(self, other: Guard) -> Self

Trait Implementations

impl BitAnd<Guard> for Guard

Construct a Guard::And:

let and_guard = g1 & g2;

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, other: Self) -> Self::Output

Performs the & operation.

impl BitAndAssign<Guard> for Guard

Update a Guard with Or.

g1 &= g2;

fn bitand_assign(&mut self, other: Self)

Performs the &= operation.

impl BitOr<Guard> for Guard

Construct a Guard::Or:

let or_guard = g1 | g2;

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, other: Self) -> Self::Output

Performs the | operation.

impl BitOrAssign<Guard> for Guard

Update a Guard with Or.

g1 |= g2;

fn bitor_assign(&mut self, other: Self)

Performs the |= operation.

impl Clone for Guard

fn clone(&self) -> Guard

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Guard

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

Formats the value using the given formatter.

impl Default for Guard

fn default() -> Self

Returns the “default value” for a type.

impl From<Expr<Guard>> for Guard

fn from(expr: Expr<Guard>) -> Self

Performs the conversion.

impl From<Guard> for Expr<Guard>

fn from(guard: Guard) -> Self

Performs the conversion.

impl From<Rc<RefCell<Port>>> for Guard

Construct guards from ports

fn from(port: RRC<Port>) -> Self

Performs the conversion.

impl Hash for Guard

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, 

Feeds a slice of this type into the given Hasher.

impl Not for Guard

Construct a Guard::Or:

let not_guard = !g1;

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl Ord for Guard

Define an ordering on the precedence of guards. Guards are considered equal when they have the same precedence.

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<Guard> for Guard

fn eq(&self, other: &Self) -> 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 !=.

impl PartialOrd<Guard> for Guard

Define order on guards

fn partial_cmp(&self, other: &Self) -> 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 Eq for Guard