fffl 1.0.0

A contiguous First-fit Freelist
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

use std::hint::unreachable_unchecked;



#[derive(PartialEq, Debug, Clone)]

/// Container struct for items in Freelist
pub(super) enum Slot<T> {
    /// Contains a value `T`
    Value(T),
    /// Contains an index pointing to the next available slot
    Next(usize),
    /// An empty / terminal slot
    Empty
}

impl <T>Slot<T> {

    #[inline(always)]
    /// Converts [`Slot::Value(T)`](Slot::Value) into [`Some(T)`](Option::Some)
    /// 
    /// Calling on any other variant is UB.
    pub(super) unsafe fn to_some_unchecked(self) -> Option<T> {
        match self {
            Slot::Value(value) => Some(value),
            // Because this is only used internally, we can ensure we don't end up here.
            _ => unsafe { unreachable_unchecked() }
        }
    }

    #[inline(always)]
    /// Converts [`&Slot::Value(T)`](Slot::Value) into `&T`
    /// 
    /// Calling on any other variant is UB.
    pub(super) unsafe fn as_value_unchecked(&self) -> &T {
        match self {
            Slot::Value(value) => value,
            // Because this is only used internally, we can ensure we don't end up here.
            _ => unsafe { unreachable_unchecked() }
        }
    }

    #[inline(always)]
    /// Converts [`&mut Slot::Value(T)`](Slot::Value) into `&mut T`
    /// 
    /// Calling on any other variant is UB.
    pub(super) unsafe fn as_value_unchecked_mut(&mut self) -> &mut T {
        match self {
            Slot::Value(value) => value,
            // Because this is only used internally, we can ensure we don't end up here.
            _ => unsafe { unreachable_unchecked() }
        }
    }

}

impl <T> From<T> for Slot<T> {
    #[inline(always)]
    fn from(value: T) -> Self { Self::Value(value) }
}

impl <T> From<Slot<T>> for Option<T> {
    #[inline]
    fn from(value: Slot<T>) -> Self {
        match value {
            Slot::Value(value) => Some(value),
            _ => None
        }
    }
}

impl <'a, T> From<&'a Slot<T>> for Option<&'a T> {
    #[inline]
    fn from(value: &'a Slot<T>) -> Self {
        match value {
            Slot::Value(value) => Some(value),
            _ => None
        }
    }
}

impl <'a, T: 'a> From<&'a mut Slot<T>> for Option<&'a mut T> {
    #[inline]
    fn from(value: &'a mut Slot<T>) -> Self {
        match value {
            Slot::Value(value) => Some(value),
            _ => None
        }
    }
}




#[cfg(test)]
mod slot {

    use super::Slot;

    #[test]
    fn to_some_unchecked() {
        let slot = Slot::Value(5);
        assert_eq!(unsafe { slot.to_some_unchecked() }, Some(5));
    }

    #[test]
    fn as_value_unchecked() {
        let slot = Slot::Value(5);
        assert_eq!(unsafe { slot.as_value_unchecked() }, &5);
    }

    #[test]
    fn as_value_unchecked_mut() {
        let mut slot = Slot::Value(5);
        assert_eq!(unsafe { slot.as_value_unchecked_mut() }, &mut 5);
    }

    #[test]
    fn from_t() {
        let slot = Slot::from(5i32);
        assert_eq!(slot, Slot::Value(5));
    }

    #[test]
    fn from_slot() {
        let slot = Slot::Value(5);
        let none_slot = Slot::<i32>::Empty;
        assert_eq!(Option::from(slot), Some(5));
        assert_eq!(Option::<i32>::from(none_slot), None);
    }

}