incrust 0.2.15

Template engine inspired by Jinja2
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::collections::hash_map::{HashMap, Keys, Values, Iter};
use std::iter::Iterator;

use super::abc::*;


impl <'a> Type for HashMap<EntityId, BType<'a>> {
    fn to_bool(&self) -> bool { !self.is_empty() }
}

impl <'a> IClone for HashMap<EntityId, BType<'a>> {
    fn iclone<'b>(&self) -> Result<BType<'b>, CloneError> {
        let cloned: HashMap<EntityId, BType<'b>> = HashMap::new();
        for (k, v) in self.iter() {
            cloned.insert(k, v.iclone()?);
        }
        Ok( Box::new(cloned) )
    }
}


impl <'a, 'b: 'a> IIterable<'a> for HashMap<EntityId, BType<'a>> {
    fn is_empty(&self) -> bool {
        HashMap::is_empty(self)
    }

    fn ivalues(&self) -> VIterator {
        VIterator { me: self.values() }
    }
}



//impl <'a> IMap for HashMap<EntityId, BType<'a>> {
//    fn ivalues(&self) -> Option<Box<Iterator<Item=BType>>> {
//        Some(Box::new(VIterator { me: self.values() }))
//    }
////    fn ikeys(&self) -> Option<KIterator> {
////        Some(KIterator { me: self.keys() })
////    }
////    fn ikeyvalues(&self) -> Option<KVIterator> {
////        Some(KVIterator { me: self.iter() })
////    }
//}



//impl <'a> Iterator for KIterator<'a> {
//    type Item = &'a EntityId;
//
//    fn next(&mut self) -> Option<&'a EntityId> {
//        match self.me.next() {
//            Some(next) => Some(next),
//            None => None
//        }
//    }
//}
//
//impl <'a> Iterator for KVIterator<'a> {
//    type Item = (&'a EntityId, &'a Var);
//
//    fn next(&mut self) -> Option<(&'a EntityId, &'a Var)> {
//        match self.me.next() {
//            Some(next) => Some(next),
//            None => None
//        }
//    }
//}