object-rainbow 0.0.0-a.67

distributed object model
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

use typenum::{U1, U254};

use crate::{decr_byte_niche::DecrByteNiche, *};

#[derive(
    Debug,
    Clone,
    Copy,
    PartialEq,
    Eq,
    PartialOrd,
    Ord,
    ListHashes,
    Topological,
    ParseAsInline,
    Default,
)]
pub struct Ff;

impl ToOutput for Ff {
    fn to_output(&self, output: &mut impl Output) {
        0xffu8.to_output(output);
    }
}

impl InlineOutput for Ff {}

impl<I: ParseInput> ParseInline<I> for Ff {
    fn parse_inline(input: &mut I) -> crate::Result<Self> {
        if input.parse_inline::<u8>()? == 0xff {
            Ok(Self)
        } else {
            Err(Error::OutOfBounds)
        }
    }
}

impl ByteOrd for Ff {
    fn bytes_cmp(&self, Self: &Self) -> Ordering {
        Ordering::Equal
    }
}

impl MaybeHasNiche for Ff {
    type MnArray = SomeNiche<DecrByteNiche<U254>>;
}

#[test]
fn ff_option() {
    assert_eq!(Some(Ff).vec(), [0xff]);
    assert_eq!(None::<Ff>.vec(), [0xfe]);
    assert_eq!(None::<Option<Ff>>.vec(), [0xfd]);
    assert_eq!(None::<Option<Option<Ff>>>.vec(), [0xfc]);
}

impl Size for Ff {
    type Size = U1;
}

impl Monostate for Ff {}

pub type FfCollection<T> = crate::none_terminated::Nt<
    crate::monostate_headers::MonostateHeaders<T, (Ff, crate::niche_cut::NicheCut)>,
>;

#[test]
fn ff_collection() {
    let mut stuff = FfCollection::<Vec<u8>>::default();
    stuff.push(1);
    stuff.push(2);
    assert_eq!(stuff.vec(), [0xff, 0x01, 0xff, 0x02, 0xfe]);
}