cnsprcy 0.3.2

WIP
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

use data_encoding::BASE64URL_NOPAD;
use liter::Value;
use rand::Rng;
use serde::{Serialize, Deserialize};


#[derive(
	Copy,
	Clone,
	PartialEq,
	Eq,
	PartialOrd,
	Ord,
	Hash,
	Serialize,
	Deserialize,
	Value
)]
pub struct NodeID {
	id: [u8; 6]
}

impl NodeID {

	pub fn get(self) -> [u8; 6] { self.id }
	/// Generate a random NodeID according to RFC4122 Section 4.5
	pub fn random() -> Self {
		let mut id: [u8; 6] = rand::rng().random();
		// "The least significant bit of the first octet set to one"
		id[0] |= 0b1;
		Self {id}
	}
	pub fn inner(&self) -> &[u8; 6] {&self.id}
	pub fn from_u64(packed: u64) -> Self {
		let [_, _, a, b, c, d, e, f] = packed.to_le_bytes();
		Self { id: [a, b, c, d, e, f] }
	}
	pub fn to_u64(self) -> u64 {
		let Self { id: [a, b, c, d, e, f]} = self;
		u64::from_le_bytes([0, 0, a, b, c, d, e, f])
	}
}

/*
 *	NODE ID CONVERSION TRAITS
 */

impl std::ops::Deref for NodeID {
	type Target = [u8];
	fn deref(&self) -> &[u8] {&self.id}
}
impl std::convert::AsRef<[u8; 6]> for NodeID {
	fn as_ref(&self) -> &[u8; 6] {&self.id}
}
impl std::convert::AsMut<[u8; 6]> for NodeID {
	fn as_mut(&mut self) -> &mut [u8; 6] {&mut self.id}
}

impl std::convert::From<[u8; 6]> for NodeID {
	fn from(id: [u8; 6]) -> Self {Self{id}}
}
impl std::convert::From<NodeID> for [u8; 6] {
	fn from(node_id: NodeID) -> [u8; 6] {node_id.id}
}

impl std::str::FromStr for NodeID {
	type Err = String;

	fn from_str(s: &str) -> Result<Self, Self::Err> {
		match BASE64URL_NOPAD.decode(s.as_bytes()) {
			Ok(id_vec) if id_vec.len() == 6 => {
				Ok(Self {id: id_vec.try_into().unwrap()})
			},
			Ok(_) => Err("ID is not exactly 6 bytes long!".to_owned()),
			Err(e) => Err(
				format!("failed to decode URL-safe base64 ID: {e}")
			)
		}
	}
}
impl std::fmt::Display for NodeID {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		BASE64URL_NOPAD.encode(&self.id).fmt(f)
	}
}
impl std::fmt::Debug for NodeID {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		std::fmt::Display::fmt(self, f)
	}
}