LPVec 0.1.0

A simple VEC lib written to demo Rust at Logpoint
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

use std::alloc::Layout;
use std::mem;
use std::slice;

pub struct LPVec {
    pub content: Box<[usize]>,
    pub len: usize,
    pub capacity: usize,
}

impl LPVec{
    pub fn new() -> LPVec {
        Self {
            content: Box::new([0]),
            len: 0,
            capacity: 1,
        }
    }

    pub fn push(&mut self, item: usize) {
        if self.len == self.capacity {
            // Allocate a new array on heap
            let new_cap = self.capacity * 2;
            let mut new_content = unsafe {
                let content =
                    Layout::from_size_align(1usize, mem::align_of::<usize>()).expect("bad layout");
                let alloced = std::alloc::alloc(content) as *mut usize;
                let b = Box::from_raw(slice::from_raw_parts_mut(alloced, new_cap));
                b
            };

            for d in 0..self.len {
                new_content[d] = self.content[d].clone();
            }

            self.content = new_content;
            self.capacity = new_cap;
        }

        self.content[self.len] = item;
        self.len += 1;
    }
}

#[cfg(test)]
mod tests {
    use crate::LPVec;

    #[test]
    fn test_vec() {
        let mut new_vec = LPVec::new();
        new_vec.push(1usize);
        new_vec.push(2usize);
        new_vec.push(3usize);
        new_vec.push(3usize);
        new_vec.push(3usize);
        new_vec.push(3usize);

        println!(
            "LP Vec contains {} elements with cap {}",
            new_vec.len, new_vec.capacity
        );

        for item in 0..new_vec.len {
            println!("Item is {}", new_vec.content[item]);
        }
    }
}