rings-core 0.20.0

Chord DHT implementation with ICE
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

use crate::message::MessageClass;
use crate::message::MessageKind;

pub(super) const INBOUND_LANE_COUNT: usize = MessageClass::COUNT + 1;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum InboundLane {
    DhtControl,
    Storage,
    E2e,
    Application,
    Reassembly,
}

impl InboundLane {
    pub(super) const ALL: [Self; INBOUND_LANE_COUNT] = [
        Self::DhtControl,
        Self::Storage,
        Self::E2e,
        Self::Application,
        Self::Reassembly,
    ];

    pub(super) const fn from_class(class: MessageClass) -> Self {
        match class {
            MessageClass::DhtControl => Self::DhtControl,
            MessageClass::Storage => Self::Storage,
            MessageClass::E2e => Self::E2e,
            MessageClass::Application => Self::Application,
        }
    }

    pub(crate) const fn from_kind(kind: MessageKind) -> Self {
        if kind.is_chunk() {
            return Self::Reassembly;
        }
        Self::from_class(kind.class())
    }

    pub(super) const fn index(self) -> usize {
        match self {
            Self::DhtControl => 0,
            Self::Storage => 1,
            Self::E2e => 2,
            Self::Application => 3,
            Self::Reassembly => MessageClass::COUNT,
        }
    }

    pub(super) const fn is_logical_data(self) -> bool {
        matches!(self, Self::Storage | Self::E2e | Self::Application)
    }
}

const fn lanes_follow_indices(lanes: &[InboundLane], index: usize) -> bool {
    match lanes.split_first() {
        None => true,
        Some((lane, remaining)) => {
            lane.index() == index && lanes_follow_indices(remaining, index + 1)
        }
    }
}

const _: () = assert!(lanes_follow_indices(&InboundLane::ALL, 0));