Enum Release 

pub enum Release {
    AwaitingEvent,
    Elapsing {
        event_at: DateTime<Utc>,
        opens_at: DateTime<Utc>,
    },
    UnrecordedEventTime,
    LagOutOfRange {
        event_at: DateTime<Utc>,
    },
    Released {
        at: EventTime,
    },
    SkippedBranch {
        at: EventTime,
    },
    NotSelected,
}

State of a constraint that waits for an event plus elapsed lag, at one clock reading.

Variants

AwaitingEvent

The required event has not occurred.

Elapsing

The event occurred and positive lag is still elapsing.

Fields

event_at: DateTime<Utc>

Recorded time of the required event.

opens_at: DateTime<Utc>

Earliest clock reading at which the constraint is satisfied.

UnrecordedEventTime

Positive lag must elapse from an event whose time was never recorded.

LagOutOfRange

The lag cannot be added to the event time within the supported calendar range.

Fields

event_at: DateTime<Utc>

Recorded time of the required event.

Released

The constraint is satisfied.

Fields

at: EventTime

When it became satisfied: the event time plus any positive lag.

SkippedBranch

The predecessor was excluded by a choice and the successor is an active-branch join, so the constraint is an absent branch rather than a satisfied prerequisite.

Fields

at: EventTime

When the excluding choice was made.

NotSelected

The predecessor was excluded by a choice; an ordinary constraint from it never releases.

Implementations

impl Release

pub fn evaluate( event: Option<EventTime>, lag_hours: f64, now: DateTime<Utc>, ) -> Self

Evaluate one constraint against an adapter-supplied clock reading.

Positive lag delays release by elapsed time. Negative lag (lead) only shapes the schedule projection: execution still waits for the event itself, so it is treated as zero here.

pub fn evaluate_with( event: Option<EventTime>, lag_hours: f64, now: DateTime<Utc>, lag_end: impl FnOnce(DateTime<Utc>, f64) -> Option<DateTime<Utc>>, ) -> Self

Evaluate one constraint whose positive lag ends at lag_end(event_at, hours), such as working hours of a calendar; None from it means the lag is out of range.

pub fn released_at(self) -> Option<EventTime>

Release time when satisfied.

Trait Implementations

impl Clone for Release

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Release

impl Debug for Release

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Release

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Release

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Release

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Release