pipecircuit 0.0.23

Correct. Robust. Fast. Portable. Pick four.
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

//! The owned duplex table contract. Placement belongs to its transport.
use super::{Error, Guarantee, OperationId, PersistentRow, TableProtocol};
use core::marker::PhantomData;
/// An opaque operation identity, not a table revision or an authorization token.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Receipt(OperationId);
impl Receipt {
    /// Physical protocol construction; this is correlation, not authorization.
    #[doc(hidden)]
    pub const fn from_operation(operation: OperationId) -> Self {
        Self(operation)
    }
    #[doc(hidden)]
    pub const fn operation(self) -> OperationId {
        self.0
    }
}

#[derive(Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Answer<Value, Refusal> {
    Ready(Result<Value, Refusal>),
    Pending,
    Unavailable(Error),
}

#[derive(Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum MutationAnswer<Outcome, Refusal> {
    Pending {
        receipt: Receipt,
        outcome: Result<Outcome, Refusal>,
        established: Guarantee,
    },
    Confirmed {
        receipt: Receipt,
        outcome: Result<Outcome, Refusal>,
        established: Guarantee,
    },
    Unknown,
    Unavailable(Error),
}
#[derive(Debug, PartialEq, Eq)]
pub struct TableMutation<Command> {
    pub receipt: Receipt,
    pub command: Command,
    pub guarantee: Guarantee,
}
impl<Command> TableMutation<Command> {
    pub fn into_request<Query>(self) -> TableRequest<Query, Command> {
        TableRequest::Mutate {
            receipt: self.receipt,
            command: self.command,
            guarantee: self.guarantee,
        }
    }
}

#[derive(Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum TableRequest<Query, Mutation> {
    Read {
        query: Query,
        guarantee: Guarantee,
    },
    Mutate {
        receipt: Receipt,
        command: Mutation,
        guarantee: Guarantee,
    },
    Inquire {
        receipt: Receipt,
        guarantee: Guarantee,
    },
    Retire {
        receipt: Receipt,
    },
}
#[derive(Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum TableReply<Value, Outcome, Refusal> {
    Read(Answer<Value, Refusal>),
    Mutation(MutationAnswer<Outcome, Refusal>),
    Retired(Result<(), Error>),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum StorageFailure {
    Io { raw_os_error: Option<i32> },
    Codec,
    Core(Error),
    Locked,
    UnsupportedPlatform,
    Format,
    Checksum,
    TooLarge,
    Conflict,
    UnsafePath,
    Truncated,
    WorkerClosed,
    SchemaMismatch,
}

pub struct TablePipe<Row: PersistentRow, P: TableProtocol<Row>>(PhantomData<fn() -> (Row, P)>);
impl<Row: PersistentRow, P: TableProtocol<Row>> crate::Pipe for TablePipe<Row, P> {
    type In<'a> = TableRequest<P::Query, P::Mutation>;
    type Out<'a> = Result<TableReply<P::Value, P::Outcome, P::Refusal>, StorageFailure>;
}