dope-core 0.20.0

Owned native I/O and completion driver for dope
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

use std::marker;

use dope_sys::table::token::host;

use crate::{
    driver::{
        self,
        retained::flight::{GENERATION_BITS, INDEX_BITS, Mismatch, Target, storage},
        route::{self, kind},
    },
    io::event::batch::Flow,
};

#[must_use = "a validated flight completion must be committed"]
pub(crate) struct Complete<'q, 'd, C: kind::Class = kind::Any> {
    pub(super) completion: storage::Complete<'q, Target, INDEX_BITS, GENERATION_BITS>,
    pub(super) driver: driver::Reference<'d>,
    pub(super) class: marker::PhantomData<C>,
}

impl<'q, 'd> Complete<'q, 'd> {
    pub(crate) fn bind<C: kind::Flight>(self, proof: kind::Witness<C>) -> Complete<'q, 'd, C> {
        Complete {
            completion: self.completion,
            driver: self.driver,
            class: proof.marker(),
        }
    }

    pub(crate) fn kind(&self) -> kind::Native {
        self.completion.value().kind
    }
}

impl<'q, 'd, C: kind::Flight> TryFrom<Complete<'q, 'd>> for Complete<'q, 'd, C> {
    type Error = Mismatch<'q, 'd>;

    fn try_from(bound: Complete<'q, 'd>) -> Result<Self, Self::Error> {
        let observed = bound.kind();
        let Some(proof) = observed.witness() else {
            return Err(Mismatch {
                bound,
                expected: C::FLIGHT,
                observed,
            });
        };
        Ok(bound.bind(proof))
    }
}

impl<'d, C: kind::Class> From<&Complete<'_, 'd, C>> for route::Erased<'d, C> {
    fn from(bound: &Complete<'_, 'd, C>) -> Self {
        bound.completion.value().bind(bound.driver.brand)
    }
}

impl<'d, C: kind::Class> Complete<'_, 'd, C> {
    pub(crate) const fn driver(&self) -> driver::Reference<'d> {
        self.driver
    }

    pub(crate) fn complete(self) -> route::Erased<'d, C> {
        self.completion.complete().bind(self.driver.brand)
    }

    pub(crate) fn settle(self, flow: Flow) -> route::Erased<'d, C> {
        self.completion.settle(flow).bind(self.driver.brand)
    }
}

impl<C: kind::Class> host::Flight<Flow> for Complete<'_, '_, C> {
    type Key = super::raw::Echo;

    fn finish(self) {
        self.completion.finish();
    }

    fn end(self, flow: Flow) -> Self::Key {
        let echo = super::raw::Echo::from_inner(self.completion.echo());
        if flow == Flow::Last {
            self.completion.finish();
        }
        echo
    }
}