crndm 0.1.0

Persistent Programming Library
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

#![allow(dead_code)]
#![feature(trait_alias)]

// 1. Linked List
// 2. Binary Search Tree
// 3. HashMap /w Vec

mod pbst;
mod phash;
mod plist;

mod vbst;
mod vhash;
mod vlist;

use std::env;

pub trait Prog {
    fn perform<F: FnOnce(&Self)>(f: F);
    fn exec(&self, args: Vec<String>) -> bool;
    fn help();

    fn next(args: &Vec<String>, i: &mut usize) -> Option<String> {
        if *i < args.len() {
            *i += 1;
            Some(args[*i - 1].clone())
        } else {
            None
        }
    }

    fn repeat(&self, args: &Vec<String>, i: usize, mut n: usize) -> bool {
        let mut v = args[i..].to_vec().clone();
        v.insert(0, "nop".to_string());
        v.insert(0, "nop".to_string());
        while n > 1 {
            if !self.exec(v.clone()) {
                return false;
            }
            n -= 1;
        }
        true
    }

    fn run(&self, filename: &str) -> bool {
        let contents = std::fs::read_to_string(filename).unwrap();
        let mut args: Vec<String> = contents.split_whitespace().map(|x| x.to_string()).collect();
        args.insert(0, "nop".to_string());
        args.insert(0, "nop".to_string());
        self.exec(args)
    }
}

fn perform<T: Prog>(args: Vec<String>) {
    T::perform(|store| {
        store.exec(args);
    });
}

fn main() {
    let args: Vec<String> = env::args().collect();

    if args.len() < 2 {
        println!(
            "usage: {} [vlist|plist|vbst|pbst|vhash|phash] [OPERATION]",
            args[0]
        )
    } else {
        let tp = &args[1];
        if tp == "vlist" {
            perform::<vlist::List<i32>>(args)
        } else if tp == "plist" {
            perform::<plist::List<i32>>(args)
        } else if tp == "vbst" {
            perform::<vbst::BST<i32>>(args)
        } else if tp == "pbst" {
            perform::<pbst::BST<i64>>(args)
        } else if tp == "vhash" {
            perform::<vhash::HashMap<i32, i32>>(args)
        } else if tp == "phash" {
            perform::<phash::HashMap<i32, i32>>(args)
        }
    }
}