clover 0.1.3

A scripting language.
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
99
100
101
102
103
104
105
106
107
108
109
110

use crate::intermediate::ast::Document;
use std::collections::{HashMap, HashSet};

pub struct DependencySolver {
    dependencies: HashMap<String, u32>,
    references: HashMap<String, Vec<String>>,
    unsolved: HashSet<String>
}

impl DependencySolver {
    pub fn new() -> DependencySolver {
        DependencySolver {
            dependencies: HashMap::new(),
            references: HashMap::new(),
            unsolved: HashSet::new()
        }
    }

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

    pub fn get_cycle_reference_list(&self) -> Vec<String> {
        let mut list = Vec::new();

        for (filename, _) in self.dependencies.iter() {
            list.push(filename.clone());
        };

        list
    }

    pub fn get_unsolved_filename(&self) -> Option<String> {
        if let Some(filename) = self.unsolved.iter().next() {
            Some(filename.clone())
        } else {
            None
        }
    }

    pub fn get_next_no_dependency_filename(&self) -> Option<String> {
        for (filename, &dependency) in self.dependencies.iter() {
            if dependency == 0 {
                return Some(filename.clone());
            };
        };

        None
    }

    pub fn set_loaded(&mut self, filename: &str) {
        self.dependencies.remove(filename);

        if let Some(source_list) = self.references.remove(filename) {
            for source in source_list.iter() {
                self.decrease_dependency(source);
            }
        }
    }

    pub fn solve(&mut self, document: &Document, loaded_assemblies: &HashSet<String>) {
        if loaded_assemblies.contains(&document.filename) || self.dependencies.contains_key(&document.filename) {
            return;
        }

        self.add_dependencies(document, loaded_assemblies);

        if self.unsolved.contains(&document.filename) {
            self.unsolved.remove(&document.filename);
        };
    }

    fn add_reference(&mut self, source: &str, target: &str) {
        if !self.references.contains_key(target) {
            self.references.insert(target.to_string(), Vec::new());
        };

        let list = self.references.get_mut(target).unwrap();
        list.push(source.to_string());
    }

    fn increase_dependency(&mut self, source: &str) {
        if let Some(count) = self.dependencies.get_mut(source) {
            *count += 1;
        } else {
            self.dependencies.insert(source.to_string(), 1);
        };
    }

    fn decrease_dependency(&mut self, source: &str) {
        if let Some(count) = self.dependencies.get_mut(source) {
            *count -= 1;
        }
    }

    fn add_dependencies(&mut self, document: &Document, loaded_assemblies: &HashSet<String>) {
        self.dependencies.insert(document.filename.clone(), 0);

        for dependency_filename in document.get_dependencies().iter() {
            if !loaded_assemblies.contains(dependency_filename) {
                self.increase_dependency(&document.filename);
                self.add_reference(&document.filename, dependency_filename);

                if !self.dependencies.contains_key(dependency_filename) {
                    self.unsolved.insert(dependency_filename.to_string());
                }
            };
        };
    }
}