vielle.dev
[WIP] A simple wake-on-lan service
1pub mod ip {
2 use serde::{Deserialize, Deserializer, Serializer, de::Error};
3 use std::{net::IpAddr, str::FromStr};
4
5 pub fn deserialize<'de, D>(de: D) -> Result<IpAddr, D::Error>
6 where
7 D: Deserializer<'de>,
8 {
9 IpAddr::from_str(&String::deserialize(de)?).map_err(Error::custom)
10 }
11
12 pub fn serialize<S>(ip: &IpAddr, se: S) -> Result<S::Ok, S::Error>
13 where
14 S: Serializer,
15 {
16 se.serialize_str(ip.to_string().as_str())
17 }
18
19 pub mod option {
20 use super::*;
21
22 pub fn deserialize<'de, D>(de: D) -> Result<Option<IpAddr>, D::Error>
23 where
24 D: Deserializer<'de>,
25 {
26 if let Some(str) = Option::<String>::deserialize(de)? {
27 Ok(Some(IpAddr::from_str(&str).map_err(Error::custom)?))
28 } else {
29 Ok(None)
30 }
31 }
32
33 pub fn serialize<S>(ip: &Option<IpAddr>, se: S) -> Result<S::Ok, S::Error>
34 where
35 S: Serializer,
36 {
37 if let Some(ref ip) = *ip {
38 se.serialize_str(ip.to_string().as_str())
39 } else {
40 se.serialize_none()
41 }
42 }
43 }
44}
45
46pub mod mac {
47 use crate::mac::MacAddress;
48 use serde::{Deserialize, Deserializer, Serializer, de::Error};
49 use std::str::FromStr;
50
51 pub fn deserialize<'de, D>(de: D) -> Result<MacAddress, D::Error>
52 where
53 D: Deserializer<'de>,
54 {
55 MacAddress::from_str(&String::deserialize(de)?).map_err(Error::custom)
56 }
57
58 pub fn serialize<S>(mac: &MacAddress, se: S) -> Result<S::Ok, S::Error>
59 where
60 S: Serializer,
61 {
62 se.serialize_str(&mac.to_string())
63 }
64}
65
66pub mod links {
67 use std::collections::HashMap;
68
69 use serde::{Deserialize, Deserializer, Serializer, ser::SerializeSeq};
70
71 #[derive(Deserialize)]
72 #[serde(untagged)]
73 enum Inner {
74 Vec(Vec<(String, String)>),
75 Hash(HashMap<String, String>),
76 }
77
78 pub fn deserialize<'de, D>(de: D) -> Result<Vec<(String, String)>, D::Error>
79 where
80 D: Deserializer<'de>,
81 {
82 Ok(match Inner::deserialize(de)? {
83 Inner::Vec(vec) => vec,
84 Inner::Hash(hash) => hash.into_iter().collect(),
85 })
86 }
87
88 pub fn serialize<S>(links: &Vec<(String, String)>, se: S) -> Result<S::Ok, S::Error>
89 where
90 S: Serializer,
91 {
92 let mut seq = se.serialize_seq(Some(links.len()))?;
93 for link in links {
94 seq.serialize_element(link)?;
95 }
96 seq.end()
97 }
98}