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

//!
//! State layer for lightproc implementation
//!
//! Contains trait bounds and state wrapping code
//!
//! # Example
//! ```rust
//! use lightproc::proc_state::State;
//! use crate::lightproc::proc_state::AsAny;
//!
//! #[derive(Clone)]
//! pub struct SharedState {
//!     name: String,
//!     surname: String,
//!     id: u64,
//! }
//!
//!
//! let mut s = SharedState {
//!     name: "Riemann".to_string(),
//!     surname: "Sum".to_string(),
//!     id: 123
//! };
//!
//! s.as_any();
//! ```

use std::any::Any;

use std::fmt::{Error, Formatter};

use std::fmt;
use std::sync::{Arc, Mutex};

///
/// State trait to implement a state for Bastion
pub trait State: Send + Sync + AsAny + 'static {}

///
/// Blanket implementation for the state when rules apply
impl<T> State for T where T: Send + Sync + 'static {}

///
/// Default debug implementation for dynamically dispatched state
impl fmt::Debug for dyn State {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
        f.write_fmt(format_args!("State :: {:?}", self.type_id()))
    }
}

///
/// Generic protection type where state is stored as is.
/// This allows us to share the state between the threads (both by ref and by value).
/// All state implementors bound to use this.
pub type ProcState = Arc<Mutex<dyn State>>;

///
/// Generic dynamic programming construct which allows us to downcast to the typeless level.
/// And do costly conversion between types if possible.
pub trait AsAny {
    ///
    /// Downcast implemented type to Any.
    fn as_any(&mut self) -> &mut dyn Any;
}

///
/// Blanket implementation for Any conversion if type is implementing Any.
impl<T: Any> AsAny for T {
    fn as_any(&mut self) -> &mut dyn Any {
        self
    }
}

// ------------------------------------------------------
// State related types are below
// ------------------------------------------------------

///
/// Empty proc state which is an heap allocated empty struct.
pub type EmptyProcState = Box<EmptyState>;

///
/// Base construct for empty state struct.
#[derive(Debug)]
pub struct EmptyState;