harmos-domain 0.1.5

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

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

/* === Modules === */

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

/* === Imports === */

// Standard Library Imports

// Third Party Imports

// Local Imports
use super::{RecordInput, StoredRecord, StoredRow, StreamInput};
use crate::model::storage::codec::{Bytes, Id, Nested, Optional, Time, Unsigned, Version, product};
use crate::model::storage::{SchemaKey, StorageCursor};

/* === Constants === */

/* === Macros === */

product!(SchemaKey { id: Id => 1, version: Version => 2, payload_encoding: Encoding => 3 });
product!(RecordInput {
    schema: Nested<SchemaKey> => 1,
    scope: Optional<Id> => 2,
    item: Id => 3,
    source: Optional<Id> => 4,
    source_time: Optional<Time> => 5,
    payload: Bytes => 6,
});
product!(StreamInput {
    record: Nested<RecordInput> => 1,
    stream: Id => 2,
    sequence: Unsigned => 3,
});
product!(StoredRecord<Vec<u8>> {
    position: Nested<StorageCursor> => 1,
    schema: Nested<SchemaKey> => 2,
    scope: Optional<Id> => 3,
    item: Id => 4,
    source: Optional<Id> => 5,
    source_time: Optional<Time> => 6,
    payload: Bytes => 7,
});
product!(StoredRow<Vec<u8>> {
    record: Nested<StoredRecord<Vec<u8>>> => 1,
    stream: Id => 2,
    sequence: Unsigned => 3,
});

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

/* === Structs === */

struct Encoding;

/* === Enums === */

/* === Traits === */

/* === Implementations === */

impl crate::model::storage::codec::Value for Encoding {
    const NAME: &'static str = concat!(module_path!(), "::", stringify!(Encoding));
    type Native = crate::model::storage::PayloadEncoding;
    const KIND: crate::schema::declaration::Kind = crate::schema::declaration::Kind::U64;
    fn postcard_write(value: &Self::Native, bytes: &mut Vec<u8>) {
        crate::__private::PostcardValue::write(&(*value as u64), bytes);
    }

    fn postcard_size(_: &Self::Native) -> usize {
        1
    }

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

    fn postcard_read(input: &mut crate::__private::PostcardReader<'_>) -> Result<Self::Native, crate::MessageError> {
        encoding(input.value()?)
    }
}

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

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

fn encoding(value: u64) -> Result<crate::model::storage::PayloadEncoding, crate::MessageError> {
    match value {
        0 => Ok(crate::model::storage::PayloadEncoding::ProtobufV1),
        1 => Ok(crate::model::storage::PayloadEncoding::PostcardV1),
        _ => Err(crate::MessageError::borrowed("unknown persisted payload encoding")),
    }
}

/* === Tests === */