tcgeneric 0.11.0

Generic data types used internally by TinyChain
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

//! Time utilities for TinyChain

use std::convert::{TryFrom, TryInto};
use std::ops;
use std::time;

use tc_error::*;

/// The current time of the TinyChain network, used to generate transaction IDs.
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
pub struct NetworkTime {
    nanos: u64,
}

/// A TinyChain timestamp, used for absolute ordering of transactions.
impl NetworkTime {
    // TODO: replace system time with an explicit network time synchronization system.
    /// The current time.
    pub fn now() -> NetworkTime {
        NetworkTime::from_nanos(
            time::SystemTime::now()
                .duration_since(time::UNIX_EPOCH)
                .unwrap()
                .as_nanos() as u64,
        )
    }

    /// This timestamp in nanoseconds since the Unix epoch.
    pub fn as_nanos(&self) -> u64 {
        self.nanos
    }

    /// Constructs a new timestamp from a duration in nanoseconds since the Unix epoch.
    pub fn from_nanos(nanos: u64) -> NetworkTime {
        NetworkTime { nanos }
    }
}

impl ops::Add<time::Duration> for NetworkTime {
    type Output = Self;

    fn add(self, other: time::Duration) -> Self {
        NetworkTime {
            nanos: self.nanos + other.as_nanos() as u64,
        }
    }
}

impl ops::Add<NetworkTime> for time::Duration {
    type Output = NetworkTime;

    fn add(self, other: NetworkTime) -> NetworkTime {
        NetworkTime {
            nanos: self.as_nanos() as u64 + other.nanos,
        }
    }
}

impl ops::Sub<NetworkTime> for NetworkTime {
    type Output = time::Duration;

    fn sub(self, other: NetworkTime) -> time::Duration {
        time::Duration::from_nanos(self.nanos - other.nanos)
    }
}

impl ops::Sub<time::Duration> for NetworkTime {
    type Output = Self;

    fn sub(self, other: time::Duration) -> Self {
        NetworkTime {
            nanos: self.nanos - other.as_nanos() as u64,
        }
    }
}

impl ops::Sub<NetworkTime> for time::Duration {
    type Output = NetworkTime;

    fn sub(self, other: NetworkTime) -> NetworkTime {
        NetworkTime {
            nanos: self.as_nanos() as u64 - other.nanos,
        }
    }
}

impl TryFrom<time::SystemTime> for NetworkTime {
    type Error = TCError;

    fn try_from(st: time::SystemTime) -> TCResult<NetworkTime> {
        let st = st
            .duration_since(time::UNIX_EPOCH)
            .map_err(|cause| bad_request!("invalid timestamp: {:?}", st).consume(cause))?;

        let nanos: u64 = st.as_nanos().try_into().map_err(|cause| {
            bad_request!("expected a 64-bit timestamp but found {:?}", st).consume(cause)
        })?;

        Ok(NetworkTime::from_nanos(nanos))
    }
}

impl From<NetworkTime> for time::SystemTime {
    fn from(nt: NetworkTime) -> Self {
        time::UNIX_EPOCH + time::Duration::from_nanos(nt.nanos)
    }
}