diman_unit_system 0.2.0

Internal procedural macros for diman.
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

use std::collections::HashMap;

use syn::Ident;

use super::{error::Error, error::Result};

pub trait Resolvable {
    type Resolved;

    fn resolve(self, others: &HashMap<Ident, Self::Resolved>) -> Self::Resolved;
    fn is_resolvable(&self, others: &HashMap<Ident, Self::Resolved>) -> bool;
    fn ident(&self) -> Ident;
}

pub struct Resolver<U, R> {
    unresolved: Vec<U>,
    resolved: HashMap<Ident, R>,
}

impl<U: Resolvable<Resolved = R>, R> Resolver<U, R> {
    pub fn resolve(unresolved: Vec<U>) -> Result<HashMap<Ident, R>> {
        let mut resolver = Self {
            unresolved,
            resolved: HashMap::new(),
        };
        resolver.run()?;
        Ok(resolver.resolved)
    }

    fn run(&mut self) -> Result<()> {
        // This is a very inefficient topological sort.
        while !self.unresolved.is_empty() {
            let next_resolvable = self
                .unresolved
                .iter()
                .enumerate()
                .find(|(_, x)| x.is_resolvable(&self.resolved));
            if let Some((index, _)) = next_resolvable {
                let next_resolvable = self.unresolved.remove(index);
                let name = next_resolvable.ident();
                let resolved = next_resolvable.resolve(&self.resolved);
                self.resolved.insert(name, resolved);
            } else {
                return Err(Error::unresolvable(
                    self.unresolved.drain(..).map(|x| x.ident()).collect(),
                ));
            }
        }
        Ok(())
    }
}