algs4 0.7.0

Algorithms, 4ed. MOOC in Coursera. in Rust.
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

use std::iter;
use super::StackOfStrings;

const STACK_CAPACITY: usize = 1024;

pub struct FixedCapacityStackOfStrings {
    s: Vec<Option<String>>,
    n: usize
}

impl FixedCapacityStackOfStrings {
    pub fn with_capacity(capacity: usize) -> FixedCapacityStackOfStrings {
        let storage = iter::repeat(None).take(capacity).collect();

        FixedCapacityStackOfStrings {
            s: storage,
            n: 0
        }
    }
}

impl StackOfStrings for FixedCapacityStackOfStrings {
    fn new() -> FixedCapacityStackOfStrings {
        let storage = iter::repeat(None).take(STACK_CAPACITY).collect();

        FixedCapacityStackOfStrings {
            s: storage,
            n: 0
        }
    }

    fn is_empty(&self) -> bool {
        self.n == 0
    }

    fn push(&mut self, item: String) {
        self.s[self.n] = Some(item);
        self.n += 1;
    }

    fn pop(&mut self) -> String {
        self.n -= 1;
        let cell = self.s[self.n].take();
        cell.unwrap()
    }
}


#[test]
fn test_fixed_capacity_stack() {
    let mut stack: FixedCapacityStackOfStrings = StackOfStrings::new();

    let mut result = "to be not that or be".split(' ');

    for s in "to be or not to - be - - that - - - is".split(' ') {
        if s == "-" {
            assert_eq!(&stack.pop(), result.next().unwrap())
        } else {
            stack.push(s.into())
        }
    }
}