mtid 0.6.1

Human-friendly id for personal distributed system (deprecated, use the caretta-id crate)
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

#[cfg(feature = "rusqlite")]
mod rusqlite;

#[cfg(feature = "sea-orm")]
mod sea_orm;

use core::{fmt::Display, str::FromStr};

#[cfg(feature = "prost")]
use crate::macros;
use crate::{error::Error, triplet::Triplet};

crate::macros::mtid_struct! {
    Self = Stid,
    ActualT = u16,
    description = "Single length Triplet ID.",
    example_str = "123",
    example_int = 1091,
}

crate::macros::mtid_impl! {
    Self = Stid,
    Uint = u16,
    BITS = 15,
    CAPACITY = Triplet::CAPACITY,
    NIL_STR = "000",
    MAX_STR = "zzz",
    MAX_INT = 32767,
    EXAMPLE_VALID_INT = 0b0010_0111_0001_0000,
    EXAMPLE_OVERSIZED_INT = 0b1010_0111_0001_0000
}

crate::macros::mtid_bytes_impl! {
    Self = Stid,
    Uint = u16,
    LEN = 2,
}

impl Display for Stid {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        let triplet = Triplet::from(*self);
        triplet.fmt(f)
    }
}

impl From<Stid> for Triplet {
    fn from(value: Stid) -> Self {
        Triplet::from_uint_lossy(value.0)
    }
}

impl From<Triplet> for Stid {
    fn from(value: Triplet) -> Self {
        Self::from_uint_lossy(u16::from(value))
    }
}

impl FromStr for Stid {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let len = s.len();
        if len != 3 {
            return Err(Error::ParseLength {
                expected_without_delimiter: 3,
                expected_with_delimiter: None,
                found: len,
            });
        }
        let mut chars = s.chars();
        Ok(Self(u16::from(Triplet::parse_chars(&mut chars).map_err(
            |e| Error::ParseTriplet {
                source: e,
                index: 0,
            },
        )?)))
    }
}

#[cfg(feature = "std")]
impl PartialEq<String> for Stid {
    fn eq(&self, other: &String) -> bool {
        match Self::from_str(other) {
            Ok(x) => *self == x,
            Err(_) => false,
        }
    }
}

#[cfg(feature = "prost")]
macros::mtid_prost_impl! {
    Self = Stid,
    ActualT = u16,
    ProtoT = proto::Stid,
    BITS = 15,
    VALID_VALUE = 0b0010_0111_0001_0000,
    OVERSIZED_VALUE = 0b1010_0111_0001_0000,
}