dope-manifold 0.36.0

Owned application and service composition for dope
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use dope_core::driver::route::{indices, table};

use crate::client::side::registry;

pub(in crate::client) enum Start {
    Started,
    InProgress,
}

#[derive(Clone, Copy)]
pub(super) enum Step {
    Intake,
    Lane(indices::SlotIndex),
}

#[derive(Clone, Copy)]
pub(super) enum Primary {
    Done,
    Lane(indices::SlotIndex),
}

pub(in crate::client) enum State {
    Open,
    Draining(Cursor),
    Done,
}

pub(in crate::client) struct Cursor {
    lane: Option<indices::SlotIndex>,
    next: Next,
}

#[derive(Clone, Copy)]
enum Next {
    Intake,
    Lane,
}

#[must_use = "a shutdown plan must be completed only after work is admitted"]
pub(super) enum Plan<'a> {
    Intake(&'a mut Cursor),
    Lane(
        &'a mut Cursor,
        indices::SlotIndex,
        Option<indices::SlotIndex>,
    ),
}

impl Cursor {
    pub(super) fn intake(&mut self) {
        self.next = Next::Lane;
    }

    pub(super) fn advance(&mut self, next: Option<indices::SlotIndex>) {
        self.lane = next;
        self.next = Next::Intake;
    }
}

impl State {
    pub(in crate::client) const fn new() -> Self {
        Self::Open
    }

    pub(in crate::client) fn begin(&mut self) -> Start {
        if !matches!(self, Self::Open) {
            return Start::InProgress;
        }
        *self = Self::Draining(Cursor {
            lane: Some(indices::SlotIndex::ZERO),
            next: Next::Intake,
        });
        Start::Started
    }

    pub(in crate::client) const fn is_open(&self) -> bool {
        matches!(self, Self::Open)
    }

    pub(in crate::client) const fn is_draining(&self) -> bool {
        matches!(self, Self::Draining(_))
    }

    pub(super) fn plan(
        &mut self,
        queue: registry::Queue,
        capacity: table::Capacity,
    ) -> Option<Plan<'_>> {
        let step = match self {
            Self::Draining(cursor) => {
                match (cursor.lane.filter(|lane| capacity.contains(*lane)), queue) {
                    (None, registry::Queue::Empty) => {
                        *self = Self::Done;
                        return None;
                    }
                    (None, registry::Queue::Pending) => Step::Intake,
                    (Some(_), registry::Queue::Pending) if matches!(cursor.next, Next::Intake) => {
                        Step::Intake
                    }
                    (Some(lane), registry::Queue::Empty | registry::Queue::Pending) => {
                        Step::Lane(lane)
                    }
                }
            }
            Self::Open | Self::Done => return None,
        };
        match (self, step) {
            (Self::Draining(cursor), Step::Intake) => Some(Plan::Intake(cursor)),
            (Self::Draining(cursor), Step::Lane(lane)) => {
                Some(Plan::Lane(cursor, lane, capacity.next(lane)))
            }
            (Self::Open | Self::Done, _) => None,
        }
    }

    pub(super) fn next_lane(&mut self, capacity: table::Capacity) -> Option<Primary> {
        let Self::Draining(cursor) = self else {
            return None;
        };
        match cursor.lane.filter(|lane| capacity.contains(*lane)) {
            Some(lane) => {
                cursor.lane = capacity.next(lane);
                Some(Primary::Lane(lane))
            }
            None => {
                *self = Self::Done;
                Some(Primary::Done)
            }
        }
    }
}

const _: () = assert!(
    std::mem::size_of::<Option<indices::SlotIndex>>() == std::mem::size_of::<indices::SlotIndex>()
);
const _: () = assert!(std::mem::size_of::<State>() == 2 * std::mem::size_of::<u32>());