type-vec 0.1.0

A type-safe vector with type-level length
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

//! Defines the size type which value is static or dynamic

use crate::common::*;

// IntoSize

/// The helper trait that converts the input type to a size type.
pub trait IntoSize
where
    Self::Output: Size,
{
    type Output;
    fn into_size(self) -> Self::Output;
}

impl IntoSize for usize {
    type Output = Dyn;

    fn into_size(self) -> Self::Output {
        Dyn(self)
    }
}

impl IntoSize for Dyn {
    type Output = Self;

    fn into_size(self) -> Self::Output {
        self
    }
}

impl IntoSize for UTerm {
    type Output = Self;

    fn into_size(self) -> Self::Output {
        self
    }
}

impl<U, B> IntoSize for UInt<U, B>
where
    U: Unsigned,
    B: Bit,
{
    type Output = Self;

    fn into_size(self) -> Self::Output {
        self
    }
}

// Size

/// Marks the size type.
pub trait Size {
    fn to_usize(&self) -> usize;
}

impl Size for Dyn {
    fn to_usize(&self) -> usize {
        self.0
    }
}

impl Size for UTerm {
    fn to_usize(&self) -> usize {
        Self::USIZE
    }
}

impl<U, B> Size for UInt<U, B>
where
    U: Unsigned,
    B: Bit,
{
    fn to_usize(&self) -> usize {
        Self::USIZE
    }
}

// Dyn

/// The dynamic size type. It is used when the size is not known in compile time.
pub struct Dyn(usize);

// ops

typ! {
    pub fn IsDyn<size>(size: Size) -> Bit {
        match size {
            Dyn => true,
            UTerm => false,
            #[generics(uint: Unsigned, bit: Bit)]
            UInt::<uint, bit> => false,
        }
    }

    pub fn IncreaseOne<size>(size: Size) -> Size {
        match size {
            Dyn => Dyn,
            UTerm => U1,
            #[generics(uint: Unsigned, bit: Bit)]
            UInt::<uint, bit> => UInt::<uint, bit> + 1u,
        }
    }

    pub fn DecreaseOne<size>(size: Size) -> Size {
        match size {
            Dyn => Option::<Dyn>,
            #[generics(uint: Unsigned, bit: Bit)]
            UInt::<uint, bit> => UInt::<uint, bit> - 1u
        }
    }

    pub fn SizeAdd<lhs, rhs>(lhs: Size, rhs: Size) -> Size {
        if IsDyn(lhs) || IsDyn(rhs) {
            Dyn
        } else {
            lhs + rhs
        }
    }

    pub fn CheckIndex<length, index>(length: Size, index: Size) {
        if IsDyn(length) || IsDyn(index) {
            Option::<()>
        } else {
            match index >= 0u && index < length {
                B1 => (),
            }
        }
    }

    pub fn CheckIndexInclusive<length, index>(length: Size, index: Size) {
        if IsDyn(length) || IsDyn(index) {
            Option::<()>
        } else {
            match index >= 0u && index <= length {
                B1 => (),
            }
        }
    }
}