try to fix some minor dropdown bugs
[potlatch2.git] / org / idmedia / as3commons / util / HashMap.as
1 /*
2  * Copyright the original author or authors.
3  * 
4  * Licensed under the MOZILLA PUBLIC LICENSE, Version 1.1 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  * 
8  *      http://www.mozilla.org/MPL/MPL-1.1.html
9  * 
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package org.idmedia.as3commons.util {
17   
18   
19   /**
20    * Hash table based implementation of the <tt>Map</tt> interface.  This
21    * implementation provides all of the optional map operations, and permits
22    * <tt>null</tt> values and the <tt>null</tt> key. 
23    * This class makes no guarantees as to the order of the map; in particular, 
24    * it does not guarantee that the order will remain constant over time.
25    *
26    * <p>This implementation provides constant-time performance for the basic
27    * operations (<tt>get</tt> and <tt>put</tt>), assuming the hash function
28    * disperses the elements properly among the buckets.  Iteration over
29    * collection views requires time proportional to the "capacity" of the
30    * <tt>HashMap</tt> instance (the number of buckets) plus its size (the number
31    * of key-value mappings).
32    *
33    * <p>The iterators returned by all of this class's "collection view methods"
34    * are <i>fail-fast</i>: if the map is structurally modified at any time after
35    * the iterator is created, in any way except through the iterator's own
36    * <tt>remove</tt> or <tt>add</tt> methods, the iterator will throw a
37    * <tt>ConcurrentModificationException</tt>.  Thus, in the face of concurrent
38    * modification, the iterator fails quickly and cleanly, rather than risking
39    * arbitrary, non-deterministic behavior at an undetermined time in the
40    * future.
41    *
42    * <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
43    * as it is, generally speaking, impossible to make any hard guarantees in the
44    * presence of unsynchronized concurrent modification.  Fail-fast iterators
45    * throw <tt>ConcurrentModificationException</tt> on a best-effort basis. 
46    * Therefore, it would be wrong to write a program that depended on this
47    * exception for its correctness: <i>the fail-fast behavior of iterators
48    * should be used only to detect bugs.</i>
49    * 
50    * @author sleistner
51    * @inheritDoc
52    */
53   public class HashMap extends AbstractMap implements Map {
54     
55     private var entries:Set;
56     
57     /**
58      * Constructs an empty <tt>HashMap</tt>
59      */
60     function HashMap() {
61       entries = new EntrySet();
62     }
63     
64     /**
65      * Returns a collection view of the mappings contained in this map.  Each
66      * element in the returned collection is a <tt>Entry</tt>.  The
67      * collection is backed by the map, so changes to the map are reflected in
68      * the collection, and vice-versa.  The collection supports element
69      * removal, which removes the corresponding mapping from the map, via the
70      * <tt>Iterator.remove</tt>, <tt>Collection.remove</tt>,
71      * <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt> operations.
72      * It does not support the <tt>add</tt> or <tt>addAll</tt> operations.
73      *
74      * @return a collection view of the mappings contained in this map.
75      * @see Entry Entry
76      */
77     override public function entrySet():Set {
78       return entries;   
79     }
80     
81     /**
82      * Associates the specified value with the specified key in this map.
83      * If the map previously contained a mapping for this key, the old
84      * value is replaced.
85      *
86      * @param key key with which the specified value is to be associated.
87      * @param value value to be associated with the specified key.
88      * @return previous value associated with specified key, or <tt>null</tt>
89      *         if there was no mapping for key.  A <tt>null</tt> return can
90      *         also indicate that the HashMap previously associated
91      *         <tt>null</tt> with the specified key.
92      */
93     override public function put(key:*, value:*):* {
94       //if(key == null) {
95         //throw new NullPointerException();
96       //}
97
98       var iter:Iterator = entries.iterator();
99       while(iter.hasNext()) {
100         var e:Entry = Entry(iter.next());
101         if(e.getKey() === key) {
102           var oldValue:* = e.getValue();
103           e.setValue(value);
104           return oldValue;      
105         }       
106       }
107       entries.add(new EntryImpl(key, value));
108       return null;
109     }
110     
111     /**
112      * This method was added by Derek Wischusen on 10/15/2007.
113      * 
114      * Iterates throughs the hash and passes each key value pair 
115      * to the function that is passed in as parameter.
116      * 
117      * @param block a function that the following signature:
118      *              function(key : Object, value : object){}
119      * 
120      */    
121     public function forEach (block : Function) : void
122     {
123                 var keys : Array = this.keySet().toArray();                             
124                 for each (var key : Object in keys)
125                 {
126                         block(key, this.get(key))
127                 }       
128     }
129   }
130 }
131
132 import org.idmedia.as3commons.lang.IllegalArgumentException;
133 import org.idmedia.as3commons.lang.IllegalStateException;
134 import org.idmedia.as3commons.lang.NoSuchElementException;
135 import org.idmedia.as3commons.util.AbstractSet;
136 import org.idmedia.as3commons.util.Entry;
137 import org.idmedia.as3commons.util.Iterator;
138
139 internal class EntryImpl implements Entry {
140   
141   private var key:*;
142   private var value:*;
143   
144   function EntryImpl(key:*, value:*) {
145     this.key = key;
146     this.value = value;
147   }
148   
149   public function getKey():* {
150     return key;
151   }
152   
153   public function getValue():* {
154     return value;
155   }
156   
157   public function setValue(newValue:*):* {
158     var oldValue:* = value;
159     value = newValue;
160     return oldValue;
161   }
162   
163   public function equals(o:*):Boolean {
164     return o === this;
165   }
166 }
167
168