Enum CircuitEvent 

pub enum CircuitEvent {
    PushRegion {
        name: Cow<'static, str>,
        location: OperatorLocation,
    },
    PopRegion,
    Operator {
        node_id: GlobalNodeId,
        name: Cow<'static, str>,
        location: OperatorLocation,
    },
    StrictOperatorOutput {
        node_id: GlobalNodeId,
        name: Cow<'static, str>,
        location: OperatorLocation,
    },
    StrictOperatorInput {
        node_id: GlobalNodeId,
        output_node_id: NodeId,
    },
    Subcircuit {
        node_id: GlobalNodeId,
        iterative: bool,
    },
    SubcircuitComplete {
        node_id: GlobalNodeId,
    },
    Edge {
        kind: EdgeKind,
        from: GlobalNodeId,
        to: GlobalNodeId,
    },
}

Events related to circuit construction. A handler listening to these events should be able to reconstruct complete circuit topology, including operators, nested circuits, and streams connecting them.

Variants

PushRegion

Create a sub-region.

Fields

name: Cow<'static, str>

Sub-region name.

location: OperatorLocation

The region’s source location

PopRegion

Subregion complete.

Operator

A new regular (non-strict) operator is added to the circuit.

Fields

node_id: GlobalNodeId

Global id of the new operator.

name: Cow<'static, str>

Operator name.

location: OperatorLocation

The operator’s source location

StrictOperatorOutput

The output half of a strict operator. A strict operator is activated twice in each clock cycle: first, its output computed based on previous inputs is read; second, a new input for the current cycle is pushed to the operator. These activations are modeled as separate circuit nodes. The StrictOperatorOutput event is emitted first, when the output node is created.

Fields

node_id: GlobalNodeId

name: Cow<'static, str>

Operator name.

location: OperatorLocation

The operator’s source location

StrictOperatorInput

The input half of a strict operator is added to the circuit. This event is triggered when the circuit builder connects an input stream to the strict operator. The output node already exists at this point.

Fields

node_id: GlobalNodeId

Node id of the input half.

output_node_id: NodeId

Node id of the associated output node, that already exists in the circuit.

Subcircuit

A new nested circuit is added to the circuit.

Fields

node_id: GlobalNodeId

Global id of the nested circuit.

iterative: bool

true is the subcircuit has its own clock and can iterate multiple times for each parent clock tick.

SubcircuitComplete

Nested circuit has been fully populated.

Fields

node_id: GlobalNodeId

Global id of the nested circuit.

Edge

A new edge between nodes connected as producer and consumer to the same stream. Producer and consumer nodes can be located in different subcircuits.

Fields

kind: EdgeKind

from: GlobalNodeId

Global id of the producer operator that writes to the stream.

to: GlobalNodeId

Global id of an operator or subcircuit that reads values from the stream.

Implementations

impl CircuitEvent

pub fn push_region_static( name: &'static str, location: OperatorLocation, ) -> Self

Create a CircuitEvent::PushRegion event instance.

pub fn push_region(name: &str, location: OperatorLocation) -> Self

Create a CircuitEvent::PushRegion event instance.

pub fn pop_region() -> Self

Create a CircuitEvent::PopRegion event.

pub fn operator( node_id: GlobalNodeId, name: Cow<'static, str>, location: OperatorLocation, ) -> Self

Create a CircuitEvent::Operator event instance.

pub fn strict_operator_output( node_id: GlobalNodeId, name: Cow<'static, str>, location: OperatorLocation, ) -> Self

Create a CircuitEvent::StrictOperatorOutput event instance.

pub fn strict_operator_input( node_id: GlobalNodeId, output_node_id: NodeId, ) -> Self

Create a CircuitEvent::StrictOperatorInput event instance.

pub fn subcircuit(node_id: GlobalNodeId, iterative: bool) -> Self

Create a CircuitEvent::Subcircuit event instance.

pub fn subcircuit_complete(node_id: GlobalNodeId) -> Self

Create a CircuitEvent::SubcircuitComplete event instance.

pub fn stream( from: GlobalNodeId, to: GlobalNodeId, ownership_preference: OwnershipPreference, ) -> Self

Create a CircuitEvent::Edge event instance.

pub fn dependency(from: GlobalNodeId, to: GlobalNodeId) -> Self

Create a CircuitEvent::Edge event instance.

pub fn is_strict_input_event(&self) -> bool

true if self is a CircuitEvent::StrictOperatorInput

pub fn is_strict_output_event(&self) -> bool

true if self is a CircuitEvent::StrictOperatorOutput

pub fn is_operator_event(&self) -> bool

true if self is a CircuitEvent::Operator

pub fn is_subcircuit_event(&self) -> bool

true if self is a CircuitEvent::Subcircuit

pub fn is_iterative_subcircuit_event(&self) -> bool

true if self is a CircuitEvent::Subcircuit and self.iterative is true.

pub fn is_edge_event(&self) -> bool

true if self is a CircuitEvent::Edge

pub fn is_node_event(&self) -> bool

true if self is one of events related to nodes: CircuitEvent::Operator, CircuitEvent::StrictOperatorOutput, CircuitEvent::StrictOperatorInput, CircuitEvent::Subcircuit, or CircuitEvent::SubcircuitComplete.

pub fn is_new_node_event(&self) -> bool

true if self is one of the node creation events: CircuitEvent::Operator, CircuitEvent::StrictOperatorOutput, CircuitEvent::StrictOperatorInput, or CircuitEvent::Subcircuit.

pub fn node_id(&self) -> Option<&GlobalNodeId>

If self is one of the node creation events, returns self.node_id.

pub fn node_name(&self) -> Option<&Cow<'static, str>>

If self is a CircuitEvent::Operator or CircuitEvent::StrictOperatorOutput, returns self.name.

pub fn location(&self) -> OperatorLocation

pub fn output_node_id(&self) -> Option<NodeId>

If self is a CircuitEvent::StrictOperatorInput, returns self.output_node_id.

pub fn from(&self) -> Option<&GlobalNodeId>

If self is a CircuitEvent::Edge, returns self.from.

pub fn to(&self) -> Option<&GlobalNodeId>

If self is a CircuitEvent::Edge, returns self.to.

pub fn edge_kind(&self) -> Option<&EdgeKind>

If self is a CircuitEvent::Edge, returns self.kind.

Trait Implementations

impl Clone for CircuitEvent

fn clone(&self) -> CircuitEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CircuitEvent

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

Formats the value using the given formatter.

impl Display for CircuitEvent

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

Formats the value using the given formatter.

impl Hash for CircuitEvent

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 PartialEq for CircuitEvent

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

impl StructuralPartialEq for CircuitEvent