Enum ResumeCondition 

#[non_exhaustive]
pub enum ResumeCondition {
    Single {
        waitpoint_key: String,
        matcher: SignalMatcher,
    },
    OperatorOnly,
    TimeoutOnly,
    Composite(CompositeBody),
}

Declarative resume condition for SuspendArgs::resume_condition.

RFC-013 §2.4 — typed replacement for the SDK’s former ConditionMatcher / resume_condition_json pair.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Single

Single waitpoint-key match with a predicate. matcher is evaluated against every signal delivered to waitpoint_key.

Fields

waitpoint_key: String

matcher: SignalMatcher

OperatorOnly

Operator-only resume — no signal satisfies; only an explicit operator resume closes the waitpoint.

TimeoutOnly

Pure-timeout suspension. No signal satisfier; the waitpoint resolves only via timeout_behavior at timeout_at. Requires SuspendArgs::timeout_at to be Some(_) — otherwise the Rust-side validator rejects as timeout_only_without_deadline.

Composite(CompositeBody)

Multi-condition composition; RFC-014 defines the body.

Implementations

impl ResumeCondition

pub fn all_of_waitpoints<I, S>(waitpoint_keys: I) -> ResumeCondition

where I: IntoIterator<Item = S>, S: Into<String>,

RFC-014 §10.3 builder — AllOf across N distinct waitpoints, each member a Single { matcher: Wildcard } leaf. Canonical Pattern 3 shape for heterogeneous-subsystem “all fired” semantics (e.g. db-migration-complete + cache-warmed + feature-flag-set).

Callers that need per-waitpoint matchers should construct the tree directly via [ResumeCondition::Composite(CompositeBody::all_of(..))].

pub fn referenced_waitpoint_keys(&self) -> Vec<String>

Collect every distinct waitpoint_key the condition targets. Used at suspend-time to validate the condition’s wp set against SuspendArgs.waitpoints (RFC-014 §5.1 multi-binding cross- check). Order follows tree DFS, de-duplicated preserving first occurrence.

pub fn validate_composite(&self) -> Result<(), CompositeValidationError>

Validate RFC-014 structural invariants on a composite condition. Single / OperatorOnly / TimeoutOnly return Ok — they carry no composite body. Checks cover:

• AllOf { members: [] } — §5.1 allof_empty_members
• Count { n: 0 } — §5.1 count_n_zero
• Count { waitpoints: [] } — §5.1 count_waitpoints_empty
• Count { n > waitpoints.len(), DistinctWaitpoints } — §5.1 count_exceeds_waitpoint_set
• depth > MAX_COMPOSITE_DEPTH — §5.1 condition_depth_exceeded

Trait Implementations

impl Clone for ResumeCondition

fn clone(&self) -> ResumeCondition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResumeCondition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ResumeCondition

fn deserialize<__D>( __deserializer: __D, ) -> Result<ResumeCondition, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ResumeCondition

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ResumeCondition

impl StructuralPartialEq for ResumeCondition