Oregami
Repositories/oxedyne/fe2o3

oxedyne/fe2o3/fe2o3_jdat/src/id.rs

7.6 KiB, 9 runs

created by r1870400018:467, which is this file's identity for as long as the history lasts, whatever it is later renamed to

download · who wrote it · its history

1//! An `IdDat` is the `Dat` flavoured version of the generic identifier `oxedyne_fe2o3_core::id::Id` that
2//! wraps an explicit, native unsigned integer. The unsigned integers and `IdDat` implement the
3//! `NumId` and `NumIdDat` trait collections.
4
5use crate::{
6 prelude::*,
7};
8
9use oxedyne_fe2o3_core::{
10 prelude::*,
11 byte::{
12 FromBytes,
13 FromByteArray,
14 ToBytes,
15 ToByteArray,
16 },
17 id::ParseId,
18 rand::RanDef,
19 string::ToHexString,
20};
21use oxedyne_fe2o3_text::base2x;
22
23use std::{
24 fmt::{
25 self,
26 Debug,
27 Display,
28 LowerHex,
29 },
30 ops::Deref,
31};
32
33
34pub trait NumId<const L: usize>:
35 Clone
36 + Copy
37 + Debug
38 + Default
39 + Display
40 + ParseId<L>
41 + Eq
42 + Ord
43 + PartialEq
44 + PartialOrd
45 + LowerHex
46 + FromBytes
47 + ToBytes
48 + FromByteArray
49 + ToByteArray<L>
50 + ToHexString
51 + RanDef
52 + Send
53 + Sync
54{}
55
56impl NumId<1> for u8 {}
57impl NumId<2> for u16 {}
58impl NumId<4> for u32 {}
59impl NumId<8> for u64 {}
60impl NumId<16> for u128 {}
61impl NumId<32> for B32 {}
62
63#[derive(Clone, Copy, Default, Eq, Ord, PartialEq, PartialOrd)]
64pub struct Id<
65 const IDL: usize,
66 N: NumId<IDL>,
67>(
68 pub N
69);
70
71impl NumId<1> for Id<1, u8> {}
72impl NumId<2> for Id<2, u16> {}
73impl NumId<4> for Id<4, u32> {}
74impl NumId<8> for Id<8, u64> {}
75impl NumId<16> for Id<16, u128> {}
76impl NumId<32> for Id<32, B32> {}
77
78impl<
79 const IDL: usize,
80 N: NumId<IDL>,
81>
82 Debug for Id<IDL, N>
83{
84 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
85 let byts = self.to_byte_array();
86 write!(f, "{}", base2x::HEMATITE64.to_string(&byts))
87 }
88}
89
90impl<
91 const IDL: usize,
92 N: NumId<IDL>,
93>
94 Display for Id<IDL, N>
95{
96 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
97 write!(f, "{:?}", self)
98 }
99}
100
101impl<
102 const IDL: usize,
103 N: NumId<IDL>,
104>
105 ParseId<IDL> for Id<IDL, N>
106{
107 fn parse_id(s: &str) -> Outcome<Self> {
108 let byts = res!(base2x::HEMATITE64.from_str(s));
109 let (result, _) = res!(Self::from_bytes(&byts));
110 Ok(result)
111 }
112}
113
114impl<
115 const IDL: usize,
116 N: NumId<IDL>,
117>
118 Deref for Id<IDL, N>
119{
120 type Target = N;
121 fn deref(&self) -> &Self::Target { &self.0 }
122}
123
124impl<
125 const IDL: usize,
126 N: NumId<IDL>,
127>
128 LowerHex for Id<IDL, N>
129{
130 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
131 LowerHex::fmt(&self.0, f)
132 }
133}
134
135impl<
136 const IDL: usize,
137 N: NumId<IDL>,
138>
139 FromBytes for Id<IDL, N>
140{
141 fn from_bytes(buf: &[u8]) -> Outcome<(Self, usize)> {
142 let (id, n) = res!(N::from_bytes(buf));
143 Ok((Self(id), n))
144 }
145}
146
147impl<
148 const IDL: usize,
149 N: NumId<IDL>,
150>
151 ToBytes for Id<IDL, N>
152{
153 fn to_bytes(&self, buf: Vec<u8>) -> Outcome<Vec<u8>> {
154 self.0.to_bytes(buf)
155 }
156}
157
158impl<
159 const IDL: usize,
160 N: NumId<IDL>,
161>
162 FromByteArray for Id<IDL, N>
163{
164 fn from_byte_array<const L: usize>(buf: [u8; L]) -> Outcome<Self> {
165 Ok(Self(res!(N::from_byte_array(buf))))
166 }
167}
168
169impl<
170 const IDL: usize,
171 N: NumId<IDL>,
172>
173 ToByteArray<IDL> for Id<IDL, N>
174{
175 fn to_byte_array(&self) -> [u8; IDL] {
176 self.0.to_byte_array()
177 }
178}
179
180impl<
181 const IDL: usize,
182 N: NumId<IDL>,
183>
184 ToHexString for Id<IDL, N>
185{
186 fn to_hex_string(&self) -> String {
187 self.0.to_hex_string()
188 }
189}
190
191impl<
192 const IDL: usize,
193 N: NumId<IDL>,
194>
195 RanDef for Id<IDL, N>
196{
197 fn randef() -> Self {
198 Self(N::randef())
199 }
200}
201
202impl<
203 const IDL: usize,
204 N: NumId<IDL>,
205>
206 Id<IDL, N>
207{
208 pub fn new(n: N) -> Self {
209 Self(n)
210 }
211}
212
213//#[cfg(test)]
214//mod tests {
215// use crate::{
216// prelude::*,
217// id::NumId,
218// };
219//
220// use oxedyne_fe2o3_core::{
221// prelude::*,
222// string::ToHexString,
223// };
224//
225//
226// struct Id<N: NumId<2>>(N);
227//
228// impl<N: NumId<2>> std::ops::Deref for Id<N> {
229// type Target = N;
230// fn deref(&self) -> &Self::Target { &self.0 }
231// }
232//
233// #[test]
234// fn test_uint_000() -> Outcome<()> {
235// let id = Id(255u16);
236// req!(id.to_hex_string().as_str(), "0x00ff");
237// Ok(())
238// }
239//
240//}
241pub trait NumIdDat<const L: usize>:
242 NumId<L>
243 + ToDat
244 + FromDat
245{}
246
247// Native unsigned integers.
248impl NumIdDat<1> for u8 {}
249impl NumIdDat<2> for u16 {}
250impl NumIdDat<4> for u32 {}
251impl NumIdDat<8> for u64 {}
252impl NumIdDat<16> for u128 {}
253impl NumIdDat<32> for B32 {}
254
255
256#[derive(Clone, Copy, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
257pub struct IdDat<
258 const IDL: usize,
259 N: NumIdDat<IDL>,
260>(
261 pub N
262);
263
264impl NumId<1> for IdDat<1, u8> {}
265impl NumId<2> for IdDat<2, u16> {}
266impl NumId<4> for IdDat<4, u32> {}
267impl NumId<8> for IdDat<8, u64> {}
268impl NumId<16> for IdDat<16, u128> {}
269impl NumId<32> for IdDat<32, B32> {}
270
271impl NumIdDat<1> for IdDat<1, u8> {}
272impl NumIdDat<2> for IdDat<2, u16> {}
273impl NumIdDat<4> for IdDat<4, u32> {}
274impl NumIdDat<8> for IdDat<8, u64> {}
275impl NumIdDat<16> for IdDat<16, u128> {}
276impl NumIdDat<32> for IdDat<32, B32> {}
277
278impl<
279 const IDL: usize,
280 N: NumIdDat<IDL>,
281>
282 Debug for IdDat<IDL, N>
283{
284 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
285 let byts = self.to_byte_array();
286 write!(f, "{}", base2x::HEMATITE64.to_string(&byts))
287 }
288}
289
290impl<
291 const IDL: usize,
292 N: NumIdDat<IDL>,
293>
294 Display for IdDat<IDL, N>
295{
296 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
297 write!(f, "{:?}", self)
298 }
299}
300
301impl<
302 const IDL: usize,
303 N: NumIdDat<IDL>,
304>
305 ParseId<IDL> for IdDat<IDL, N>
306{
307 fn parse_id(s: &str) -> Outcome<Self> {
308 let byts = res!(base2x::HEMATITE64.from_str(s));
309 let (result, _) = res!(Self::from_bytes(&byts));
310 Ok(result)
311 }
312}
313
314impl<
315 const IDL: usize,
316 N: NumIdDat<IDL>,
317>
318 Deref for IdDat<IDL, N>
319{
320 type Target = N;
321 fn deref(&self) -> &Self::Target { &self.0 }
322}
323
324impl<
325 const IDL: usize,
326 N: NumIdDat<IDL>,
327>
328 LowerHex for IdDat<IDL, N>
329{
330 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
331 LowerHex::fmt(&self.0, f)
332 }
333}
334
335impl<
336 const IDL: usize,
337 N: NumIdDat<IDL>,
338>
339 FromBytes for IdDat<IDL, N>
340{
341 fn from_bytes(buf: &[u8]) -> Outcome<(Self, usize)> {
342 let (id, n) = res!(N::from_bytes(buf));
343 Ok((Self(id), n))
344 }
345}
346
347impl<
348 const IDL: usize,
349 N: NumIdDat<IDL>,
350>
351 ToBytes for IdDat<IDL, N>
352{
353 fn to_bytes(&self, buf: Vec<u8>) -> Outcome<Vec<u8>> {
354 self.0.to_bytes(buf)
355 }
356}
357
358impl<
359 const IDL: usize,
360 N: NumIdDat<IDL>,
361>
362 FromByteArray for IdDat<IDL, N>
363{
364 fn from_byte_array<const L: usize>(buf: [u8; L]) -> Outcome<Self> {
365 Ok(Self(res!(N::from_byte_array(buf))))
366 }
367}
368
369impl<
370 const IDL: usize,
371 N: NumIdDat<IDL>,
372>
373 ToByteArray<IDL> for IdDat<IDL, N>
374{
375 fn to_byte_array(&self) -> [u8; IDL] {
376 self.0.to_byte_array()
377 }
378}
379
380impl<
381 const IDL: usize,
382 N: NumIdDat<IDL>,
383>
384 ToHexString for IdDat<IDL, N>
385{
386 fn to_hex_string(&self) -> String {
387 self.0.to_hex_string()
388 }
389}
390
391impl<
392 const IDL: usize,
393 N: NumIdDat<IDL>,
394>
395 RanDef for IdDat<IDL, N>
396{
397 fn randef() -> Self {
398 Self(N::randef())
399 }
400}
401
402// Now for NumIdDat traits...
403
404impl<
405 const IDL: usize,
406 N: NumIdDat<IDL>,
407>
408 ToDat for IdDat<IDL, N>
409{
410 fn to_dat(&self) -> Outcome<Dat> {
411 self.0.to_dat()
412 }
413}
414
415impl<
416 const IDL: usize,
417 N: NumIdDat<IDL>,
418>
419 FromDat for IdDat<IDL, N>
420{
421 fn from_dat(dat: Dat) -> Outcome<Self> {
422 Ok(Self(res!(N::from_dat(dat))))
423 }
424}
425
426impl<
427 const IDL: usize,
428 N: NumIdDat<IDL>,
429>
430 IdDat<IDL, N>
431{
432 pub fn new(n: N) -> Self {
433 Self(n)
434 }
435}