Enum TriggerCondition 

pub enum TriggerCondition<Event> {
    None,
    Never,
    EventCount {
        event: Event,
        required: usize,
    },
    Greater {
        reference_event: Event,
    },
    GreaterOrEqual {
        reference_event: Event,
    },
    Equal {
        reference_event: Event,
    },
    LessOrEqual {
        reference_event: Event,
    },
    Less {
        reference_event: Event,
    },
    Sequence {
        conditions: Vec<TriggerCondition<Event>>,
    },
    And {
        conditions: Vec<TriggerCondition<Event>>,
    },
    Or {
        conditions: Vec<TriggerCondition<Event>>,
    },
    AnyN {
        conditions: Vec<TriggerCondition<Event>>,
        n: usize,
    },
}

The (uncompiled) trigger conditions for events.

Each condition triggers at most once.

Variants

None

No trigger condition, this condition is always fulfilled.

Never

The unfulfillable trigger condition. This condition is never fulfilled.

EventCount

Trigger after a certain number of events have been received.

Fields

event: Event

The event to count.

required: usize

The amount of times this event needs to be received for the condition to trigger.

Greater

Trigger when an event is received that is greater than the reference event.

Fields

reference_event: Event

The reference event to compare against.

GreaterOrEqual

Trigger when an event is received that is greater than or equal to the reference event.

Fields

reference_event: Event

The reference event to compare against.

Equal

Trigger when an event is received that is equal to the reference event.

Fields

reference_event: Event

The reference event to compare against.

LessOrEqual

Trigger when an event is received that is less than or equal to the reference event.

Fields

reference_event: Event

The reference event to compare against.

Less

Trigger when an event is received that is less than the reference event.

Fields

reference_event: Event

The reference event to compare against.

Sequence

Trigger when the given conditions have been fulfilled in sequence.

This works by having a pointer to the current active condition in the sequence. Whenever a condition is fulfilled, the pointer gets moved to the right. If it has visited all conditions, then this condition triggers.

Fields

conditions: Vec<TriggerCondition<Event>>

The sequence of conditions.

And

Triggers after all given conditions have been fulfilled in any order.

This can be constructed via the BitAnd operator.

Compared to Self::Sequence, this does not require to fulfil the conditions in any order.

Example

use event_trigger_action_system::*;

assert_eq!(none() & never(), TriggerCondition::<()>::And {conditions: vec![none(), never()]});

Fields

conditions: Vec<TriggerCondition<Event>>

The conditions to fulfil.

Or

Triggers after one of the given conditions have been fulfilled.

This can be constructed via the BitOr operator.

Example

use event_trigger_action_system::*;

assert_eq!(none() | never(), TriggerCondition::<()>::Or {conditions: vec![none(), never()]});

Fields

conditions: Vec<TriggerCondition<Event>>

The conditions to fulfil.

AnyN

Triggers after a given number of the given conditions have been fulfilled.

Fields

conditions: Vec<TriggerCondition<Event>>

The conditions to fulfil.

n: usize

The amount of conditions that need to be fulfilled.

Implementations

impl<Event> TriggerCondition<Event>

pub fn compile<EventCompiler: Fn(Event) -> CompiledEvent, CompiledEvent: TriggerEvent>( self, event_compiler: &EventCompiler, ) -> CompiledTriggerCondition<CompiledEvent>

Compile this trigger condition.

Raw event information is transformed into a more compact identifier for a matching compiled event.

Trait Implementations

impl<Event> BitAnd for TriggerCondition<Event>

type Output = TriggerCondition<Event>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<Event: Clone> BitAndAssign for TriggerCondition<Event>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<Event> BitOr for TriggerCondition<Event>

type Output = TriggerCondition<Event>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<Event: Clone> BitOrAssign for TriggerCondition<Event>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<Event: Clone> Clone for TriggerCondition<Event>

fn clone(&self) -> TriggerCondition<Event>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Event: Debug> Debug for TriggerCondition<Event>

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

Formats the value using the given formatter.

impl<Event: PartialEq> PartialEq for TriggerCondition<Event>

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

impl<Event> StructuralPartialEq for TriggerCondition<Event>