dope-session 0.2.3

Thin io_uring adaptor with "Manifolds"
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

use std::marker::PhantomData;

use crate::{CodecLayer, WriteBufStorage};
use dope_core::driver::{Completion, CompletionRouter, DriverLifecycle, PoolDriver};
use dope_core::profile::Profile;
use dope_runtime::runtime::Manifold;
use dope_transport::Transport;

pub mod client;
pub(crate) mod core;
pub mod server;
pub mod slot;

use self::core::PoolCore;

pub trait Direction<B: PoolDriver>: 'static {
    type Transport: Transport;
    type SlotUser: Default + 'static;
    type CodecLayer: CodecLayer;
    type WriteBuf: WriteBufStorage;

    fn has_pending(&self) -> bool;

    fn tick(
        &mut self,
        core: &mut PoolCore<Self::Transport, Self::CodecLayer, Self::WriteBuf, Self::SlotUser, B>,
        driver: &mut B::Driver,
    );

    #[inline(always)]
    fn on_accept_event(&mut self, _token: B::Token, _result: i32, _more: bool) {}
}

pub struct Pool<D: Direction<B>, F: Profile, B: PoolDriver> {
    pub(crate) direction: D,
    pub(crate) core: PoolCore<D::Transport, D::CodecLayer, D::WriteBuf, D::SlotUser, B>,
    pub(crate) profile: PhantomData<F>,
}

pub trait PoolTick<B: PoolDriver> {
    fn tick(&mut self, driver: &mut B::Driver);
}

pub(crate) trait PoolRecv<B: PoolDriver> {
    fn on_recv_event(
        &mut self,
        driver: &mut B::Driver,
        token: B::Token,
        result: i32,
        more: bool,
        bid: Option<u16>,
    );
}

pub(crate) trait PoolWrite<B: PoolDriver> {
    fn on_write_event(&mut self, driver: &mut B::Driver, token: B::Token, result: i32, notif: bool);
}

impl<D, F, B> Manifold for Pool<D, F, B>
where
    D: Direction<B>,
    F: Profile,
    B: PoolDriver,
    Self: PoolTick<B> + CompletionRouter<B>,
{
    type Backend = B;

    #[inline(always)]
    fn has_pending(&self, _driver: &mut B::Driver) -> bool {
        F::HYBRID_PARK && self.direction.has_pending()
    }

    #[inline(always)]
    fn drive(&mut self, driver: &mut B::Driver) {
        B::dispatch_completions(driver, self);
        <Self as PoolTick<B>>::tick(self, driver);
        let _ = driver.submit_only();
    }
}

impl<D, F, B> CompletionRouter<B> for Pool<D, F, B>
where
    D: Direction<B>,
    F: Profile,
    B: PoolDriver,
    Self: PoolRecv<B> + PoolWrite<B>,
{
    #[inline(always)]
    fn on_complete(&mut self, driver: &mut B::Driver, ev: Completion<B>) {
        match ev {
            Completion::Recv {
                token,
                result,
                more,
                bid,
            } => self.on_recv_event(driver, token, result, more, bid),
            Completion::Write {
                token,
                result,
                notif,
            } => self.on_write_event(driver, token, result, notif),
            Completion::Accept {
                token,
                result,
                more,
            } => self.direction.on_accept_event(token, result, more),
        }
    }
}