diff options
author | Mitsuru Oshima <oshima@google.com> | 2009-06-10 16:16:02 -0700 |
---|---|---|
committer | Mitsuru Oshima <oshima@google.com> | 2009-06-10 16:16:02 -0700 |
commit | 7e013cacd45f33d8af87842d3cc2eb1479eaad6b (patch) | |
tree | 1f1a5ba1039a0ab62dac27735c0ecc23dc11d9c5 /src/com/google/common/io/protocol/IntMap.java | |
parent | babfb77851cabbf713f91dcee2836f46628dcff4 (diff) | |
download | protobuf-7e013cacd45f33d8af87842d3cc2eb1479eaad6b.tar.gz protobuf-7e013cacd45f33d8af87842d3cc2eb1479eaad6b.tar.bz2 protobuf-7e013cacd45f33d8af87842d3cc2eb1479eaad6b.zip |
Revert "ProtoBuf update"
This reverts commit 9aaf507646c866ab131bf2bcd973882ff9f553cf.
Diffstat (limited to 'src/com/google/common/io/protocol/IntMap.java')
-rw-r--r-- | src/com/google/common/io/protocol/IntMap.java | 383 |
1 files changed, 0 insertions, 383 deletions
diff --git a/src/com/google/common/io/protocol/IntMap.java b/src/com/google/common/io/protocol/IntMap.java deleted file mode 100644 index 9f0b8fc3..00000000 --- a/src/com/google/common/io/protocol/IntMap.java +++ /dev/null @@ -1,383 +0,0 @@ -// Copyright 2009 Google Inc. All Rights Reserved. - -package com.google.common.io.protocol; - -import java.util.Enumeration; -import java.util.Hashtable; -import java.util.NoSuchElementException; - -/** - * A Map from primitive integers to Object values. This stores values - * for smaller keys in an Object array, and uses {@link Hashtable} - * only for larger keys. This is specifically designed to be used by - * J2me protocol buffer runtime ({@link ProtoBuf}, {@link ProtoBufType}) - * to support large tags that are commonly used in Extensions/MessageSet. - * - * This class is not thread safe, so the client has to provide - * appropriate locking mechanism if the map is to be used from - * multiple threads. - */ -public class IntMap { - private static final int MAX_LOWER_BUFFER_SIZE = 64; - private static final int INITIAL_LOWER_BUFFER_SIZE = 8; - - /** - * An iterator that returns int keys of the IntMap. IntMap has its - * own Iterator instead of Enumeration to avoid autoboxing. This - * uses the same buffer of the IntMap, so you should not update the - * IntMap while the iterator is in use. Once the IntMap is changed, - * the behavior of preiously obtained iterator is undefined, and a new - * KeyIterator has to be used instead. - */ - public class KeyIterator { - private int oneAheadIndex = 0; - private int currentKey = Integer.MIN_VALUE; - private Enumeration higherKeyEnumerator = null; - - /** - * @returns true if there is more keys. - */ - public boolean hasNext() { - if (currentKey != Integer.MIN_VALUE) { - return true; - } - if (oneAheadIndex <= maxLowerKey) { - for (; oneAheadIndex <= maxLowerKey; oneAheadIndex++) { - if (lower[oneAheadIndex] != null) { - // record the key, then increment the oneAheadIndex. - currentKey = oneAheadIndex++; - return true; - } - } - } - if (higher != null) { - if (higherKeyEnumerator == null) { - higherKeyEnumerator = higher.keys(); - } - if (higherKeyEnumerator.hasMoreElements()) { - Integer key = (Integer) higherKeyEnumerator.nextElement(); - currentKey = key.intValue(); - return true; - } - } - return false; - } - - /** - * @returns next key - * @throws NoSuchElementException if there is no more keys. - */ - public int next() { - if (currentKey == Integer.MIN_VALUE && !hasNext()) { - throw new NoSuchElementException(); - } - int key = currentKey; - currentKey = Integer.MIN_VALUE; - return key; - } - } - - /** Stores values for lower keys */ - private Object[] lower; - - /** Hashtable for higher tags */ - private Hashtable higher; - - /** A maximum key that has been ever added to the lower buffer.*/ - private int maxLowerKey; - - /** A maximum key that has been ever added to the map.*/ - private int maxKey; - - /** the number of elements in lower buffer */ - private int lowerCount; - - /** - * Constructs an {@link IntMap} with default lower buffer size. - */ - public IntMap() { - this(INITIAL_LOWER_BUFFER_SIZE); // can expand 3 times - } - - /** - * Constructs an {@link IntMap} with the suggested initial lower buffer size. - * The argument is just a hint and may not be used. If its value is - * larger than {@link MAX_LOWER_BUFFER_SIZE} or negative, it will use the - * MAX_LOWER_BUFFER_SIZE instead. - */ - IntMap(int initialLowerBufferSize) { - int lowerBufferSize = INITIAL_LOWER_BUFFER_SIZE; - if (initialLowerBufferSize > 0) { - lowerBufferSize = Math.min(initialLowerBufferSize, MAX_LOWER_BUFFER_SIZE); - } - lower = new Object[lowerBufferSize]; - lowerCount = 0; - maxKey = Integer.MIN_VALUE; - maxLowerKey = Integer.MIN_VALUE; - } - - /** - * A factory method to constructs an {@link IntMap} with the same - * lower buffer size. - * - * @return a new IntMap whose lower buffer size is same as - * this instance. - */ - public IntMap newIntMapWithSameBufferSize() { - return new IntMap(maxLowerKey); - } - - /** - * @return the {@link KeyIterator} of the map. - */ - public KeyIterator keys() { - return new KeyIterator(); - } - - /** - * Returns max key that ever added to the map. Note that this is not - * max for current state. Removing the max key will not update the - * max key value. If nothing is added, it will return {@link - * Integer.MIN_VALUE}, which means you cannot tell if an value is - * added with MIN_VALUE key. - */ - public int maxKey() { - return maxKey; - } - - /** - * Returns the number of key-value pairs in the map. - */ - public int size() { - return higher == null ? lowerCount : lowerCount + higher.size(); - } - - /** - * @return true if the map is empty. - */ - public boolean isEmpty() { - return size() == 0; - } - - /** - * Clears all key/value pairs. The map becomes empty after this - * operation, but does not release memory. - */ - public void clear() { - for (int i = 0; i < lower.length; i++) { - lower[i] = null; - } - if (higher != null) higher.clear(); - maxKey = Integer.MIN_VALUE; - maxLowerKey = Integer.MIN_VALUE; - lowerCount = 0; - } - - /** - * Returns the value associated with the given key. - * - * @param key a key - * @return the value associated with the given key. null if the map has - * no value for the key. - */ - public Object get(int key) { - if (key > maxKey) { - return null; - } else if (0 <= key && key <= maxLowerKey) { - return lower[key]; - } else if (higher != null) { - return higher.get(key); - } else { - return null; - } - } - - /** - * Maps the specified key to the given value in the {@link IntMap}. - * Caveat: Passing null value removes the value from the map. This is to - * keep the semantics used in {@link ProtoBuf}. - * - * @param key a key - * @param value the value to be added to the Map. If this is null, - * the key will be removed from the map. This method does nothing if - * the key does not exist and value is null. - */ - public void put(int key, Object value) { - if (value == null) { - remove(key); - return; - } - expandLowerIfNecessary(key); - maxKey = Math.max(key, maxKey); - if (0 <= key && key < lower.length) { - maxLowerKey = Math.max(key, maxLowerKey); - if (lower[key] == null) { - lowerCount++; - } - lower[key] = value; - } else { - if (higher == null) { - higher = new Hashtable(); - } - higher.put(key, value); - } - } - - /** - * Removes the key and corresponding value from the {@link IntMap}. - * - * @param key the key to remove. This method does nothing if the map does not - * have the value corresponding for the key. - * @return the removed value. null if the map does not have the value for - * the key. - */ - public Object remove(int key) { - Object deleted = null; - if (0 <= key && key < lower.length) { - deleted = lower[key]; - if (deleted != null) { - lowerCount--; - } - lower[key] = null; - } else if (higher != null) { - return higher.remove(key); - } - return deleted; - } - - /** - * Tests if given key has a corresponding value in this {@link IntMap}. - * - * @param key possible key. - * @return <code>true</code> if the given key has the correspoding - * value. <code>false</code> otherwise. - */ - public boolean containsKey(int key) { - if (0 <= key && key < lower.length) { - return lower[key] != null; - } else if (higher != null) { - return higher.containsKey(key); - } - return false; - } - - /** - * Returns hashcode for {@link IntMap}. - */ - public int hashCode() { - int hashCode = 1; - for (int i = 0; i < lower.length ; i++) { - Object value = lower[i]; - if (value != null) { - hashCode = 31 * hashCode + value.hashCode() + i; - } - } - // Hashtable in J2me does not implement hashCode(), so we simply - // use the size of hashtable. - return higher == null ? hashCode : hashCode + higher.size(); - } - - /** - * Compares the equality. Two IntMaps are considered equals iff - * both map have the same key-value pairs. - * Caveat: This assumes that the Class of each value object implements - * equals correctly. This may not be the case in J2me. - * - * @param object an object to be compared with - * @return true if the specified Object is equal to this IntMap - */ - public boolean equals(Object object) { - if (this == object) { - return true; - } - if (object == null || !(object instanceof IntMap)) { - return false; - } - IntMap peer = (IntMap) object; - if (size() != peer.size()) { - return false; - } - return compareLowerBuffer(lower, peer.lower) && - compareHashtable(higher, peer.higher); - } - - private boolean compareLowerBuffer(Object[] lower1, Object[] lower2) { - int min = Math.min(lower1.length, lower2.length); - - for (int i = 0; i < min; i++) { - if ((lower1[i] == null && lower2[i] != null) || - (lower1[i] != null && !lower1[i].equals(lower2[i]))) { - return false; - } - } - // make sure there are no values in remaining fields. - if (lower1.length > lower2.length) { - for (int i = min; i < lower1.length; i++) { - if (lower1[i] != null) return false; - } - } else if (lower1.length < lower2.length) { - for (int i = min; i < lower2.length; i++) { - if (lower2[i] != null) return false; - } - } - return true; - } - - /** - * J2me's Hashtable does not implement equal, Bummer! - */ - private static boolean compareHashtable(Hashtable h1, Hashtable h2) { - if (h1 == h2) { // null == null is caught here - return true; - } - if (h1 == null || h2 == null) { - return false; - } - if (h1.size() != h2.size()) { - return false; - } - // Ensure the values are the same. - Enumeration h1Keys = h1.keys(); - while (h1Keys.hasMoreElements()) { - Object key = h1Keys.nextElement(); - Object h1Value = h1.get(key); - Object h2Value = h2.get(key); - if (!h1Value.equals(h2Value)) { - return false; - } - } - return true; - } - - /** - * Expands lower buffer iff the key does not fit to current buffer size, - * but will fit in MAX buffer size. - */ - private void expandLowerIfNecessary(int key) { - if (key <= MAX_LOWER_BUFFER_SIZE && key >= lower.length && key > 0) { - int size = lower.length; - do { - size <<= 1; - } while (size <= key); - size = Math.min(size, MAX_LOWER_BUFFER_SIZE); - Object[] newLower = new Object[size]; - System.arraycopy(lower, 0, newLower, 0, lower.length); - lower = newLower; - } - } - - /* {@inheritDoc} */ - public String toString() { - StringBuffer buffer = new StringBuffer("IntMap{lower:"); - for (int i = 0; i < lower.length; i++) { - if (lower[i] != null) { - buffer.append(i); - buffer.append("=>"); - buffer.append(lower[i]); - buffer.append(", "); - } - } - buffer.append(", higher:" + higher + "}"); - return buffer.toString(); - } -} |