orelang.operator.HashMapOperators source code

1 module orelang.operator.HashMapOperators;
2 import orelang.operator.IOperator,
3        orelang.Engine,
4        orelang.Value;
5 
6 class MakeHashOperator : IOperator {
7   /**
8    * call
9    */
10   /*
11     (make-hash name)
12    */
13   public Value call(Engine engine, Value[] args) {
14     string name = args[0].getString;
15     Value[string] hash = null;
16     Value ret = new Value(hash);
17 
18     engine.defineVariable(name, ret);
19 
20     return ret;
21   }
22 }
23 
24 class NewHashOperator : IOperator {
25   /**
26    * call
27    */
28   /*
29     (new-hash)
30    */
31   public Value call(Engine engine, Value[] args) {
32     Value[string] hash = null;
33     Value ret = new Value(hash);
34 
35     return ret;
36   }
37 }
38 
39 class HashSetValueOperator : IOperator {
40   /**
41    * call
42    */
43   /*
44     (hash-set-value hash key value)
45   */
46   public Value call(Engine engine, Value[] args) {
47     Value ret;
48 
49     if (args[0].type == ValueType.SymbolValue) {
50       Value obj = engine.getVariable(args[0].getString);
51 
52       if (obj.type == ValueType.HashMap) {
53         Value[string] hash = obj.getHashMap;
54         
55         hash[engine.eval(args[1]).getString] = engine.eval(args[2]);
56         ret = new Value(hash);
57       
58         engine.setVariable(args[0].getString, ret);
59       } else {
60         throw new Exception("No such a HashMap - " ~ args[0].getString);
61       }
62     } else if (args[0].type == ValueType.HashMap) {
63       Value[string] hash = args[0].getHashMap;
64 
65       hash[engine.eval(args[1]).getString] = engine.eval(args[2]);
66       ret = new Value(hash);
67 
68       engine.setVariable(args[0].getString, ret);
69     } else {
70       throw new Exception("set-value accepts (HashName Key Value) or (HashValue Key Value) only");
71     }
72 
73     return ret;
74   }
75 }
76 
77 class HashGetValueOperator : IOperator {
78   /**
79    * call
80    */
81   /*
82     (hash-get-value hash key)
83   */
84   public Value call(Engine engine, Value[] args) {
85     if (args[0].type == ValueType.SymbolValue) {
86       Value obj = engine.getVariable(args[0].getString);
87 
88       if (obj.type == ValueType.HashMap) {
89         Value[string] hash = obj.getHashMap;
90         return hash[engine.eval(args[1]).getString];
91       } else {
92         throw new Exception("No such a HashMap - " ~ args[0].getString);
93       }
94     } else if (engine.eval(args[0]).type == ValueType.HashMap) {
95       Value[string] hash = engine.eval(args[0]).getHashMap;
96 
97       return hash[engine.eval(args[1]).getString];
98     } else {
99       throw new Exception("hash-get-value accepts (HashName Key Value) or (HashValue Key Value) only");
100     }
101   }
102 }
103 
104 class HashGetKeysOperator : IOperator {
105   /**
106    * call
107    */
108   /*
109     (hash-get-keys hash)
110   */
111   public Value call(Engine engine, Value[] args) {
112     if (args[0].type == ValueType.SymbolValue) {
113       Value obj = engine.getVariable(args[0].getString);
114 
115       if (obj.type == ValueType.HashMap) {
116         Value[string] hash = obj.getHashMap;
117         Value[] keys;
118 
119         foreach (key; hash.keys) {
120           keys ~= new Value(key);
121         }
122 
123         return new Value(keys);
124       } else {
125         throw new Exception("No such a HashMap - " ~ args[0].getString);
126       }
127     } else if (engine.eval(args[0]).type == ValueType.HashMap) {
128       Value[string] hash = engine.eval(args[0]).getHashMap;
129       Value[] keys;
130 
131       foreach (key; hash.keys) {
132         keys ~= new Value(key);
133       }
134 
135       return new Value(keys);
136     } else {
137       throw new Exception("hash-get-keys accepts (HashName Key Value) or (HashValue Key Value) only");
138     }
139   }
140 }
141 
142 class HashGetValuesOperator : IOperator {
143   /**
144    * call
145    */
146   /*
147     (hash-get-values hash)
148   */
149   public Value call(Engine engine, Value[] args) {
150     if (args[0].type == ValueType.SymbolValue) {
151       Value obj = engine.getVariable(args[0].getString);
152 
153       if (obj.type == ValueType.HashMap) {
154         Value[string] hash = obj.getHashMap;
155         Value[] values;
156 
157         foreach (value; hash.values) {
158           values ~= value;
159         }
160 
161         return new Value(values);
162       } else {
163         throw new Exception("No such a HashMap - " ~ args[0].getString);
164       }
165     } else if (engine.eval(args[0]).type == ValueType.HashMap) {
166       Value[string] hash = engine.eval(args[0]).getHashMap;
167       Value[] values;
168 
169       foreach (value; hash.values) {
170         values ~= value;
171       }
172 
173       return new Value(values);
174     } else {
175       throw new Exception("hash-get-values accepts (HashName Key Value) or (HashValue Key Value) only");
176     }
177   }
178 }