pb-mapper-core 0.5.0

Credentials, checksums, addressing, and shared primitives for pb-mapper
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

use std::fmt::{Debug, Display};
use std::hash::Hash;
use std::ops::AddAssign;

#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct RemoteConnId(u32);

#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct LocalConnId(u32);

impl LocalConnId {
    pub const fn from_u32(data: u32) -> Self {
        Self(data)
    }
}

pub trait ConnIdTrait:
    Copy + Clone + Debug + Display + Hash + PartialEq + Eq + PartialOrd + Ord + Default + Into<u32>
{
}

pub trait ConnIdProvider<T: ConnIdTrait> {
    fn get_next_id(&mut self) -> T;
    fn is_valid_id(&self, id: &T) -> bool;
}

macro_rules! impl_tuple_from_primitive {
    ($primitive_ty:ident, $tuple_ty:ident) => {
        impl From<$primitive_ty> for $tuple_ty {
            fn from(value: $primitive_ty) -> Self {
                Self(value)
            }
        }
    };
}

macro_rules! impl_primitive_from_tupe {
    ($primitive_ty:ident, $tuple_ty:ident) => {
        impl From<$tuple_ty> for $primitive_ty {
            fn from(value: $tuple_ty) -> Self {
                value.0
            }
        }
    };
}

macro_rules! impl_tuple_add_assign_primitive {
    ($primitive_ty:ident, $tuple_ty:ident) => {
        impl AddAssign<$primitive_ty> for $tuple_ty {
            fn add_assign(&mut self, rhs: $primitive_ty) {
                self.0 += rhs
            }
        }
    };
}

impl_tuple_from_primitive!(u32, RemoteConnId);

impl_primitive_from_tupe!(u32, RemoteConnId);

impl_tuple_add_assign_primitive!(u32, RemoteConnId);

impl_tuple_from_primitive!(u32, LocalConnId);

impl_primitive_from_tupe!(u32, LocalConnId);

impl_tuple_add_assign_primitive!(u32, LocalConnId);

impl Display for RemoteConnId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "RemoteConnId({})", self.0)
    }
}

impl Display for LocalConnId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "LocalConnId({})", self.0)
    }
}

impl ConnIdTrait for RemoteConnId {}
impl ConnIdTrait for LocalConnId {}

#[derive(Debug, Clone, Copy, Hash)]
pub struct ConnId {
    pub local_id: LocalConnId,
    pub remote_id: RemoteConnId,
}

impl Display for ConnId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "`L-{}:R-{}`", self.local_id, self.remote_id)
    }
}