odem-rs-core 0.3.0

Core components of the odem-rs 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

//! A module for core-specific error types.

pub use crate::continuation::error::*;

/* ************************************************************** Error Types */

/// Enumeration of errors for the functions and structures contained in this
/// module of the simulation library.
#[derive(Copy, Clone, Debug, PartialEq, Eq, thiserror::Error)]
pub enum Error {
	/// The simulation stopped when the simulator detected a deadlock.
	#[error("deadlock detected")]
	Deadlock,
	/// Continuation is already bound.
	#[error(transparent)]
	NotBorn(#[from] NotBorn),
	/// Continuation is not idle.
	#[error(transparent)]
	NotIdle(#[from] NotIdle),
	/// Continuation is not active.
	#[error(transparent)]
	NotBusy(#[from] NotBusy),
	/// Continuation is not scheduled.
	#[error(transparent)]
	NotNext(#[from] NotNext),
	/// Continuation hasn't completed yet.
	#[error(transparent)]
	NotDone(#[from] NotDone),
	/// Continuation hasn't been released yet.
	#[error(transparent)]
	NotGone(#[from] NotGone),
	/// Continuation hasn't been bound yet.
	#[error(transparent)]
	NotInit(#[from] NotInit),
	/// Continuation hasn't terminated.
	#[error(transparent)]
	NotTerm(#[from] NotTerm),
	/// Signals an attempt to schedule a continuation at an earlier model-time.
	#[error("causality error")]
	Causality,
}

/* ******************************************************** Minor Error Types */

/// Signals the detection of a deadlock during a simulation run.
#[derive(Copy, Clone, Debug, PartialEq, Eq, thiserror::Error)]
pub struct Deadlock<T>(pub T);

impl<T> From<Deadlock<T>> for Error {
	fn from(_: Deadlock<T>) -> Self {
		Error::Deadlock
	}
}

impl<T: crate::config::Time> core::fmt::Display for Deadlock<T> {
	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
		write!(f, "deadlock detected at {}", self.0.display())
	}
}

/// Signals that an event at the current model time caused a change in that
/// event's past, violating causality.
#[derive(Copy, Clone, Debug, PartialEq, Eq, thiserror::Error)]
#[error(
	"continuation was scheduled at model-time {cause:?} (cause) for model-time \
         {effect:?} (effect), violating causality"
)]
pub struct CausalityError<T> {
	/// Source time of the caller.
	pub cause: T,
	/// Target model-time of the caller.
	pub effect: T,
}

impl<T> From<CausalityError<T>> for Error {
	fn from(_: CausalityError<T>) -> Self {
		Error::Causality
	}
}