Enum Effect 

pub enum Effect {
    Receive {
        at_stage: Name,
    },
    Send {
        from: Name,
        to: Name,
        msg: Box<dyn SendData>,
    },
    Call {
        from: Name,
        to: Name,
        duration: Duration,
        msg: Box<dyn SendData>,
    },
    Clock {
        at_stage: Name,
    },
    Wait {
        at_stage: Name,
        duration: Duration,
    },
    Schedule {
        at_stage: Name,
        msg: Box<dyn SendData>,
        id: ScheduleId,
    },
    CancelSchedule {
        at_stage: Name,
        id: ScheduleId,
    },
    External {
        at_stage: Name,
        effect: Box<dyn ExternalEffect>,
    },
    Terminate {
        at_stage: Name,
    },
    AddStage {
        at_stage: Name,
        name: Name,
    },
    WireStage {
        at_stage: Name,
        name: Name,
        initial_state: Box<dyn SendData>,
        tombstone: Box<dyn SendData>,
    },
    Contramap {
        at_stage: Name,
        original: Name,
        new_name: Name,
    },
}

An effect emitted by a stage.

Variants

Receive

Fields

at_stage: Name

Send

Fields

from: Name

to: Name

msg: Box<dyn SendData>

Call

Fields

from: Name

to: Name

duration: Duration

msg: Box<dyn SendData>

Clock

Fields

at_stage: Name

Wait

Fields

at_stage: Name

duration: Duration

Schedule

Fields

at_stage: Name

msg: Box<dyn SendData>

id: ScheduleId

CancelSchedule

Fields

at_stage: Name

id: ScheduleId

External

Fields

at_stage: Name

effect: Box<dyn ExternalEffect>

Terminate

Fields

at_stage: Name

AddStage

Fields

at_stage: Name

name: Name

WireStage

Fields

at_stage: Name

name: Name

initial_state: Box<dyn SendData>

tombstone: Box<dyn SendData>

Contramap

Fields

at_stage: Name

original: Name

new_name: Name

Implementations

impl Effect

pub fn to_json(&self) -> Value

impl Effect

pub fn send( from: impl AsRef<str>, to: impl AsRef<str>, msg: Box<dyn SendData>, ) -> Self

Construct a send effect.

pub fn call( from: impl AsRef<str>, to: impl AsRef<str>, duration: Duration, msg: Box<dyn SendData>, ) -> Self

Construct a call effect.

pub fn clock(at_stage: impl AsRef<str>) -> Self

Construct a clock effect.

pub fn wait(at_stage: impl AsRef<str>, duration: Duration) -> Self

Construct a wait effect.

pub fn schedule( at_stage: impl AsRef<str>, msg: Box<dyn SendData>, schedule_id: &ScheduleId, ) -> Self

Construct a schedule effect.

pub fn cancel(at_stage: impl AsRef<str>, schedule_id: &ScheduleId) -> Self

pub fn external( at_stage: impl AsRef<str>, effect: Box<dyn ExternalEffect>, ) -> Self

Construct an external effect.

pub fn terminate(at_stage: impl AsRef<str>) -> Self

Construct a terminate effect.

pub fn add_stage(at_stage: impl AsRef<str>, name: impl AsRef<str>) -> Self

Construct an add stage effect.

pub fn wire_stage( at_stage: impl AsRef<str>, name: impl AsRef<str>, initial_state: Box<dyn SendData>, tombstone: Option<Box<dyn SendData>>, ) -> Self

Construct a wire stage effect.

pub fn contramap( at_stage: impl AsRef<str>, original: impl AsRef<str>, new_name: impl AsRef<str>, ) -> Self

pub fn at_stage(&self) -> &Name

Get the stage name of this effect.

pub fn assert_receive<Msg>(&self, at_stage: impl AsRef<StageRef<Msg>>)

Assert that this effect is a receive effect.

pub fn assert_send<Msg1, Msg2: SendData + PartialEq>( &self, at_stage: impl AsRef<StageRef<Msg1>>, target: impl AsRef<StageRef<Msg2>>, msg: Msg2, )

Assert that this effect is a send effect.

pub fn assert_clock<Msg>(&self, at_stage: impl AsRef<StageRef<Msg>>)

Assert that this effect is a clock effect.

pub fn assert_wait<Msg>( &self, at_stage: impl AsRef<StageRef<Msg>>, duration: Duration, )

Assert that this effect is a wait effect.

pub fn assert_call<Msg1, Msg2: SendData, Out>( self, at_stage: impl AsRef<StageRef<Msg1>>, target: impl AsRef<StageRef<Msg2>>, extract: impl FnOnce(Msg2) -> Out, duration: Duration, ) -> Out

Assert that this effect is a call effect.

pub fn assert_external<Eff: ExternalEffect + PartialEq>( &self, at_stage: impl AsRef<Name>, effect: &Eff, )

Assert that this effect is an external effect.

pub fn extract_external<Eff: ExternalEffectAPI + PartialEq>( self, at_stage: impl AsRef<Name>, ) -> Box<Eff>

Extract the external effect from this effect.

pub fn assert_add_stage<Msg>( &self, at_stage: impl AsRef<StageRef<Msg>>, name: impl AsRef<str>, )

Assert that this effect is an add stage effect.

pub fn assert_wire_stage<Msg, St: SendData + PartialEq>( &self, at_stage: impl AsRef<StageRef<Msg>>, name: impl AsRef<str>, initial_state: St, )

Assert that this effect is a wire stage effect.

pub fn extract_wire_stage<Msg, St: SendData + PartialEq>( &self, at_stage: impl AsRef<StageRef<Msg>>, initial_state: St, ) -> &Name

Trait Implementations

impl Debug for Effect

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Effect

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Effect

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

Formats the value using the given formatter.

impl PartialEq for Effect

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 Serialize for Effect

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.