aquaengine 0.0.2

AquaEngine is a RAD framework for graphics and computes
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! Version

use std::cmp::Ordering;

/// A version of an application, an API, ...
///
/// # Example
/// ```
/// use aquaengine::version::Version;
///
/// let version = Version::new(1, 0, 0);
/// let version2 = Version::new(1, 0, 0);
/// let version3 = Version::new(2, 1, 1);
///
/// assert_eq!(version, version2);
/// assert_ne!(version, version3);
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd)]
pub struct Version {
    major: u16,
    minor: u16,
    patch: u16
}

impl Version {
    /// Build a version.
    ///
    /// # Example
    /// ```
    ///     use aquaengine::version::Version;
    ///
    ///     let version = Version::new(1, 0, 0);
    /// ```
    pub fn new(major: u16, minor: u16, patch: u16) -> Self {
        Self { major, minor, patch }
    }

    /// Returns the major version
    ///
    /// # Example
    /// ```
    ///     use aquaengine::version::Version;
    ///
    ///     let version = Version::new(1, 0, 0);
    ///     assert_eq!(version.major(), 1);
    /// ```
    pub fn major(&self) -> u16 {
        self.major
    }

    /// Build a version.
    ///
    /// # Example
    /// ```
    ///     use aquaengine::version::Version;
    ///
    ///     let version = Version::new(0, 1, 0);
    ///     assert_eq!(version.minor(), 1);
    /// ```
    pub fn minor(&self) -> u16 {
        self.minor
    }

    /// Build a version.
    ///
    /// # Example
    /// ```
    ///     use aquaengine::version::Version;
    ///
    ///     let version = Version::new(0, 0, 1);
    ///     assert_eq!(version.patch(), 1);
    /// ```
    pub fn patch(&self) -> u16 {
        self.patch
    }
}

impl Ord for Version {
    fn cmp(&self, other: &Self) -> Ordering {
        let version_u64 = u64::from(self);
        let other_u64 = u64::from(other);

        version_u64.cmp(&other_u64)
    }
}

impl From<Version> for u64 {
    fn from(version: Version) -> Self {
        Self::from(&version)
    }
}

impl<'a> From<&'a Version> for u64 {
    fn from(version: &Version) -> Self {
        let major = Self::from(version.major) << 32;
        let minor = Self::from(version.minor) << 16;
        let patch = Self::from(version.patch);

        major + minor + patch
    }
}

impl From<Version> for u32 {
    fn from(version: Version) -> Self {
        Self::from(&version)
    }
}

impl<'a> From<&'a Version> for u32 {
    fn from(version: &Version) -> Self {
        let major = Self::from(version.major) << 16;
        let minor = Self::from(version.minor / 2) << 8;
        let patch = Self::from(version.patch / 2);

        major + minor + patch
    }
}

impl From<Version> for u16 {
    fn from(version: Version) -> Self {
        Self::from(&version)
    }
}

impl<'a> From<&'a Version> for u16 {
    fn from(version: &Version) -> Self {
        let major = version.major << 8;
        let minor = (version.minor / 3) << 4;
        let patch = version.patch / 3;

        major + minor + patch
    }
}