Enum Guard

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

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

Variants

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

Represents c1 || c2.

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

Represents c1 && c2.

Not(Box<Guard<T>>)

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

Info(T)

Other types of information.

Implementations

impl<T> Guard<T>

pub fn is_true(&self) -> bool

Returns true definitely Guard::True. Returning false does not mean that the guard is not true.

pub fn is_false(&self) -> bool

Checks if the guard is always false. Returning false does not mean that the guard is not false.

pub fn is_not_done(&self, cell_name: &Id) -> bool

returns true if the self is !cell_name, false otherwise.

pub fn update<F>(&mut self, upd: F)

where F: FnOnce(Guard<T>) -> Guard<T>,

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<T>) -> Self

where T: Eq,

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

where T: Eq,

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

where T: Debug + Eq + ToString,

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

where T: Debug + Eq + ToString,

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

where T: Debug + Eq + ToString,

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

where T: Debug + Eq + ToString,

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

where T: Debug + Eq + ToString,

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

where T: Debug + Eq + ToString,

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

Returns all the ports used by this guard.

impl<T> Guard<T>

Helper functions for the guard.

pub fn for_each<F>(&mut self, f: &mut F)

where F: FnMut(RRC<Port>) -> Option<Guard<T>>,

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 for_each_info<F>(&mut self, f: &mut F)

where F: FnMut(&mut T) -> Option<Guard<T>>,

runs f(info) on each Guard::Info in guard. if f(info) = Some(result)replaces interval with result. iff(info) = None does nothing.

pub fn check_for_each_info<F>(&self, f: &mut F) -> Result<(), Error>

where F: Fn(&T) -> Result<(), Error>,

runs f(info) on each info in guard. f should return Result<(), Error>, meaning that it essentially does nothing if the f returns OK(()), but returns an appropraite error otherwise

impl Guard<StaticTiming>

pub fn add_interval(&mut self, timing_interval: StaticTiming)

updates self -> self & interval

pub fn compute_live_states(&self, group_latency: u64) -> HashSet<u64>

Take a static assignment guard and the latency of the group in which the assignment exists, and provide a list of states, relative to the group’s latency, in which the static assignment should be valid.

pub fn replace_static_timing( &mut self, builder: &mut Builder<'_>, counter: &RRC<Cell>, width: &u64, domain: &u64, )

Replace every interval [a1, a_n] in a static timing guard with counter.out == a_1 | counter.out == a_2 | ... | counter.out == a_{n-1}

pub fn remove_static_timing_info(&mut self)

Take a static assignment guard and get rid of all static timing portions of the guard. This is useful when we know the cycles c at which the assignment will be active, and we can separately construct the assignment guard like dst = c ? src instead of dst = beg <= c <= end ? src.

Trait Implementations

impl<T> BitAnd for Guard<T>

where T: Eq,

Construct a Guard::And:

let and_guard = g1 & g2;

type Output = Guard<T>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T> BitAndAssign for Guard<T>

where T: Eq,

Update a Guard with Or.

g1 &= g2;

fn bitand_assign(&mut self, other: Self)

Performs the &= operation.

impl<T> BitOr for Guard<T>

where T: Eq,

Construct a Guard::Or:

let or_guard = g1 | g2;

type Output = Guard<T>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T> BitOrAssign for Guard<T>

where T: Eq,

Update a Guard with Or.

g1 |= g2;

fn bitor_assign(&mut self, other: Self)

Performs the |= operation.

impl<T: Clone> Clone for Guard<T>

fn clone(&self) -> Guard<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Guard<T>

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

Formats the value using the given formatter.

impl<T> Default for Guard<T>

fn default() -> Guard<T>

Returns the “default value” for a type.

impl From<Guard<Nothing>> for Guard<StaticTiming>

fn from(g: Guard<Nothing>) -> Self

Turns a normal guard into a static guard

impl From<Guard<StaticTiming>> for Guard<Nothing>

fn from(guard: Guard<StaticTiming>) -> Guard<Nothing>

Converts to this type from the input type.

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

Construct guards from ports

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

Converts to this type from the input type.

impl<T> Hash for Guard<T>

where T: ToString,

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> Not for Guard<T>

Construct a Guard::Or:

let not_guard = !g1;

type Output = Guard<T>

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl<T> Ord for Guard<T>

where T: Eq,

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

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,

Restrict a value to a certain interval.

impl<T> PartialEq for Guard<T>

where T: Eq,

fn eq(&self, other: &Self) -> 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<T> PartialOrd for Guard<T>

where T: Eq,

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<T> Eq for Guard<T>

where T: Eq,