1 files changed, 0 insertions, 566 deletions
diff --git a/luni/src/main/java/org/apache/harmony/luni/util/TwoKeyHashMap.java b/luni/src/main/java/org/apache/harmony/luni/util/TwoKeyHashMap.java
deleted file mode 100644
index 35e6c62..0000000
--- a/luni/src/main/java/org/apache/harmony/luni/util/TwoKeyHashMap.java
+++ /dev/null
@@ -1,566 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You 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.luni.util;
-
-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 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
-     */
-    @SuppressWarnings("unchecked")
-    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 (e != null) ? 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, null, null, 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
-     *
-     */
-    @SuppressWarnings("unchecked")
-    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 {@code key1} and {@code key2}.
-     */
-    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() {
-            this.itr = new EntryIteratorImpl();
-        }
-
-        public V next() {
-            return itr.next().getValue();
-        }
-
-        public void remove() {
-            itr.remove();
-        }
-
-        public boolean hasNext() {
-            return itr.hasNext();
-        }
-    }
-}