async-flow 0.1.5

Async abstractions for flow-based programming (FBP).
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
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

// This is free and unencumbered software released into the public domain.

/// A input or output port identifier.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
pub enum PortId {
    Input(InputPortId),
    Output(OutputPortId),
}

impl PortId {
    pub fn as_isize(&self) -> isize {
        match self {
            PortId::Input(id) => id.0,
            PortId::Output(id) => id.0,
        }
    }

    pub fn as_usize(&self) -> usize {
        self.as_isize() as _
    }
}

impl TryFrom<isize> for PortId {
    type Error = &'static str;

    fn try_from(id: isize) -> Result<Self, Self::Error> {
        if id < 0 {
            Ok(Self::Input(InputPortId(id)))
        } else if id > 0 {
            Ok(Self::Output(OutputPortId(id)))
        } else {
            Err("Port IDs cannot be zero")
        }
    }
}

impl From<InputPortId> for PortId {
    fn from(input: InputPortId) -> Self {
        PortId::Input(input)
    }
}

impl From<OutputPortId> for PortId {
    fn from(input: OutputPortId) -> Self {
        PortId::Output(input)
    }
}

impl Into<isize> for PortId {
    fn into(self) -> isize {
        self.as_isize()
    }
}

impl Into<usize> for PortId {
    fn into(self) -> usize {
        self.as_usize()
    }
}

impl core::fmt::Display for PortId {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        match self {
            PortId::Input(id) => write!(f, "{}", id),
            PortId::Output(id) => write!(f, "{}", id),
        }
    }
}

/// An input port identifier.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct InputPortId(pub(crate) isize);

impl InputPortId {
    #[doc(hidden)]
    pub fn index(&self) -> usize {
        self.0.unsigned_abs() - 1
    }
}

impl TryFrom<isize> for InputPortId {
    type Error = &'static str;

    fn try_from(id: isize) -> Result<Self, Self::Error> {
        if id < 0 {
            Ok(InputPortId(id))
        } else {
            Err("Input port IDs must be negative integers")
        }
    }
}

impl Into<isize> for InputPortId {
    fn into(self) -> isize {
        self.0
    }
}

impl Into<usize> for InputPortId {
    fn into(self) -> usize {
        self.0.unsigned_abs()
    }
}

impl core::fmt::Display for InputPortId {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        write!(f, "{}", self.0)
    }
}

/// An output port identifier.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct OutputPortId(pub(crate) isize);

impl OutputPortId {
    #[doc(hidden)]
    pub fn index(&self) -> usize {
        (self.0 as usize) - 1
    }
}

impl TryFrom<isize> for OutputPortId {
    type Error = &'static str;

    fn try_from(input: isize) -> Result<Self, Self::Error> {
        if input > 0 {
            Ok(OutputPortId(input))
        } else {
            Err("Output port IDs must be positive integers")
        }
    }
}

impl Into<isize> for OutputPortId {
    fn into(self) -> isize {
        self.0
    }
}

impl Into<usize> for OutputPortId {
    fn into(self) -> usize {
        self.0 as usize
    }
}

impl core::fmt::Display for OutputPortId {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        write!(f, "{}", self.0)
    }
}