simcore 0.1.0

A generic discrete-event simulation framework
Documentation 
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

//! Simulation events.

use std::cmp::Ordering;

use downcast_rs::{impl_downcast, Downcast};
use dyn_clone::{clone_trait_object, DynClone};
use serde::ser::Serialize;

use crate::component::Id;

/// Event identifier.
pub type EventId = u64;

/// Trait that should be implemented by event payload.
pub trait EventData: Downcast + DynClone + erased_serde::Serialize {}

impl_downcast!(EventData);

clone_trait_object!(EventData);

erased_serde::serialize_trait_object!(EventData);

impl<T: Serialize + DynClone + 'static> EventData for T {}

/// Representation of event.
#[derive(Clone)]
pub struct Event {
    /// Unique event identifier.
    ///
    /// Events are numbered sequentially starting from 0.
    pub id: EventId,
    /// Time of event occurrence.
    pub time: f64,
    /// Identifier of event source.
    pub src: Id,
    /// Identifier of event destination.
    pub dst: Id,
    /// Event payload.
    pub data: Box<dyn EventData>,
}

impl Eq for Event {}

impl PartialEq for Event {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id
    }
}

impl Ord for Event {
    fn cmp(&self, other: &Self) -> Ordering {
        other.time.total_cmp(&self.time).then_with(|| other.id.cmp(&self.id))
    }
}

impl PartialOrd for Event {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

/// Typed version of [`crate::Event`].
pub struct TypedEvent<T>
where
    T: EventData,
{
    /// Unique event identifier.
    ///
    /// Events are numbered sequentially starting from 0.
    pub id: EventId,
    /// Time of event occurrence.
    pub time: f64,
    /// Identifier of event source.
    pub src: Id,
    /// Identifier of event destination.
    pub dst: Id,
    /// Event payload.
    pub data: T,
}

impl Event {
    /// Converts [`Event`] to [`TypedEvent`] of type `T`.
    ///
    /// Panics on downcast error.
    pub fn downcast<T>(e: Event) -> TypedEvent<T>
    where
        T: EventData,
    {
        match e.data.downcast::<T>() {
            Ok(data) => TypedEvent {
                id: e.id,
                time: e.time,
                src: e.src,
                dst: e.dst,
                data: *data,
            },
            Err(_) => {
                panic!("Event downcast error");
            }
        }
    }
}