6:03 a.m.
Author: manik.surtani(a)jboss.com
Date: 2009-02-19 07:03:50 -0500 (Thu, 19 Feb 2009)
New Revision: 7727
Modified:
core/branches/flat/src/main/java/org/horizon/container/UnsortedDataContainer.java
core/branches/flat/src/main/java/org/horizon/util/AbstractMap.java
core/branches/flat/src/main/java/org/horizon/util/BidirectionalLinkedHashMap.java
core/branches/flat/src/main/java/org/horizon/util/FastCopyHashMap.java
Log:
Removed support for null keys
Modified:
core/branches/flat/src/main/java/org/horizon/container/UnsortedDataContainer.java
===================================================================
---
core/branches/flat/src/main/java/org/horizon/container/UnsortedDataContainer.java 2009-02-18
17:40:47 UTC (rev 7726)
+++
core/branches/flat/src/main/java/org/horizon/container/UnsortedDataContainer.java 2009-02-19
12:03:50 UTC (rev 7727)
@@ -50,7 +50,6 @@
// stuff, we don't need to iterate through immortal data.
final ConcurrentMap<Object, CachedValue> immortalData = new
ConcurrentHashMap<Object, CachedValue>();
final ConcurrentMap<Object, ExpirableCachedValue> expirableData = new
ConcurrentHashMap<Object, ExpirableCachedValue>();
- private static final Object NULL = new Object();
private CacheLoaderManager clm;
private CacheStore cacheStore;
@@ -75,25 +74,16 @@
}
}
- private Object maskNullKey(Object o) {
- return o == null ? NULL : o;
- }
-
- private Object unmaskNullKey(Object o) {
- return (o == NULL) ? null : o;
- }
-
public Object get(Object k) {
- Object maskedKey = maskNullKey(k);
- CachedValue cv = immortalData.get(maskedKey);
+ CachedValue cv = immortalData.get(k);
if (cv != null) {
cv.touch();
return cv.getValue();
} else {
- ExpirableCachedValue ecv = expirableData.get(maskedKey);
+ ExpirableCachedValue ecv = expirableData.get(k);
if (ecv != null) {
if (ecv.isExpired()) {
- expire(maskedKey);
+ expire(k);
} else {
ecv.touch();
return ecv.getValue();
@@ -105,9 +95,7 @@
}
public void put(Object k, Object v, long lifespan) {
- Object maskedKey = maskNullKey(k);
-
- CachedValue cv = immortalData.get(maskedKey);
+ CachedValue cv = immortalData.get(k);
ExpirableCachedValue ecv;
if (cv != null) {
// do we need to move this to expirable?
@@ -117,16 +105,16 @@
cv.touch();
} else {
ecv = new ExpirableCachedValue(v, lifespan);
- immortalData.remove(maskedKey);
- expirableData.put(maskedKey, ecv);
+ immortalData.remove(k);
+ expirableData.put(k, ecv);
}
- } else if ((ecv = expirableData.get(maskedKey)) != null) {
+ } else if ((ecv = expirableData.get(k)) != null) {
// do we need to move this to immortal?
if (lifespan < 0) {
// yes.
cv = new CachedValue(v);
- expirableData.remove(maskedKey);
- immortalData.put(maskedKey, cv);
+ expirableData.remove(k);
+ immortalData.put(k, cv);
} else {
ecv.setValue(v);
ecv.touch();
@@ -135,21 +123,20 @@
// does not exist anywhere!
if (lifespan < 0) {
cv = new CachedValue(v);
- immortalData.put(maskedKey, cv);
+ immortalData.put(k, cv);
} else {
ecv = new ExpirableCachedValue(v, lifespan);
- expirableData.put(maskedKey, ecv);
+ expirableData.put(k, ecv);
}
}
}
public boolean containsKey(Object k) {
- Object maskedKey = maskNullKey(k);
- if (!immortalData.containsKey(maskedKey)) {
- ExpirableCachedValue ecv = expirableData.get(maskedKey);
+ if (!immortalData.containsKey(k)) {
+ ExpirableCachedValue ecv = expirableData.get(k);
if (ecv == null) return false;
if (ecv.isExpired()) {
- expire(maskedKey);
+ expire(k);
return false;
}
}
@@ -157,16 +144,14 @@
}
public long getModifiedTimestamp(Object key) {
- Object maskedKey = maskNullKey(key);
- CachedValue cv = immortalData.get(maskedKey);
- if (cv == null) cv = expirableData.get(maskedKey);
+ CachedValue cv = immortalData.get(key);
+ if (cv == null) cv = expirableData.get(key);
return cv == null ? -1 : cv.getModifiedTime();
}
public Object remove(Object k) {
- Object maskedKey = maskNullKey(k);
- CachedValue cv = immortalData.remove(maskedKey);
- if (cv == null) cv = expirableData.remove(maskedKey);
+ CachedValue cv = immortalData.remove(k);
+ if (cv == null) cv = expirableData.remove(k);
if (cv == null) {
return null;
@@ -238,8 +223,7 @@
}
public boolean contains(Object o) {
- Object maskedKey = maskNullKey((Object) o);
- return immortalKeys.contains(maskedKey) || expirableKeys.contains(maskedKey);
+ return immortalKeys.contains(o) || expirableKeys.contains(o);
}
public boolean remove(Object o) {
@@ -277,7 +261,7 @@
@SuppressWarnings("unchecked")
public Object next() {
- return unmaskNullKey(currentIterator.next());
+ return currentIterator.next();
}
public void remove() {
Modified: core/branches/flat/src/main/java/org/horizon/util/AbstractMap.java
===================================================================
--- core/branches/flat/src/main/java/org/horizon/util/AbstractMap.java 2009-02-18 17:40:47
UTC (rev 7726)
+++ core/branches/flat/src/main/java/org/horizon/util/AbstractMap.java 2009-02-19 12:03:50
UTC (rev 7727)
@@ -5,18 +5,13 @@
import java.util.Set;
/**
- * Similar to the JDK's AbstractMap, this provides common functionality for custom
map implementations.
+ * Similar to the JDK's AbstractMap, this provides common functionality for custom
map implementations. Unlike JDK's
+ * AbstractMap, there is no support for null keys.
*
* @author Manik Surtani
* @since 1.0
*/
public abstract class AbstractMap<K, V> implements Map<K, V> {
-
- /**
- * Marks null keys.
- */
- private static final Object NULL = new Object();
-
// views
protected transient Set<Map.Entry<K, V>> entrySet = null;
protected transient Set<K> keySet = null;
@@ -30,19 +25,13 @@
return h ^ (h >>> 7) ^ (h >>> 4);
}
- @SuppressWarnings("unchecked")
- protected static final <K> K maskNull(K key) {
- return key == null ? (K) NULL : key;
- }
-
- protected static final <K> K unmaskNull(K key) {
- return key == NULL ? null : key;
- }
-
protected static final boolean eq(Object o1, Object o2) {
return o1 == o2 || (o1 != null && o1.equals(o2));
}
+ protected final void assertKeyNotNull(Object key) {
+ if (key == null) throw new NullPointerException("Null keys are not
supported!");
+ }
protected static class SimpleEntry<K, V> implements Map.Entry<K, V> {
private K key;
Modified:
core/branches/flat/src/main/java/org/horizon/util/BidirectionalLinkedHashMap.java
===================================================================
---
core/branches/flat/src/main/java/org/horizon/util/BidirectionalLinkedHashMap.java 2009-02-18
17:40:47 UTC (rev 7726)
+++
core/branches/flat/src/main/java/org/horizon/util/BidirectionalLinkedHashMap.java 2009-02-19
12:03:50 UTC (rev 7727)
@@ -9,9 +9,18 @@
import java.util.NoSuchElementException;
/**
- * // TODO javadocs
+ * Similar to the JDK's {@link java.util.LinkedHashMap} except that this version
makes use of the fact that entries are
+ * bidirectionally linked and can hence be nagigated either from the start
<i>or</i> from the end. It exposes such
+ * navigability by overriding {@link java.util.Map#keySet()} and {@link
java.util.Map#entrySet()} to return {@link
+ * org.horizon.util.ReversibleSet} rather than a standard JDK {@link java.util.Set}.
{@link
+ * org.horizon.util.ReversibleSet}s allow you to access 2 iterators: one that iterates
from start to end, as usual, and
+ * a reversed one that iterates from end to start instead.
+ * <p/>
+ * Unline the JDK {@link java.util.LinkedHashMap}, this implementation does not support
null keys.
+ * <p/>
*
* @author Manik Surtani
+ * @since 1.0
*/
public class BidirectionalLinkedHashMap<K, V> extends AbstractMap<K, V> {
@@ -221,8 +230,7 @@
* with <tt>key</tt>.)
*/
public V put(K key, V value) {
- if (key == null)
- return putForNullKey(value);
+ assertKeyNotNull(key);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (LinkedEntry<K, V> e = table[i]; e != null; e = e.next) {
@@ -241,23 +249,6 @@
}
/**
- * Offloaded version of put for null keys
- */
- private V putForNullKey(V value) {
- for (LinkedEntry<K, V> e = table[0]; e != null; e = e.next) {
- if (e.key == null) {
- V oldValue = e.value;
- e.value = value;
- e.recordAccess(this);
- return oldValue;
- }
- }
- modCount++;
- addEntry(0, null, value, 0);
- return null;
- }
-
- /**
* This method is used instead of put by constructors and pseudoconstructors (clone,
readObject). It does not resize
* the table, check for comodification, etc. It calls createEntry rather than
addEntry.
*/
@@ -360,6 +351,7 @@
* with <tt>key</tt>.)
*/
public V remove(Object key) {
+ assertKeyNotNull(key);
LinkedEntry<K, V> e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
@@ -369,7 +361,7 @@
* contains no mapping for this key.
*/
final LinkedEntry<K, V> removeEntryForKey(Object key) {
- int hash = (key == null) ? 0 : hash(key.hashCode());
+ int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
LinkedEntry<K, V> prev = table[i];
LinkedEntry<K, V> e = prev;
@@ -598,6 +590,7 @@
* operation may be used to distinguish these two cases.
*/
public V get(Object key) {
+ assertKeyNotNull(key);
LinkedEntry<K, V> e = getEntry(key);
if (e == null)
return null;
Modified: core/branches/flat/src/main/java/org/horizon/util/FastCopyHashMap.java
===================================================================
--- core/branches/flat/src/main/java/org/horizon/util/FastCopyHashMap.java 2009-02-18
17:40:47 UTC (rev 7726)
+++ core/branches/flat/src/main/java/org/horizon/util/FastCopyHashMap.java 2009-02-19
12:03:50 UTC (rev 7727)
@@ -34,6 +34,8 @@
/**
* A HashMap that is optimized for fast shallow copies.
+ * <p/>
+ * Null keys are <i>not</i> supported.
*
* @author Jason T. Greene
* @since 1.0
@@ -149,8 +151,7 @@
}
public V get(Object key) {
- key = maskNull(key);
-
+ assertKeyNotNull(key);
int hash = hash(key);
int length = table.length;
int index = index(hash, length);
@@ -168,8 +169,7 @@
}
public boolean containsKey(Object key) {
- key = maskNull(key);
-
+ assertKeyNotNull(key);
int hash = hash(key);
int length = table.length;
int index = index(hash, length);
@@ -195,8 +195,7 @@
}
public V put(K key, V value) {
- key = maskNull(key);
-
+ assertKeyNotNull(key);
Entry<K, V>[] table = this.table;
int hash = hash(key);
int length = table.length;
@@ -274,8 +273,7 @@
}
public V remove(Object key) {
- key = maskNull(key);
-
+ assertKeyNotNull(key);
Entry<K, V>[] table = this.table;
int length = table.length;
int hash = hash(key);
@@ -398,8 +396,6 @@
@SuppressWarnings("unchecked")
private void putForCreate(K key, V value) {
- key = maskNull(key);
-
Entry<K, V>[] table = this.table;
int hash = hash(key);
int length = table.length;
@@ -420,7 +416,7 @@
for (Entry<K, V> e : table) {
if (e != null) {
- s.writeObject(unmaskNull(e.key));
+ s.writeObject(e.key);
s.writeObject(e.value);
}
}
@@ -527,7 +523,7 @@
private class KeyIterator extends FasyCopyHashMapIterator<K> {
public K next() {
- return unmaskNull(nextEntry().key);
+ return nextEntry().key;
}
}
@@ -553,7 +549,7 @@
public Map.Entry<K, V> next() {
Entry<K, V> e = nextEntry();
- return new WriteThroughEntry(unmaskNull(e.key), e.value);
+ return new WriteThroughEntry(e.key, e.value);
}
}