1 dojo.provide("calitha.collections.AbstractMap");
  2 dojo.require("calitha.collections.IMap");
  3 dojo.require("calitha.collections.util");
  4 dojo.require("calitha.collections.abstractmap.KeySet");
  5 dojo.require("calitha.collections.abstractmap.ValuesCollection");
  6 dojo.require("calitha.exception.UnsupportedOperationException");
  7 
  8 dojo.declare("calitha.collections.AbstractMap", calitha.collections.IMap,
  9 /** @lends calitha.collections.AbstractMap# */
 10 {
 11     /**
 12      * @constructs
 13      * @extends calitha.collections.IMap
 14      */
 15     constructor: function()
 16     {
 17         this._keySet = null;
 18         this._values = null;
 19     }
 20     ,
 21     clear: function()
 22     {
 23 	    this.entrySet().clear();
 24     }
 25     ,
 26     containsKey: function(/**Object*/ key)
 27     {
 28         var it = this.entrySet().iterator();
 29         while (it.hasNext())
 30         {
 31             var entry = it.next();
 32             if (calitha.collections.util.equals(entry.getKey(), key))
 33             {
 34                 return true;
 35             }
 36         }
 37         return false;
 38     }
 39     ,
 40     containsValue: function(/**Object*/ value)
 41     {
 42         var it = this.entrySet().iterator();
 43         while (it.hasNext())
 44         {
 45             var entry = it.next();
 46             if (calitha.collections.util.equals(entry.getValue(), value))
 47             {
 48                 return true;
 49             }
 50         }
 51         return false;
 52     }
 53     ,
 54     equals: function(/**Object*/ o)
 55     {
 56         if (o === this)
 57         {
 58             return true;
 59         }
 60         if (!(calitha.collections.util.isObjectInstanceOf(o, calitha.collections.IMap)))
 61         {
 62             return false;
 63         }
 64         //noinspection UnnecessaryLocalVariableJS
 65         var map = o;
 66 	    if (map.size() != this.size())
 67         {
 68 	        return false;
 69         }
 70         var it = this.entrySet().iterator();
 71         while (it.hasNext())
 72         {
 73             var entry = it.next();
 74             var key = entry.getKey();
 75             var value = entry.getValue();
 76             if (value === null)
 77             {
 78                 if (!(map.get(key) === null && map.containsKey(key)))
 79                 {
 80                     return false;
 81                 }
 82             }
 83             else
 84             {
 85                 if (!value.equals(map.get(key)))
 86                 {
 87                     return false;
 88                 }
 89             }
 90         }
 91         return true;
 92     }
 93     ,
 94     get: function(/**Object*/ key)
 95     {
 96         var it = this.entrySet().iterator();
 97         while (it.hasNext())
 98         {
 99             var entry = it.next();
100             if (calitha.collections.util.equals(entry.getKey(), key))
101             {
102                 return entry.getValue();
103             }
104         }
105         return null;
106     }
107     ,
108     hashCode: function()
109     {
110 	    var result = 0;
111         var it = this.entrySet().iterator();
112         while (it.hasNext())
113         {
114             result += calitha.collections.util.hashCode(it.next())
115         }
116         return result;
117     }
118     ,
119     isEmpty: function()
120     {
121 	    return this.size() === 0;
122     }
123     ,
124     keySet: function()
125     {
126         if (this._keySet === null)
127         {
128             this._keySet = new calitha.collections.abstractmap.KeySet(this);
129         }
130         return this._keySet;
131     }
132     ,
133     put: function(/**Object*/ key, /**Object*/ value)
134     {
135 	    throw new calitha.exception.UnsupportedOperationException(Error());
136     }
137     ,
138     putAll: function(/**calitha.collections.IMap*/ map)
139     {
140         var it = map.entrySet().iterator();
141         while (it.hasNext())
142         {
143             var entry = it.next();
144             this.put(entry.getKey(), entry.getValue());
145         }
146     }
147     ,
148     remove: function(/**Object*/ key)
149     {
150         var it = this.entrySet().iterator();
151         var correctEntry = null;
152         while (it.hasNext())
153         {
154             var entry = it.next();
155             if (calitha.collections.util.equals(entry.getKey(), key))
156             {
157                 correctEntry = entry;
158                 break;
159             }
160         }
161         var oldValue = null;
162         if (correctEntry != null)
163         {
164             oldValue = correctEntry.getValue();
165             it.remove();
166         }
167         return oldValue;
168     }
169     ,
170     size: function()
171     {
172 	    return this.entrySet().size();
173     }
174     ,
175     toString: function()
176     {
177 	    var it = this.entrySet().iterator();
178 	    if (! it.hasNext())
179         {
180 	        return "{}";
181         }
182 	    var sb = new calitha.collections.StringBuilder();
183 	    sb.append('{');
184         while (it.hasNext())
185         {
186             var entry = it.next();
187             var key = entry.getKey();
188             var value = entry.getValue();
189             sb.append(key === this ? "(this Map)" : key);
190             sb.append('=');
191             sb.append(value === this ? "(this Map)" : value);
192             if (it.hasNext())
193             {
194                 sb.append(", ");
195             }
196         }
197         return sb.append('}').toString();
198     }
199     ,
200     values: function()
201     {
202         if (this._values === null)
203         {
204             this._values = new calitha.collections.abstractmap.ValuesCollection(this);
205         }
206         return this._values;
207     }
208 
209 });
210 
211 
212 
213 
214