1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

#![deny(missing_docs)]
/*!
See [README.md](https://crates.io/crates/sylasteven-system-pns)
**/

use sylasteven as engine;

pub use pns;

use pns::{Net, SimulatedNet};

/// The net simulation system.
pub struct Simulation {
    /// The inner net which does the real simulation.
    pub net: SimulatedNet,
}

impl Simulation {
    /// Creates a new simulation system containing an empty net.
    pub fn new() -> Simulation {
        Simulation {
            net: SimulatedNet::new(Net::new()),
        }
    }

    /// Creates a new simulation system containing a net loaded from specified file.
    pub fn load(file: &str) -> Simulation {
        Simulation {
            net: SimulatedNet::new(Net::load(file).expect("Loading net failed")),
        }
    }

    /// Creates a new simulation system containing the supplied net as empty simulated net.
    pub fn from_net(net: Net) -> Simulation {
        Simulation {
            net: SimulatedNet::new(net),
        }
    }

    /// Creates a new simulation system containing the supplied simulated net.
    pub fn from_simulated_net(net: SimulatedNet) -> Simulation {
        Simulation { net }
    }
}

/// An event representing activated and deactivated transitions in the net.
pub struct SimulationEvent {
    /// The index of the simulation state; only important when multiple states exist.
    pub index: usize,
    /// The transition index, which was activated or deactivated.
    pub tid: u32,
    /// A falg if the transition was activated or deactivated.
    pub active: bool,
    /// A falg if the transition is active for playing forward or backwards.
    pub forward: bool,
}

use engine::{Handler, System};

impl<H: Handler> System<H> for Simulation
where
    H::Event: From<SimulationEvent>,
{
    fn process(&mut self, handler: &mut H) {
        for (index, state) in self.net.states_mut().iter_mut().enumerate() {
            let forward = true;
            for &tid in state.added_transitions(forward).iter() {
                handler.handle(
                    SimulationEvent {
                        index,
                        tid,
                        active: true,
                        forward,
                    }
                    .into(),
                )
            }
            for &tid in state.removed_transitions(forward).iter() {
                handler.handle(
                    SimulationEvent {
                        index,
                        tid,
                        active: false,
                        forward,
                    }
                    .into(),
                )
            }
            let forward = false;
            for &tid in state.added_transitions(forward).iter() {
                handler.handle(
                    SimulationEvent {
                        index,
                        tid,
                        active: true,
                        forward,
                    }
                    .into(),
                )
            }
            for &tid in state.removed_transitions(forward).iter() {
                handler.handle(
                    SimulationEvent {
                        index,
                        tid,
                        active: false,
                        forward,
                    }
                    .into(),
                )
            }
        }
    }
}