elevator-core 5.10.0

Engine-agnostic elevator simulation library with pluggable dispatch strategies
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

//! Position and velocity components along the shaft axis.

use serde::{Deserialize, Serialize};
use std::fmt;

/// Position along the shaft axis.
///
/// # Display
///
/// Formats as a compact distance string:
///
/// ```
/// # use elevator_core::components::Position;
/// let pos = Position::from(4.5);
/// assert_eq!(format!("{pos}"), "4.50m");
/// ```
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub struct Position {
    /// Absolute position value.
    pub(crate) value: f64,
}

impl Position {
    /// Absolute position value.
    #[must_use]
    pub const fn value(&self) -> f64 {
        self.value
    }
}

impl fmt::Display for Position {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{:.2}m", self.value)
    }
}

impl From<f64> for Position {
    fn from(value: f64) -> Self {
        debug_assert!(
            value.is_finite(),
            "Position value must be finite, got {value}"
        );
        Self { value }
    }
}

/// Velocity along the shaft axis (signed: +up, -down).
///
/// # Display
///
/// Formats as a compact speed string:
///
/// ```
/// # use elevator_core::components::Velocity;
/// let vel = Velocity::from(1.2);
/// assert_eq!(format!("{vel}"), "1.20m/s");
/// let stopped = Velocity::from(0.0);
/// assert_eq!(format!("{stopped}"), "0.00m/s");
/// ```
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub struct Velocity {
    /// Signed velocity value.
    pub(crate) value: f64,
}

impl Velocity {
    /// Signed velocity value.
    #[must_use]
    pub const fn value(&self) -> f64 {
        self.value
    }
}

impl fmt::Display for Velocity {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{:.2}m/s", self.value)
    }
}

impl From<f64> for Velocity {
    fn from(value: f64) -> Self {
        debug_assert!(
            value.is_finite(),
            "Velocity value must be finite, got {value}"
        );
        Self { value }
    }
}