hydra/
dest.rs

1use std::borrow::Cow;
2
3use serde::Deserialize;
4use serde::Serialize;
5
6use crate::Node;
7use crate::Pid;
8use crate::Reference;
9
10/// A process destination.
11#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
12pub enum Dest {
13    /// A process id.
14    Pid(Pid),
15    /// A registered process name.
16    Named(Cow<'static, str>, Node),
17    /// A reference to an alias.
18    Alias(Reference),
19}
20
21/// One or more process destinations.
22#[derive(Debug)]
23pub enum Dests {
24    /// A single process destination.
25    Dest(Dest),
26    /// Mutiple process destinations.
27    Dests(Vec<Dest>),
28}
29
30impl Dest {
31    /// Returns `true` if the [Dest] is for a local process.
32    pub const fn is_local(&self) -> bool {
33        match self {
34            Self::Pid(pid) => pid.is_local(),
35            Self::Named(_, node) => node.is_local(),
36            Self::Alias(reference) => reference.is_local(),
37        }
38    }
39
40    /// Returns `true` if the [Dest] is for a remote process.
41    pub const fn is_remote(&self) -> bool {
42        match self {
43            Self::Pid(pid) => pid.is_remote(),
44            Self::Named(_, node) => node.is_remote(),
45            Self::Alias(reference) => reference.is_remote(),
46        }
47    }
48}
49
50impl From<Pid> for Dest {
51    fn from(value: Pid) -> Self {
52        Self::Pid(value)
53    }
54}
55
56impl From<&'static str> for Dest {
57    fn from(value: &'static str) -> Self {
58        Self::Named(value.into(), Node::Local)
59    }
60}
61
62impl From<String> for Dest {
63    fn from(value: String) -> Self {
64        Self::Named(value.into(), Node::Local)
65    }
66}
67
68impl<T> From<(String, T)> for Dest
69where
70    T: Into<Node>,
71{
72    fn from(value: (String, T)) -> Self {
73        Self::Named(value.0.into(), value.1.into())
74    }
75}
76
77impl<T> From<(&'static str, T)> for Dest
78where
79    T: Into<Node>,
80{
81    fn from(value: (&'static str, T)) -> Self {
82        Self::Named(value.0.into(), value.1.into())
83    }
84}
85
86impl From<Reference> for Dest {
87    fn from(value: Reference) -> Self {
88        Self::Alias(value)
89    }
90}
91
92impl PartialEq<Pid> for Dest {
93    fn eq(&self, other: &Pid) -> bool {
94        match self {
95            Self::Pid(pid) => pid == other,
96            _ => false,
97        }
98    }
99}
100
101impl PartialEq<Dest> for Pid {
102    fn eq(&self, other: &Dest) -> bool {
103        match other {
104            Dest::Pid(pid) => self == pid,
105            _ => false,
106        }
107    }
108}
109
110impl PartialEq<&str> for Dest {
111    fn eq(&self, other: &&str) -> bool {
112        match self {
113            Self::Named(name, _) => name == other,
114            _ => false,
115        }
116    }
117}
118
119impl PartialEq<Dest> for &str {
120    fn eq(&self, other: &Dest) -> bool {
121        match other {
122            Dest::Named(name, _) => self == name,
123            _ => false,
124        }
125    }
126}
127
128impl PartialEq<Reference> for Dest {
129    fn eq(&self, other: &Reference) -> bool {
130        match self {
131            Self::Alias(reference) => reference == other,
132            _ => false,
133        }
134    }
135}
136
137impl PartialEq<Dest> for Reference {
138    fn eq(&self, other: &Dest) -> bool {
139        match other {
140            Dest::Alias(reference) => reference == other,
141            _ => false,
142        }
143    }
144}
145
146impl From<Pid> for Dests {
147    fn from(value: Pid) -> Self {
148        Self::Dest(Dest::from(value))
149    }
150}
151
152impl From<Reference> for Dests {
153    fn from(value: Reference) -> Self {
154        Self::Dest(Dest::from(value))
155    }
156}
157
158impl From<&'static str> for Dests {
159    fn from(value: &'static str) -> Self {
160        Self::Dest(Dest::Named(value.into(), Node::Local))
161    }
162}
163
164impl<T> From<(String, T)> for Dests
165where
166    T: Into<Node>,
167{
168    fn from(value: (String, T)) -> Self {
169        Self::Dest(Dest::Named(value.0.into(), value.1.into()))
170    }
171}
172
173impl<T> From<(&'static str, T)> for Dests
174where
175    T: Into<Node>,
176{
177    fn from(value: (&'static str, T)) -> Self {
178        Self::Dest(Dest::Named(value.0.into(), value.1.into()))
179    }
180}
181
182impl From<String> for Dests {
183    fn from(value: String) -> Self {
184        Self::Dest(Dest::Named(value.into(), Node::Local))
185    }
186}
187
188impl From<&[Pid]> for Dests {
189    fn from(value: &[Pid]) -> Self {
190        if value.len() == 1 {
191            Self::Dest(Dest::from(value[0]))
192        } else {
193            Self::Dests(value.iter().copied().map(Into::into).collect())
194        }
195    }
196}
197
198impl From<Dest> for Dests {
199    fn from(value: Dest) -> Self {
200        Self::Dest(value)
201    }
202}
203
204impl From<&[Dest]> for Dests {
205    fn from(value: &[Dest]) -> Self {
206        if value.len() == 1 {
207            Self::Dest(value[0].to_owned())
208        } else {
209            Self::Dests(Vec::from(value))
210        }
211    }
212}
213
214impl From<Vec<Dest>> for Dests {
215    fn from(value: Vec<Dest>) -> Self {
216        Self::Dests(value)
217    }
218}
219
220impl From<Vec<Pid>> for Dests {
221    fn from(value: Vec<Pid>) -> Self {
222        Self::Dests(value.into_iter().map(Into::into).collect())
223    }
224}
225
226impl From<&Vec<Pid>> for Dests {
227    fn from(value: &Vec<Pid>) -> Self {
228        Self::Dests(value.iter().copied().map(Into::into).collect())
229    }
230}
231
232impl FromIterator<Dest> for Dests {
233    fn from_iter<T: IntoIterator<Item = Dest>>(iter: T) -> Self {
234        Self::Dests(Vec::from_iter(iter))
235    }
236}
237
238impl FromIterator<Pid> for Dests {
239    fn from_iter<T: IntoIterator<Item = Pid>>(iter: T) -> Self {
240        Self::Dests(Vec::from_iter(iter.into_iter().map(Into::into)))
241    }
242}
hydra/dest.rs

hydra/
dest.rs
