ample 0.2.2

ample library
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

use crate::traits::Allocatable;
use crate::traits::Loading;
use core::fmt::Debug;
use core::marker::PhantomData;

pub struct Queue<Node, Load>
where
    Node: Loading<Load>,
    Load: Allocatable,
{
    pub former: *const Node,
    pub latter: *const Node,
    _phantom: PhantomData<Load>,
}

impl<Node, Load> Queue<Node, Load>
where
    Node: Loading<Load>,
    Load: Allocatable,
{
    pub fn new() -> Queue<Node, Load> {
        Queue {
            former: core::ptr::null_mut(),
            latter: core::ptr::null_mut(),
            _phantom: PhantomData,
        }
    }

    pub fn enqueue(&mut self, node: *const Node) {
        if self.former.is_null() {
            self.former = node;
            self.latter = node;
        } else {
            // This is a simplification - in a real implementation,
            // you'd need to set the successor/ancestor based on node type
            self.latter = node;
        }
    }

    pub fn is_empty(&self) -> bool {
        self.former.is_null()
    }

    pub fn new_5(loads: &[Load; 5]) -> Queue<Node, Load>
    where
        Load: Clone,
    {
        let mut queue = Queue::new();
        for l in 0..5 {
            // Create a new node with a clone of the load
            let _node = queue.enqueue(&Node::new(loads[l].clone()));
            // In a real implementation, you would:
            // 1. Properly allocate the node with Allocatable
            // 2. Add it to the queue with enqueue
        }
        queue
    }
}

impl<Node, Load> core::fmt::Debug for Queue<Node, Load>
where
    Node: Loading<Load> + Debug + Copy + Clone,
    Load: Allocatable,
{
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "Queue {{\n")?;
        write!(f, "\t Former {:?}\n", self.former)?;
        let mut p = self.former.clone();
        if !p.is_null() {
            unsafe {
                while p != self.latter.add(1) {
                    write!(f, "\t\t Entry {:?}\n", *p)?;
                    p = p.add(1);
                }
            }
        }
        write!(f, "\t Latter {:?}\n", self.latter)?;
        write!(f, "}} Queue\n")
    }
}