FEATURE REQUEST: use type literal for primitive StoredMap creation

Question

Mark, hello;
I suggest to incorporate into api classes like shown below to avoid boiler plate with primitive bindings;
the idea is to use TypeLiteral approach:
http://google-guice.googlecode.com/svn/trunk/javadoc/com/google/inject/TypeLiteral.html
so you can instantiate like this:
// note the tail
          PrimitiveStoredMap<String, Integer> map = new PrimitiveStoredMap<String, Integer>(database) {};
thank you;
Andrei.
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.Map;
import com.sleepycat.bind.EntryBinding;
import com.sleepycat.bind.tuple.BooleanBinding;
import com.sleepycat.bind.tuple.ByteBinding;
import com.sleepycat.bind.tuple.CharacterBinding;
import com.sleepycat.bind.tuple.DoubleBinding;
import com.sleepycat.bind.tuple.FloatBinding;
import com.sleepycat.bind.tuple.IntegerBinding;
import com.sleepycat.bind.tuple.LongBinding;
import com.sleepycat.bind.tuple.ShortBinding;
import com.sleepycat.bind.tuple.StringBinding;
import com.sleepycat.bind.tuple.TupleBinding;
import com.sleepycat.collections.StoredMap;
import com.sleepycat.je.Database;
public abstract class PrimitiveStoredMap<K, V> extends
          ConcurrentMapAdapter<K, V> {
     private static final Map<Class<?>, TupleBinding<?>> primitives = new HashMap<Class<?>, TupleBinding<?>>();
     static {
          addPrimitive(String.class, String.class, new StringBinding());
          addPrimitive(Character.class, Character.TYPE, new CharacterBinding());
          addPrimitive(Boolean.class, Boolean.TYPE, new BooleanBinding());
          addPrimitive(Byte.class, Byte.TYPE, new ByteBinding());
          addPrimitive(Short.class, Short.TYPE, new ShortBinding());
          addPrimitive(Integer.class, Integer.TYPE, new IntegerBinding());
          addPrimitive(Long.class, Long.TYPE, new LongBinding());
          addPrimitive(Float.class, Float.TYPE, new FloatBinding());
          addPrimitive(Double.class, Double.TYPE, new DoubleBinding());
     private static void addPrimitive(Class<?> cls1, Class<?> cls2,
               TupleBinding<?> binding) {
          primitives.put(cls1, binding);
          primitives.put(cls2, binding);
     @SuppressWarnings("unchecked")
     public PrimitiveStoredMap(Database database) {
          ParameterizedType type = (ParameterizedType) getClass().getGenericSuperclass();
          Type[] typeArgs = type.getActualTypeArguments();
          Class<K> keyClass = (Class<K>) typeArgs[0];
          Class<V> valueClass = (Class<V>) typeArgs[1];
          TupleBinding<K> keyBinding = (TupleBinding<K>) primitives.get(keyClass);
          TupleBinding<V> valueBinding = (TupleBinding<V>) primitives.get(valueClass);
          if (keyBinding == null || valueBinding == null) {
               throw new IllegalArgumentException(
                         "only string or primitive bindings "
                                   + "are supported for keys and values "
                                   + "you are using : (" + keyClass.getSimpleName()
                                   + "," + valueClass.getSimpleName() + ")");
          this.map = makeMap(database, keyBinding, valueBinding, true);
     protected StoredMap<K, V> makeMap(Database database,
               EntryBinding<K> keyBinding, EntryBinding<V> valueBinding,
               boolean isWriteable) {
          return new StoredMap<K, V>(//
                    database, keyBinding, valueBinding, isWriteable);
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentMap;
public class ConcurrentMapAdapter<K, V> implements ConcurrentMap<K, V> {
     protected ConcurrentMap<K, V> map;
     @Override
     public int size() {
          return map.size();
     @Override
     public boolean isEmpty() {
          return map.isEmpty();
     @Override
     public boolean containsKey(Object key) {
          return map.containsKey(key);
     @Override
     public boolean containsValue(Object value) {
          return map.containsValue(value);
     @Override
     public V get(Object key) {
          return map.get(key);
     @Override
     public V put(K key, V value) {
          return map.put(key, value);
     @Override
     public V remove(Object key) {
          return map.remove(key);
     @Override
     public void putAll(Map<? extends K, ? extends V> m) {
          map.putAll(m);
     @Override
     public void clear() {
          map.clear();
     @Override
     public Set<K> keySet() {
          return map.keySet();
     @Override
     public Collection<V> values() {
          return map.values();
     @Override
     public Set<java.util.Map.Entry<K, V>> entrySet() {
          return map.entrySet();
     @Override
     public V putIfAbsent(K key, V value) {
          return map.putIfAbsent(key, value);
     @Override
     public boolean remove(Object key, Object value) {
          return map.remove(key, value);
     @Override
     public boolean replace(K key, V oldValue, V newValue) {
          return map.replace(key, oldValue, newValue);
     @Override
     public V replace(K key, V value) {
          return map.replace(key, value);
Edited by: user8971924 on Mar 26, 2011 7:52 PM

Answer 1

great! thanks for considering this;
still more ideas: add the "byte array primitive":
public class ByteArray {
     private final byte[] array;
     public ByteArray(final byte[] array) {
          this.array = array == null ? new byte[0] : array;
     public byte[] getArray() {
          return array;
     @Override
     public boolean equals(Object other) {
          if (other instanceof ByteArray) {
               ByteArray that = (ByteArray) other;
               return Arrays.equals(this.array, that.array);
          return false;
     private int hashCode;
     @Override
     public int hashCode() {
          if (hashCode == 0) {
               hashCode = Arrays.hashCode(array);
          return hashCode;
     @Override
     public String toString() {
          return Arrays.toString(array);
public class ByteArrayBinding extends TupleBinding<ByteArray> {
     @Override
     public ByteArray entryToObject(TupleInput ti) {
          return new ByteArray(ti.getBufferBytes().clone());
     @Override
     public void objectToEntry(ByteArray array, TupleOutput to) {
          to.write(array.getArray());
public abstract class PrimitiveStoredMap<K, V> extends
          ConcurrentMapAdapter<K, V> {
     private static final Map<Class<?>, TupleBinding<?>> primitives = new HashMap<Class<?>, TupleBinding<?>>();
     static {
          // je
          addPrimitive(String.class, String.class, new StringBinding());
          addPrimitive(Character.class, Character.TYPE, new CharacterBinding());
          addPrimitive(Boolean.class, Boolean.TYPE, new BooleanBinding());
          addPrimitive(Byte.class, Byte.TYPE, new ByteBinding());
          addPrimitive(Short.class, Short.TYPE, new ShortBinding());
          addPrimitive(Integer.class, Integer.TYPE, new IntegerBinding());
          addPrimitive(Long.class, Long.TYPE, new LongBinding());
          addPrimitive(Float.class, Float.TYPE, new FloatBinding());
          addPrimitive(Double.class, Double.TYPE, new DoubleBinding());
          // custom
          addPrimitive(ByteArray.class, ByteArray.class, new ByteArrayBinding());
}