huub 100.0.0

CP+SAT solver framework built to be reliable, performant, and extensible
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

//! Byte conversions used by the trailing infrastructure.

/// Lossless conversion to and from eight bytes for trailing storage.
///
/// Implementations should be cheap casts that avoid allocation or parsing, and
/// the byte order is an implementation detail rather than a serialization
/// format guarantee.
pub trait Bytes {
	/// Construct the value from its eight-byte representation.
	fn from_bytes(bytes: [u8; 8]) -> Self;
	/// Convert the value into its eight-byte representation.
	fn to_bytes(self) -> [u8; 8];
}

impl Bytes for bool {
	fn from_bytes(bytes: [u8; 8]) -> Self {
		u64::from_ne_bytes(bytes) != 0
	}

	fn to_bytes(self) -> [u8; 8] {
		(self as u64).to_ne_bytes()
	}
}

impl Bytes for f32 {
	fn from_bytes(bytes: [u8; 8]) -> Self {
		f64::from_ne_bytes(bytes) as f32
	}

	fn to_bytes(self) -> [u8; 8] {
		(self as f64).to_ne_bytes()
	}
}

impl Bytes for f64 {
	fn from_bytes(bytes: [u8; 8]) -> Self {
		f64::from_ne_bytes(bytes)
	}

	fn to_bytes(self) -> [u8; 8] {
		self.to_ne_bytes()
	}
}

impl Bytes for i16 {
	fn from_bytes(bytes: [u8; 8]) -> Self {
		i64::from_ne_bytes(bytes) as i16
	}

	fn to_bytes(self) -> [u8; 8] {
		(self as i64).to_ne_bytes()
	}
}

impl Bytes for i32 {
	fn from_bytes(bytes: [u8; 8]) -> Self {
		i64::from_ne_bytes(bytes) as i32
	}

	fn to_bytes(self) -> [u8; 8] {
		(self as i64).to_ne_bytes()
	}
}

impl Bytes for i64 {
	fn from_bytes(bytes: [u8; 8]) -> Self {
		i64::from_be_bytes(bytes)
	}

	fn to_bytes(self) -> [u8; 8] {
		self.to_be_bytes()
	}
}

impl Bytes for i8 {
	fn from_bytes(bytes: [u8; 8]) -> Self {
		i64::from_ne_bytes(bytes) as i8
	}

	fn to_bytes(self) -> [u8; 8] {
		(self as i64).to_ne_bytes()
	}
}

impl Bytes for isize {
	fn from_bytes(bytes: [u8; 8]) -> Self {
		i64::from_ne_bytes(bytes) as isize
	}

	fn to_bytes(self) -> [u8; 8] {
		(self as i64).to_ne_bytes()
	}
}

impl Bytes for u16 {
	fn from_bytes(bytes: [u8; 8]) -> Self {
		u64::from_ne_bytes(bytes) as u16
	}

	fn to_bytes(self) -> [u8; 8] {
		(self as u64).to_ne_bytes()
	}
}

impl Bytes for u32 {
	fn from_bytes(bytes: [u8; 8]) -> Self {
		u64::from_ne_bytes(bytes) as u32
	}

	fn to_bytes(self) -> [u8; 8] {
		(self as u64).to_ne_bytes()
	}
}

impl Bytes for u64 {
	fn from_bytes(bytes: [u8; 8]) -> Self {
		u64::from_ne_bytes(bytes)
	}

	fn to_bytes(self) -> [u8; 8] {
		self.to_ne_bytes()
	}
}

impl Bytes for u8 {
	fn from_bytes(bytes: [u8; 8]) -> Self {
		u64::from_ne_bytes(bytes) as u8
	}

	fn to_bytes(self) -> [u8; 8] {
		(self as u64).to_ne_bytes()
	}
}

impl Bytes for usize {
	fn from_bytes(bytes: [u8; 8]) -> Self {
		u64::from_ne_bytes(bytes) as usize
	}

	fn to_bytes(self) -> [u8; 8] {
		(self as u64).to_ne_bytes()
	}
}