kompact 0.11.3

Kompact is a Rust implementation of the Kompics component model combined with the Actor model.
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
103
104
105
106
107
108
109
110
111

use std::fmt;

const ILLEGAL_VALUE_DESC: &str = "source value was illegal for the target type";
const OUT_OF_RANGE_DESC: &str = "source value was out of range for the target type";

#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct ConvertToIntError<N> {
    original: N,
    description: &'static str,
}

impl<N> ConvertToIntError<N> {
    fn illegal_value(original: N) -> Self {
        ConvertToIntError {
            original,
            description: ILLEGAL_VALUE_DESC,
        }
    }

    fn out_of_range(original: N) -> Self {
        ConvertToIntError {
            original,
            description: OUT_OF_RANGE_DESC,
        }
    }
}

impl<N: fmt::Display> fmt::Display for ConvertToIntError<N> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "Conversion of {} was unsuccessful; {}",
            self.original, self.description
        )
    }
}

/// Casting safely to integers
///
/// Prefer using [TryFrom](std::convert::TryFrom) where available.
pub trait CheckedIntegerCasts<Target> {
    /// Cast to the nearest target value
    ///
    /// Returns errors if there is no equivalent target value
    /// or the source value is out of range for the target.
    fn checked_cast(self) -> Result<Target, ConvertToIntError<Self>>
    where
        Self: Sized;

    /// If the cast involves rounding, round up.
    #[allow(unused)]
    fn ceil_checked_cast(self) -> Result<Target, ConvertToIntError<Self>>
    where
        Self: Sized;

    /// If the cast involves rounding, round down.
    #[allow(unused)]
    fn floor_checked_cast(self) -> Result<Target, ConvertToIntError<Self>>
    where
        Self: Sized;
}

impl CheckedIntegerCasts<usize> for f64 {
    fn checked_cast(self) -> Result<usize, ConvertToIntError<Self>> {
        if self.is_nan() || self.is_infinite() {
            return Err(ConvertToIntError::illegal_value(self));
        }
        if (self.is_sign_negative() && self != -0.0f64) || (self > usize::MAX as f64) {
            return Err(ConvertToIntError::out_of_range(self));
        }
        Ok(self as usize)
    }

    fn ceil_checked_cast(self) -> Result<usize, ConvertToIntError<Self>>
    where
        Self: Sized,
    {
        self.ceil().checked_cast()
    }

    fn floor_checked_cast(self) -> Result<usize, ConvertToIntError<Self>>
    where
        Self: Sized,
    {
        self.floor().checked_cast()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn check_f64_casts() {
        assert_eq!(1usize, 1.0f64.checked_cast().unwrap());
        assert_eq!(1usize, 0.5f64.ceil_checked_cast().unwrap());
        assert_eq!(0usize, 0.5f64.floor_checked_cast().unwrap());

        assert_eq!(0usize, 0.0f64.checked_cast().unwrap());
        assert_eq!(0usize, (-0.0f64).checked_cast().unwrap());

        assert_eq!(usize::MAX, (usize::MAX as f64).checked_cast().unwrap());

        assert!((f64::NAN).checked_cast().is_err());
        assert!((f64::INFINITY).checked_cast().is_err());
        assert!((f64::NEG_INFINITY).checked_cast().is_err());
        //assert!((usize::MAX as f64 + 1.0).checked_cast().is_err());
        assert!((f64::MAX).checked_cast().is_err());
        assert!((-1.0f64).checked_cast().is_err());
    }
}