Enum SystemOrdering 

pub enum SystemOrdering {
    Before {
        system: SystemId,
        before: SystemId,
    },
    After {
        system: SystemId,
        after: SystemId,
    },
}

Specifies an ordering constraint between two systems.

Ordering constraints are used to ensure systems run in a specific order, regardless of the order they were added to the stage.

Example

use goud_engine::ecs::schedule::SystemOrdering;
use goud_engine::ecs::system::SystemId;

let ordering = SystemOrdering::Before {
    system: SystemId::from_raw(1),
    before: SystemId::from_raw(2),
};

Variants

Before

The system must run before before.

Fields

system: SystemId

The system that must run first.

before: SystemId

The system that must run after.

After

The system must run after after.

Fields

system: SystemId

The system that must run second.

after: SystemId

The system that must run first.

Implementations

impl SystemOrdering

pub fn before(system: SystemId, other: SystemId) -> Self

Creates a constraint where system runs before other.

pub fn after(system: SystemId, other: SystemId) -> Self

Creates a constraint where system runs after other.

pub fn first(&self) -> SystemId

Returns the system that must run first according to this constraint.

pub fn second(&self) -> SystemId

Returns the system that must run second according to this constraint.

pub fn as_edge(&self) -> (SystemId, SystemId)

Returns the edge (from, to) for the dependency graph.

The edge represents “from must run before to”.

pub fn involves(&self, id: SystemId) -> bool

Returns true if this ordering involves the given system.

Trait Implementations

impl Clone for SystemOrdering

fn clone(&self) -> SystemOrdering

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SystemOrdering

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

Formats the value using the given formatter.

impl Display for SystemOrdering

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

Formats the value using the given formatter.

impl Hash for SystemOrdering

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 SystemOrdering

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

impl Eq for SystemOrdering

impl StructuralPartialEq for SystemOrdering