harmos-domain 0.1.7

Harmos domain model: identifiers, contracts, catalogs and storage identities.
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

/* ***
 *
 * Harmos
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * ***
 */

/* === Modules === */

/* === Re-Exports === */

/* === Imports === */

// Standard Library Imports
use std::borrow::Cow;
use std::time::SystemTime;

// Third Party Imports

// Local Imports
use super::Value;
use crate::MessageError;
use crate::model::storage::time::Wire;
use crate::schema::{Cardinality, Field, Kind};

/* === Constants === */

/* === Macros === */

/* === Type Aliases === */

/* === Structs === */

pub struct Time;

/* === Enums === */

/* === Traits === */

/* === Implementations === */

impl Value for Time {
    const NAME: &'static str = concat!(module_path!(), "::", stringify!(Time));
    fn postcard_write(value: &SystemTime, bytes: &mut Vec<u8>) {
        use crate::__private::PostcardValue;
        let wire = Wire::from(*value);
        wire.secs_since_epoch.write(bytes);
        wire.nanos_since_epoch.write(bytes);
        wire.before_epoch.write(bytes);
    }

    fn postcard_size(value: &SystemTime) -> usize {
        use crate::__private::PostcardValue;
        let wire = Wire::from(*value);
        wire.secs_since_epoch.size() + wire.nanos_since_epoch.size() + 1
    }

    fn postcard_memory(input: &mut crate::__private::PostcardReader<'_>) -> Result<usize, MessageError> {
        Self::postcard_read(input)?;
        Ok(0)
    }

    fn postcard_read(input: &mut crate::__private::PostcardReader<'_>) -> Result<SystemTime, MessageError> {
        input.nested(|input| {
            Wire {
                secs_since_epoch: input.value()?,
                nanos_since_epoch: input.value()?,
                before_epoch: input.value()?,
            }
            .timestamp()
            .map_err(MessageError::borrowed)
        })
    }

    type Native = SystemTime;
    const KIND: Kind = Kind::Message {
        definition: <Self as crate::schema::Described>::DEFINITION,
    };
}

impl crate::schema::Described for Time {
    const NAME: &'static str = <Self as Value>::NAME;
    const FIELDS: &'static [Field] = FIELDS;
    const MARKER: &'static [u8] = &crate::schema::declaration::encode::<
        { crate::schema::declaration::encoded_len(<Self as crate::schema::Described>::NAME, Self::FIELDS) },
    >(<Self as crate::schema::Described>::NAME, Self::FIELDS);
}

const FIELDS: &[Field] = &[
    Field {
        name: Cow::Borrowed("secs_since_epoch"),
        tag: 1,
        kind: Kind::U64,
        cardinality: Cardinality::Required,
    },
    Field {
        name: Cow::Borrowed("nanos_since_epoch"),
        tag: 2,
        kind: Kind::U32,
        cardinality: Cardinality::Required,
    },
    Field {
        name: Cow::Borrowed("before_epoch"),
        tag: 3,
        kind: Kind::Bool,
        cardinality: Cardinality::Required,
    },
];

/* === Public Functions === */

/* === Private Functions === */

/* === Tests === */