maviola 0.3.0

High-level MAVLink communication library with support for essential micro-services.
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

use std::cmp::Ordering;
use std::fmt::{Debug, Formatter};
use std::sync::Mutex;
use std::time::{SystemTime, UNIX_EPOCH};

/// <sup>[`serde`](https://serde.rs) | [`specta`](https://crates.io/crates/specta)</sup>
/// Unique identifier.
///
/// Identifier which is guaranteed to be unique during the program run. It is intentionally kept
/// opaque. This identifier can't be serialized or deserialized and dedicated for comparison of
/// runtime entities like nodes or connections.
#[cfg_attr(feature = "specta", derive(specta::Type))]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Copy, Clone, Hash, PartialEq, Eq)]
pub struct UniqueId {
    timestamp: u64,
    counter: UniqueIdCounter,
}

static UNIQUE_ID: Mutex<UniqueId> = Mutex::new(UniqueId {
    timestamp: 0,
    counter: 0,
});

type UniqueIdCounter = u16;

impl Debug for UniqueId {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.debug_tuple("UniqueId")
            .field(&self.timestamp)
            .field(&self.counter)
            .finish()
    }
}

#[allow(clippy::non_canonical_partial_ord_impl)]
impl PartialOrd for UniqueId {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        let timestamp_cmp = self.timestamp.cmp(&other.timestamp);
        if timestamp_cmp != Ordering::Equal {
            return Some(timestamp_cmp);
        }

        Some(self.counter.cmp(&other.counter))
    }
}

impl Ord for UniqueId {
    fn cmp(&self, other: &Self) -> Ordering {
        self.partial_cmp(other).unwrap()
    }
}

impl UniqueId {
    /// Generates unique identifier.
    pub fn new() -> Self {
        let mut id = UNIQUE_ID.lock().unwrap();
        let (mut timestamp, counter) = (id.timestamp, id.counter);

        if counter == 0 {
            let new_timestamp = SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .unwrap()
                .as_secs();
            if new_timestamp > timestamp {
                timestamp = new_timestamp;
            } else {
                timestamp += 1;
            }
        }

        let next_counter = match counter {
            UniqueIdCounter::MAX => 0,
            current => current + 1,
        };

        id.timestamp = timestamp;
        id.counter = next_counter;

        Self { timestamp, counter }
    }
}

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

    #[test]
    fn test_unique_id() {
        let id_0 = UniqueId::new();
        let id_1 = UniqueId::new();

        assert_eq!(id_0, id_0);
        assert!(id_0 < id_1);
        assert_ne!(id_0, id_1);

        {
            let mut id = UNIQUE_ID.lock().unwrap();
            id.counter = UniqueIdCounter::MAX;
        }

        let id_0 = UniqueId::new();
        let id_1 = UniqueId::new();

        assert_eq!(id_0, id_0);
        assert!(id_0 < id_1);
        assert_ne!(id_0, id_1);
    }
}