doublets 0.3.0

Doublets (links) data structure implementation.
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

use std::{mem::transmute, ptr::NonNull};

use crate::mem::{
    header::LinksHeader, traits::UnitList, unit::raw_link::LinkPart, LinksList, UnitUpdateMem,
};
use data::LinkReference;
use trees::{AbsoluteCircularLinkedList, AbsoluteLinkedList, LinkedList};

pub struct UnusedLinks<T: LinkReference> {
    mem: NonNull<[LinkPart<T>]>,
}

impl<T: LinkReference> UnusedLinks<T> {
    #[must_use]
    pub fn new(mem: NonNull<[LinkPart<T>]>) -> Self {
        Self { mem }
    }

    fn get_header(&self) -> &LinksHeader<T> {
        unsafe { transmute(&self.mem.as_ref()[0]) }
    }

    fn get_mut_header(&mut self) -> &mut LinksHeader<T> {
        unsafe { transmute(&mut self.mem.as_mut()[0]) }
    }

    fn get_link(&self, link: T) -> &LinkPart<T> {
        unsafe { &self.mem.as_ref()[link.as_()] }
    }

    fn get_mut_link(&mut self, link: T) -> &mut LinkPart<T> {
        unsafe { &mut self.mem.as_mut()[link.as_()] }
    }
}

impl<T: LinkReference> AbsoluteLinkedList<T> for UnusedLinks<T> {
    fn get_first(&self) -> T {
        self.get_header().first_free
    }

    fn get_last(&self) -> T {
        self.get_header().last_free
    }

    fn get_size(&self) -> T {
        self.get_header().free
    }

    fn set_first(&mut self, element: T) {
        self.get_mut_header().first_free = element;
    }

    fn set_last(&mut self, element: T) {
        self.get_mut_header().last_free = element;
    }

    fn set_size(&mut self, size: T) {
        self.get_mut_header().free = size;
    }
}

impl<T: LinkReference> LinkedList<T> for UnusedLinks<T> {
    fn get_previous(&self, element: T) -> T {
        self.get_link(element).source
    }

    fn get_next(&self, element: T) -> T {
        self.get_link(element).target
    }

    fn set_previous(&mut self, element: T, previous: T) {
        self.get_mut_link(element).source = previous;
    }

    fn set_next(&mut self, element: T, next: T) {
        self.get_mut_link(element).target = next;
    }
}

impl<T: LinkReference> AbsoluteCircularLinkedList<T> for UnusedLinks<T> {}

impl<T: LinkReference> LinksList<T> for UnusedLinks<T> {
    fn detach(&mut self, link: T) {
        AbsoluteCircularLinkedList::detach(self, link);
    }

    fn attach_as_first(&mut self, link: T) {
        AbsoluteCircularLinkedList::attach_as_first(self, link);
    }
}

impl<T: LinkReference> UnitUpdateMem<T> for UnusedLinks<T> {
    fn update_mem(&mut self, mem: NonNull<[LinkPart<T>]>) {
        self.mem = mem;
    }
}

impl<T: LinkReference> UnitList<T> for UnusedLinks<T> {}