harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From telli...@apache.org
Subject svn commit: r420770 [2/2] - in /incubator/harmony/enhanced/classlib/trunk/modules/security/src/main/java/common: java/security/Provider.java org/apache/harmony/security/utils/TwoKeyHashMap.java
Date Tue, 11 Jul 2006 09:04:39 GMT
Modified: incubator/harmony/enhanced/classlib/trunk/modules/security/src/main/java/common/org/apache/harmony/security/utils/TwoKeyHashMap.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/security/src/main/java/common/org/apache/harmony/security/utils/TwoKeyHashMap.java?rev=420770&r1=420769&r2=420770&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/security/src/main/java/common/org/apache/harmony/security/utils/TwoKeyHashMap.java
(original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/security/src/main/java/common/org/apache/harmony/security/utils/TwoKeyHashMap.java
Tue Jul 11 02:04:38 2006
@@ -1,550 +1,557 @@
-/*
- *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-package org.apache.harmony.security.utils;
-
-import java.util.AbstractCollection;
-import java.util.AbstractMap;
-import java.util.AbstractSet;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.ConcurrentModificationException;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.NoSuchElementException;
-import java.util.Set;
-
-/**
- *
- * Reductive hash with two keys
- * 
- */
-public class TwoKeyHashMap<V> extends AbstractMap<String, V> {
-
-    static final float DEFAULT_LOAD_FACTOR = 0.75f;
-    static final int DEFAULT_INITIAL_SIZE = 16;
-    
-    private Set<Map.Entry<String, V>> entrySet;
-    private Collection<V> values;
-    private int size;
-    private int arrSize;
-    private transient int modCount;
-    
-    private Entry<V>[] arr;
-
-    private float loadFactor;
-    int threshold = 0;
-
-    /**
-     * Constructs an empty HashMap
-     * @param initialCapacity
-     */
-    public TwoKeyHashMap(int initialCapacity) {
-        this(initialCapacity, DEFAULT_LOAD_FACTOR);
-    }
-
-    /**
-     * Constructs an empty HashMap 
-     * @param initialCapacity
-     * @param initialLoadFactor
-     */
-    public TwoKeyHashMap(int initialCapacity, float initialLoadFactor) {
-         if (initialCapacity < 0) {
-            throw new IllegalArgumentException("initialCapacity should be >= 0");
-        }
-        if (initialLoadFactor <= 0) {
-            throw new IllegalArgumentException("initialLoadFactor should be > 0");
-        }
-        loadFactor = initialLoadFactor;
-        if (initialCapacity == Integer.MAX_VALUE) {
-            initialCapacity--;
-        }
-        arrSize = initialCapacity > 0 ? initialCapacity : 1;
-        threshold = (int) (arrSize * loadFactor);
-        arr = new Entry[arrSize + 1];
-    }
-    
-    /**
-     * Returns a collection view of the values 
-     */
-    public Collection<V> values() {
-        if (values == null) {
-            values = new ValuesCollectionImpl();
-        }
-        return values;
-    }
-    
-    /**
-     * Returns a collection view of the mappings  
-     */
-    public Set<Map.Entry<String, V>> entrySet() {
-        if (entrySet == null) {
-            entrySet = new EntrySetImpl();
-        }
-        return entrySet;
-    }
-    
-    /**
-     * Clears the map
-     */
-    public void clear() {
-        modCount++;
-        size = 0;
-        Arrays.fill(arr, 0, arr.length, null);
-    }
-
-    /**
-     * Removes the mapping for the keys
-     * @param key1
-     * @param key2
-     * @return
-     */
-    public V remove(Object key1, Object key2) {
-        Entry<V> e = removeEntry(key1, key2);
-        return null != e ? e.value : null;
-    }
-    
-    /**
-     * Associates the specified value with the specified keys in this map
-     * @param key1
-     * @param key2
-     * @param value
-     * @return
-     */
-    public V put(String key1, String key2, V value) {
-        if (key1 == null && key2 == null) {
-            int index = arrSize;
-            if (arr[index] == null) {
-                arr[index] = createEntry(0, key1, key2, value, null);
-                size++;
-                modCount++;
-                return null;
-            } else {
-                V oldValue = arr[index].value;
-                arr[index].value = value;
-                return oldValue;
-            }
-        }
-
-        int hash = key1.hashCode() + key2.hashCode();
-        int index = (hash & 0x7fffffff) % arrSize;
-        Entry<V> e = arr[index];
-
-        while (e != null) {
-            if (hash == e.hash && key1.equals(e.getKey1()) && key2.equals(e.getKey2()))
{
-                V oldValue = e.value;
-                e.value = value;
-                return oldValue;
-            }
-            e = e.next;
-        }
-
-        arr[index] = createEntry(hash, key1, key2, value, arr[index]);
-        size++;
-        modCount++;
-
-        if (size > threshold) {
-            rehash();
-        }
-        return null;
-    }
-
-    /**
-     * Rehash the map
-     *
-     */
-    void rehash() {
-        int newArrSize = (arrSize + 1) * 2 + 1;
-        if (newArrSize < 0) {
-            newArrSize = Integer.MAX_VALUE - 1;
-        }
-        Entry<V>[] newArr = new Entry[newArrSize + 1];
-
-        for (int i = 0; i < arr.length - 1; i++) {
-            Entry<V> entry = arr[i];
-            while (entry != null) {
-                Entry<V> next = entry.next;
-
-                int newIndex = (entry.hash & 0x7fffffff) % newArrSize;
-                entry.next = newArr[newIndex];
-                newArr[newIndex] = entry;
-
-                entry = next;
-            }
-        }
-        newArr[newArrSize] = arr[arrSize]; // move null entry
-        arrSize = newArrSize;
-
-        // The maximum array size is reached, increased loadFactor
-        // will keep array from further growing
-        if (arrSize == Integer.MAX_VALUE) {
-            loadFactor *= 10;
-        }
-        threshold = (int) (arrSize * loadFactor);
-        arr = newArr;
-    }
-
-    /**
-     * Returns true if this map contains a mapping for the specified keys
-     * @param key1
-     * @param key2
-     * @return
-     */
-    public boolean containsKey(Object key1, Object key2) {
-        return findEntry(key1, key2) != null;
-    }
-
-    /**
-     * Return the value by keys
-     * @param key1
-     * @param key2
-     * @return
-     */
-    public V get(Object key1, Object key2) {
-        Entry<V> e = findEntry(key1, key2);
-        if (e != null) {
-            return e.value;
-        }
-        return null;
-    }
-
-    /**
-     * Returns true if this map contains no key-value mappings
-     */
-    public boolean isEmpty() {
-        return size == 0;
-    }
-
-    /**
-     * Returns the number of mappings 
-     */
-    public int size() {
-        return size;
-    }
-    
-    /**
-     *  Creates new entry
-     * @param hashCode
-     * @param key1
-     * @param key2
-     * @param value
-     * @param next
-     * @return
-     */
-    Entry<V> createEntry(int hashCode, String key1, String key2, 
-            V value, Entry<V> next) {
-        return new Entry<V>(hashCode, key1, key2, value, next);
-    }
-
-    /**
-     * Creates entries iterator
-     * @return
-     */
-    Iterator<Map.Entry<String, V>> createEntrySetIterator() {
-        return new EntryIteratorImpl();
-    }
-
-    /**
-     * Creates values iterator
-     * @return
-     */
-    Iterator<V> createValueCollectionIterator() {
-        return new ValueIteratorImpl();
-    }
-
-    
-    /**
-     * Entry implementation for the TwoKeyHashMap class
-     * 
-     */
-    static class Entry<V> implements Map.Entry<String, V> { 
-        int hash;
-        String key1;
-        String key2;
-        V value;
-        Entry<V> next;
-
-        public Entry(int hash, String key1, String key2, V value, Entry<V> next) {
-            this.hash = hash;
-            this.key1 = key1;
-            this.key2 = key2;
-            this.value = value;
-            this.next = next;
-        }
-        
-        public String getKey() {
-            return key1 + key2;
-        }
-
-        public String getKey1() {
-            return key1;
-        }
-        
-        public String getKey2() {
-            return key2;
-        }
-
-        public V getValue() {
-            return value;
-        }
-
-        public V setValue(V value) {
-            V oldValue = this.value;
-            this.value = value;
-            return oldValue;
-        }
-
-        public boolean equals(Object obj) {
-            if (!(obj instanceof Entry)) {
-                return false;
-            }
-
-            Entry<?> e = (Entry<?>) obj;
-            Object getKey1 = e.getKey1();
-            Object getKey2 = e.getKey2();
-            Object getValue = e.getValue();
-            if ((key1 == null && getKey1 != null) || 
-                    (key2 == null && getKey2 != null) ||
-                    (value == null && getValue != null) ||
-                    !key1.equals(e.getKey1()) ||
-                    !key2.equals(e.getKey2()) ||
-                    !value.equals(getValue)) {
-                return false;
-            }
-            return true;
-        }
-
-        public int hashCode() {
-            int hash1 = (key1 == null ? 0 : key1.hashCode());
-            int hash2 = (key2 == null ? 0 : key2.hashCode());
-            return (hash1 + hash2) ^ (value == null ? 0 : value.hashCode());
-        }
-        
-    }
-    
-    class EntrySetImpl extends AbstractSet<Map.Entry<String, V>> {
-        public int size() {
-            return size;
-        }
-
-        public void clear() {
-            TwoKeyHashMap.this.clear();
-        }
-
-        public boolean isEmpty() {
-            return size == 0;
-        }
-
-        public boolean contains(Object obj) {
-            if (!(obj instanceof Entry)) {
-                return false;
-            }
-
-            Entry<?> entry = (Entry<?>) obj;
-            Entry<V> entry2 = findEntry(entry.getKey1(), entry.getKey2());
-            if (entry2 == null) {
-                return false;
-            }
-            Object value = entry.getValue();
-            Object value2 = entry2.getValue();
-            return value == null ? value2 == null : value.equals(value2);
-        }
-
-        public boolean remove(Object obj) {
-            if (!(obj instanceof Entry)) {
-                return false;
-            }
-            return removeEntry(((Entry) obj).getKey1(), ((Entry)obj).getKey2()) != null;
-        }
-
-        public Iterator<Map.Entry<String, V>> iterator() {
-            return createEntrySetIterator();
-        }
-    }
-
-    // Iterates Entries inside the Map
-    class EntryIteratorImpl implements Iterator<Map.Entry<String, V>> {
-        private int startModCount;
-        private boolean found;
-        private int curr = -1;
-        private int returned_index = -1;
-        private Entry<V> curr_entry;
-        private Entry<V> returned_entry;
-
-        EntryIteratorImpl() {
-            startModCount = modCount;
-        }
-
-        public boolean hasNext() {
-            if (found) {
-                return true;
-            }
-            if (curr_entry != null) {
-                curr_entry = curr_entry.next;
-            }
-            if (curr_entry == null) {
-                for (curr++; curr < arr.length && arr[curr] == null; curr++) {
-                }
-
-                if (curr < arr.length) {
-                    curr_entry = arr[curr];
-                }
-            }
-            return found = (curr_entry != null);
-        }
-
-        public Map.Entry<String, V> next() {
-            if (modCount != startModCount) {
-                throw new ConcurrentModificationException();
-            }
-            if (!hasNext()) {
-                throw new NoSuchElementException();
-            }
-
-            found = false;
-            returned_index = curr;
-            returned_entry = curr_entry;
-            return (Map.Entry<String, V>)curr_entry;
-        }
-
-        public void remove() {
-            if (returned_index == -1) {
-                throw new IllegalStateException();
-            }
-            
-            if (modCount != startModCount) {
-                throw new ConcurrentModificationException();
-            }
-
-            Entry<V> p = null;
-            Entry<V> e = arr[returned_index];
-            while (e != returned_entry) {
-                p = e;
-                e = e.next;
-            }
-            if (p != null) {
-                p.next = returned_entry.next;
-            } else {
-                arr[returned_index] = returned_entry.next;
-            }
-            size--;
-            modCount++;
-            startModCount++;
-            returned_index = -1;
-        }
-    }
-    
-    private final Entry<V> findEntry(Object key1, Object key2) {
-        if (key1 == null && key2 == null) {
-            return arr[arrSize];
-        }
-
-        int hash = key1.hashCode() + key2.hashCode();
-        int index = (hash & 0x7fffffff) % arrSize;
-        Entry<V> e = arr[index];
-
-        while (e != null) {
-            if (hash == e.hash && key1.equals(e.getKey1()) && key2.equals(e.getKey2()))
{
-                return e;
-            }
-            e = e.next;
-        }
-        return null;
-    }
-    
-    // Removes entry
-    private final Entry<V> removeEntry(Object key1, Object key2) {
-        if (key1 == null && key2 == null) {
-            int index = arrSize;
-            if (arr[index] != null) {
-                Entry<V> ret = arr[index];
-                arr[index] = null;
-                size--;
-                modCount++;
-                return ret;
-            }
-            return null;
-        }
-
-        int hash = key1.hashCode() + key2.hashCode();
-        int index = (hash & 0x7fffffff) % arrSize;
-
-        Entry<V> e = arr[index];
-        Entry<V> prev = e;
-        while (e != null) {
-            if (hash == e.hash && key1.equals(e.getKey1()) && key2.equals(e.getKey2()))
{
-                if (prev == e) {
-                    arr[index] = e.next;
-                } else {
-                    prev.next = e.next;
-                }
-                size--;
-                modCount++;
-                return e;
-            }
-
-            prev = e;
-            e = e.next;
-        }
-        return null;
-    }
-
-    /**
-     * An instance is returned by the values() call.
-     */
-    class ValuesCollectionImpl extends AbstractCollection<V> {
-        public int size() {
-            return size;
-        }
-
-        public void clear() {
-            TwoKeyHashMap.this.clear();
-        }
-
-        public boolean isEmpty() {
-            return size == 0;
-        }
-
-        public Iterator<V> iterator() {
-            return createValueCollectionIterator();
-        }
-        
-        public boolean contains(Object obj) {
-            return containsValue(obj);
-        }
-    }
-    
-    class ValueIteratorImpl implements Iterator<V> {
-        private EntryIteratorImpl itr;
-
-        ValueIteratorImpl() {
-            super();
-            this.itr = new EntryIteratorImpl();
-        }
-
-        public V next() {
-            return itr.next().getValue();
-        }
-
-        public void remove() {
-            itr.remove();
-        }
-
-        public boolean hasNext() {
-            return itr.hasNext();
-        }
-    }
-}
+/*
+ *  Copyright 2005 The Apache Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package org.apache.harmony.security.utils;
+
+import java.util.AbstractCollection;
+import java.util.AbstractMap;
+import java.util.AbstractSet;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.ConcurrentModificationException;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+
+/**
+ *
+ * Reductive hash with two keys
+ * 
+ */
+public class TwoKeyHashMap<E, K, V> extends AbstractMap<String, V> {
+
+    static final float DEFAULT_LOAD_FACTOR = 0.75f;
+    static final int DEFAULT_INITIAL_SIZE = 16;
+    
+    private Set<Map.Entry<String, V>> entrySet;
+    private Collection<V> values;
+    private int size;
+    private int arrSize;
+    private transient int modCount;
+    
+    private Entry<E, K, V>[] arr;
+
+    private float loadFactor;
+    int threshold = 0;
+
+    /**
+     * Constructs an empty HashMap
+     */
+    public TwoKeyHashMap() {
+        this(DEFAULT_INITIAL_SIZE, DEFAULT_LOAD_FACTOR);
+    }
+    
+    /**
+     * Constructs an empty HashMap
+     * @param initialCapacity
+     */
+    public TwoKeyHashMap(int initialCapacity) {
+        this(initialCapacity, DEFAULT_LOAD_FACTOR);
+    }
+
+    /**
+     * Constructs an empty HashMap 
+     * @param initialCapacity
+     * @param initialLoadFactor
+     */
+    public TwoKeyHashMap(int initialCapacity, float initialLoadFactor) {
+         if (initialCapacity < 0) {
+            throw new IllegalArgumentException("initialCapacity should be >= 0");
+        }
+        if (initialLoadFactor <= 0) {
+            throw new IllegalArgumentException("initialLoadFactor should be > 0");
+        }
+        loadFactor = initialLoadFactor;
+        if (initialCapacity == Integer.MAX_VALUE) {
+            initialCapacity--;
+        }
+        arrSize = initialCapacity > 0 ? initialCapacity : 1;
+        threshold = (int) (arrSize * loadFactor);
+        arr = new Entry[arrSize + 1];
+    }
+    
+    /**
+     * Returns a collection view of the values 
+     */
+    public Collection<V> values() {
+        if (values == null) {
+            values = new ValuesCollectionImpl();
+        }
+        return values;
+    }
+    
+    /**
+     * Returns a collection view of the mappings  
+     */
+    public Set<Map.Entry<String, V>> entrySet() {
+        if (entrySet == null) {
+            entrySet = new EntrySetImpl();
+        }
+        return entrySet;
+    }
+    
+    /**
+     * Clears the map
+     */
+    public void clear() {
+        modCount++;
+        size = 0;
+        Arrays.fill(arr, 0, arr.length, null);
+    }
+
+    /**
+     * Removes the mapping for the keys
+     * @param key1
+     * @param key2
+     * @return
+     */
+    public V remove(Object key1, Object key2) {
+        Entry<E, K, V> e = removeEntry(key1, key2);
+        return null != e ? e.value : null;
+    }
+    
+    /**
+     * Associates the specified value with the specified keys in this map
+     * @param key1
+     * @param key2
+     * @param value
+     * @return
+     */
+    public V put(E key1, K key2, V value) {
+        if (key1 == null && key2 == null) {
+            int index = arrSize;
+            if (arr[index] == null) {
+                arr[index] = createEntry(0, key1, key2, value, null);
+                size++;
+                modCount++;
+                return null;
+            } else {
+                V oldValue = arr[index].value;
+                arr[index].value = value;
+                return oldValue;
+            }
+        }
+
+        int hash = key1.hashCode() + key2.hashCode();
+        int index = (hash & 0x7fffffff) % arrSize;
+        Entry<E, K, V> e = arr[index];
+
+        while (e != null) {
+            if (hash == e.hash && key1.equals(e.getKey1()) && key2.equals(e.getKey2()))
{
+                V oldValue = e.value;
+                e.value = value;
+                return oldValue;
+            }
+            e = e.next;
+        }
+
+        arr[index] = createEntry(hash, key1, key2, value, arr[index]);
+        size++;
+        modCount++;
+
+        if (size > threshold) {
+            rehash();
+        }
+        return null;
+    }
+
+    /**
+     * Rehash the map
+     *
+     */
+    void rehash() {
+        int newArrSize = (arrSize + 1) * 2 + 1;
+        if (newArrSize < 0) {
+            newArrSize = Integer.MAX_VALUE - 1;
+        }
+        Entry<E, K, V>[] newArr = new Entry[newArrSize + 1];
+
+        for (int i = 0; i < arr.length - 1; i++) {
+            Entry<E, K, V> entry = arr[i];
+            while (entry != null) {
+                Entry<E, K, V> next = entry.next;
+
+                int newIndex = (entry.hash & 0x7fffffff) % newArrSize;
+                entry.next = newArr[newIndex];
+                newArr[newIndex] = entry;
+
+                entry = next;
+            }
+        }
+        newArr[newArrSize] = arr[arrSize]; // move null entry
+        arrSize = newArrSize;
+
+        // The maximum array size is reached, increased loadFactor
+        // will keep array from further growing
+        if (arrSize == Integer.MAX_VALUE) {
+            loadFactor *= 10;
+        }
+        threshold = (int) (arrSize * loadFactor);
+        arr = newArr;
+    }
+
+    /**
+     * Returns true if this map contains a mapping for the specified keys
+     * @param key1
+     * @param key2
+     * @return
+     */
+    public boolean containsKey(Object key1, Object key2) {
+        return findEntry(key1, key2) != null;
+    }
+
+    /**
+     * Return the value by keys
+     * @param key1
+     * @param key2
+     * @return
+     */
+    public V get(Object key1, Object key2) {
+        Entry<E, K, V> e = findEntry(key1, key2);
+        if (e != null) {
+            return e.value;
+        }
+        return null;
+    }
+
+    /**
+     * Returns true if this map contains no key-value mappings
+     */
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    /**
+     * Returns the number of mappings 
+     */
+    public int size() {
+        return size;
+    }
+    
+    /**
+     *  Creates new entry
+     * @param hashCode
+     * @param key1
+     * @param key2
+     * @param value
+     * @param next
+     * @return
+     */
+    Entry<E, K, V> createEntry(int hashCode, E key1, K key2, 
+            V value, Entry<E, K, V> next) {
+        return new Entry<E, K, V>(hashCode, key1, key2, value, next);
+    }
+
+    /**
+     * Creates entries iterator
+     * @return
+     */
+    Iterator<Map.Entry<String, V>> createEntrySetIterator() {
+        return new EntryIteratorImpl();
+    }
+
+    /**
+     * Creates values iterator
+     * @return
+     */
+    Iterator<V> createValueCollectionIterator() {
+        return new ValueIteratorImpl();
+    }
+
+    
+    /**
+     * Entry implementation for the TwoKeyHashMap class
+     * 
+     */
+    public static class Entry<E, K, V> implements Map.Entry<String, V> { 
+        int hash;
+        E key1;
+        K key2;
+        V value;
+        Entry<E, K, V> next;
+
+        public Entry(int hash, E key1, K key2, V value, Entry<E, K, V> next) {
+            this.hash = hash;
+            this.key1 = key1;
+            this.key2 = key2;
+            this.value = value;
+            this.next = next;
+        }
+        
+        public String getKey() {
+            return key1.toString() + key2.toString();
+        }
+
+        public E getKey1() {
+            return key1;
+        }
+        
+        public K getKey2() {
+            return key2;
+        }
+
+        public V getValue() {
+            return value;
+        }
+
+        public V setValue(V value) {
+            V oldValue = this.value;
+            this.value = value;
+            return oldValue;
+        }
+
+        public boolean equals(Object obj) {
+            if (!(obj instanceof Entry)) {
+                return false;
+            }
+
+            Entry<?, ?, ?> e = (Entry<?, ?, ?>) obj;
+            Object getKey1 = e.getKey1();
+            Object getKey2 = e.getKey2();
+            Object getValue = e.getValue();
+            if ((key1 == null && getKey1 != null) || 
+                    (key2 == null && getKey2 != null) ||
+                    (value == null && getValue != null) ||
+                    !key1.equals(e.getKey1()) ||
+                    !key2.equals(e.getKey2()) ||
+                    !value.equals(getValue)) {
+                return false;
+            }
+            return true;
+        }
+
+        public int hashCode() {
+            int hash1 = (key1 == null ? 0 : key1.hashCode());
+            int hash2 = (key2 == null ? 0 : key2.hashCode());
+            return (hash1 + hash2) ^ (value == null ? 0 : value.hashCode());
+        }
+        
+    }
+    
+    class EntrySetImpl extends AbstractSet<Map.Entry<String, V>> {
+        public int size() {
+            return size;
+        }
+
+        public void clear() {
+            TwoKeyHashMap.this.clear();
+        }
+
+        public boolean isEmpty() {
+            return size == 0;
+        }
+
+        public boolean contains(Object obj) {
+            if (!(obj instanceof Entry)) {
+                return false;
+            }
+
+            Entry<?, ?, ?> entry = (Entry<?, ?, ?>) obj;
+            Entry<E, K, V> entry2 = findEntry(entry.getKey1(), entry.getKey2());
+            if (entry2 == null) {
+                return false;
+            }
+            Object value = entry.getValue();
+            Object value2 = entry2.getValue();
+            return value == null ? value2 == null : value.equals(value2);
+        }
+
+        public boolean remove(Object obj) {
+            if (!(obj instanceof Entry)) {
+                return false;
+            }
+            return removeEntry(((Entry) obj).getKey1(), ((Entry)obj).getKey2()) != null;
+        }
+
+        public Iterator<Map.Entry<String, V>> iterator() {
+            return createEntrySetIterator();
+        }
+    }
+
+    // Iterates Entries inside the Map
+    class EntryIteratorImpl implements Iterator<Map.Entry<String, V>> {
+        private int startModCount;
+        private boolean found;
+        private int curr = -1;
+        private int returned_index = -1;
+        private Entry<E, K, V> curr_entry;
+        private Entry<E, K, V> returned_entry;
+
+        EntryIteratorImpl() {
+            startModCount = modCount;
+        }
+
+        public boolean hasNext() {
+            if (found) {
+                return true;
+            }
+            if (curr_entry != null) {
+                curr_entry = curr_entry.next;
+            }
+            if (curr_entry == null) {
+                for (curr++; curr < arr.length && arr[curr] == null; curr++) {
+                }
+
+                if (curr < arr.length) {
+                    curr_entry = arr[curr];
+                }
+            }
+            return found = (curr_entry != null);
+        }
+
+        public Map.Entry<String, V> next() {
+            if (modCount != startModCount) {
+                throw new ConcurrentModificationException();
+            }
+            if (!hasNext()) {
+                throw new NoSuchElementException();
+            }
+
+            found = false;
+            returned_index = curr;
+            returned_entry = curr_entry;
+            return (Map.Entry<String, V>)curr_entry;
+        }
+
+        public void remove() {
+            if (returned_index == -1) {
+                throw new IllegalStateException();
+            }
+            
+            if (modCount != startModCount) {
+                throw new ConcurrentModificationException();
+            }
+
+            Entry<E, K, V> p = null;
+            Entry<E, K, V> e = arr[returned_index];
+            while (e != returned_entry) {
+                p = e;
+                e = e.next;
+            }
+            if (p != null) {
+                p.next = returned_entry.next;
+            } else {
+                arr[returned_index] = returned_entry.next;
+            }
+            size--;
+            modCount++;
+            startModCount++;
+            returned_index = -1;
+        }
+    }
+    
+    private final Entry<E, K, V> findEntry(Object key1, Object key2) {
+        if (key1 == null && key2 == null) {
+            return arr[arrSize];
+        }
+
+        int hash = key1.hashCode() + key2.hashCode();
+        int index = (hash & 0x7fffffff) % arrSize;
+        Entry<E, K, V> e = arr[index];
+
+        while (e != null) {
+            if (hash == e.hash && key1.equals(e.getKey1()) && key2.equals(e.getKey2()))
{
+                return e;
+            }
+            e = e.next;
+        }
+        return null;
+    }
+    
+    // Removes entry
+    private final Entry<E, K, V> removeEntry(Object key1, Object key2) {
+        if (key1 == null && key2 == null) {
+            int index = arrSize;
+            if (arr[index] != null) {
+                Entry<E, K, V> ret = arr[index];
+                arr[index] = null;
+                size--;
+                modCount++;
+                return ret;
+            }
+            return null;
+        }
+
+        int hash = key1.hashCode() + key2.hashCode();
+        int index = (hash & 0x7fffffff) % arrSize;
+
+        Entry<E, K, V> e = arr[index];
+        Entry<E, K, V> prev = e;
+        while (e != null) {
+            if (hash == e.hash && key1.equals(e.getKey1()) && key2.equals(e.getKey2()))
{
+                if (prev == e) {
+                    arr[index] = e.next;
+                } else {
+                    prev.next = e.next;
+                }
+                size--;
+                modCount++;
+                return e;
+            }
+
+            prev = e;
+            e = e.next;
+        }
+        return null;
+    }
+
+    /**
+     * An instance is returned by the values() call.
+     */
+    class ValuesCollectionImpl extends AbstractCollection<V> {
+        public int size() {
+            return size;
+        }
+
+        public void clear() {
+            TwoKeyHashMap.this.clear();
+        }
+
+        public boolean isEmpty() {
+            return size == 0;
+        }
+
+        public Iterator<V> iterator() {
+            return createValueCollectionIterator();
+        }
+        
+        public boolean contains(Object obj) {
+            return containsValue(obj);
+        }
+    }
+    
+    class ValueIteratorImpl implements Iterator<V> {
+        private EntryIteratorImpl itr;
+
+        ValueIteratorImpl() {
+            super();
+            this.itr = new EntryIteratorImpl();
+        }
+
+        public V next() {
+            return itr.next().getValue();
+        }
+
+        public void remove() {
+            itr.remove();
+        }
+
+        public boolean hasNext() {
+            return itr.hasNext();
+        }
+    }
+}



Mime
View raw message