Overview  Package  Class  Tree   Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES    

Deprecated API

Contents
Deprecated Methods
net.openhft.collect.ByteCollection.add(Byte)
          Use specialization ByteCollection.add(byte) instead 
net.openhft.collect.set.ByteSet.add(Byte)
           
net.openhft.collect.CharCollection.add(Character)
          Use specialization CharCollection.add(char) instead 
net.openhft.collect.set.CharSet.add(Character)
           
net.openhft.collect.DoubleCollection.add(Double)
          Use specialization DoubleCollection.add(double) instead 
net.openhft.collect.set.DoubleSet.add(Double)
           
net.openhft.collect.FloatCollection.add(Float)
          Use specialization FloatCollection.add(float) instead 
net.openhft.collect.set.FloatSet.add(Float)
           
net.openhft.collect.IntCollection.add(Integer)
          Use specialization IntCollection.add(int) instead 
net.openhft.collect.set.IntSet.add(Integer)
           
net.openhft.collect.LongCollection.add(Long)
          Use specialization LongCollection.add(long) instead 
net.openhft.collect.set.LongSet.add(Long)
           
net.openhft.collect.ShortCollection.add(Short)
          Use specialization ShortCollection.add(short) instead 
net.openhft.collect.set.ShortSet.add(Short)
           
net.openhft.collect.ByteCollection.contains(Object)
          Use specialization ByteCollection.contains(byte) instead 
net.openhft.collect.CharCollection.contains(Object)
          Use specialization CharCollection.contains(char) instead 
net.openhft.collect.DoubleCollection.contains(Object)
          Use specialization DoubleCollection.contains(double) instead 
net.openhft.collect.FloatCollection.contains(Object)
          Use specialization FloatCollection.contains(float) instead 
net.openhft.collect.IntCollection.contains(Object)
          Use specialization IntCollection.contains(int) instead 
net.openhft.collect.LongCollection.contains(Object)
          Use specialization LongCollection.contains(long) instead 
net.openhft.collect.ShortCollection.contains(Object)
          Use specialization ShortCollection.contains(short) instead 
net.openhft.collect.map.ByteByteMap.containsKey(Object)
          Use specialization ByteByteMap.containsKey(byte) instead 
net.openhft.collect.map.ByteCharMap.containsKey(Object)
          Use specialization ByteCharMap.containsKey(byte) instead 
net.openhft.collect.map.ByteDoubleMap.containsKey(Object)
          Use specialization ByteDoubleMap.containsKey(byte) instead 
net.openhft.collect.map.ByteFloatMap.containsKey(Object)
          Use specialization ByteFloatMap.containsKey(byte) instead 
net.openhft.collect.map.ByteIntMap.containsKey(Object)
          Use specialization ByteIntMap.containsKey(byte) instead 
net.openhft.collect.map.ByteLongMap.containsKey(Object)
          Use specialization ByteLongMap.containsKey(byte) instead 
net.openhft.collect.map.ByteObjMap.containsKey(Object)
          Use specialization ByteObjMap.containsKey(byte) instead 
net.openhft.collect.map.ByteShortMap.containsKey(Object)
          Use specialization ByteShortMap.containsKey(byte) instead 
net.openhft.collect.map.CharByteMap.containsKey(Object)
          Use specialization CharByteMap.containsKey(char) instead 
net.openhft.collect.map.CharCharMap.containsKey(Object)
          Use specialization CharCharMap.containsKey(char) instead 
net.openhft.collect.map.CharDoubleMap.containsKey(Object)
          Use specialization CharDoubleMap.containsKey(char) instead 
net.openhft.collect.map.CharFloatMap.containsKey(Object)
          Use specialization CharFloatMap.containsKey(char) instead 
net.openhft.collect.map.CharIntMap.containsKey(Object)
          Use specialization CharIntMap.containsKey(char) instead 
net.openhft.collect.map.CharLongMap.containsKey(Object)
          Use specialization CharLongMap.containsKey(char) instead 
net.openhft.collect.map.CharObjMap.containsKey(Object)
          Use specialization CharObjMap.containsKey(char) instead 
net.openhft.collect.map.CharShortMap.containsKey(Object)
          Use specialization CharShortMap.containsKey(char) instead 
net.openhft.collect.map.DoubleByteMap.containsKey(Object)
          Use specialization DoubleByteMap.containsKey(double) instead 
net.openhft.collect.map.DoubleCharMap.containsKey(Object)
          Use specialization DoubleCharMap.containsKey(double) instead 
net.openhft.collect.map.DoubleDoubleMap.containsKey(Object)
          Use specialization DoubleDoubleMap.containsKey(double) instead 
net.openhft.collect.map.DoubleFloatMap.containsKey(Object)
          Use specialization DoubleFloatMap.containsKey(double) instead 
net.openhft.collect.map.DoubleIntMap.containsKey(Object)
          Use specialization DoubleIntMap.containsKey(double) instead 
net.openhft.collect.map.DoubleLongMap.containsKey(Object)
          Use specialization DoubleLongMap.containsKey(double) instead 
net.openhft.collect.map.DoubleObjMap.containsKey(Object)
          Use specialization DoubleObjMap.containsKey(double) instead 
net.openhft.collect.map.DoubleShortMap.containsKey(Object)
          Use specialization DoubleShortMap.containsKey(double) instead 
net.openhft.collect.map.FloatByteMap.containsKey(Object)
          Use specialization FloatByteMap.containsKey(float) instead 
net.openhft.collect.map.FloatCharMap.containsKey(Object)
          Use specialization FloatCharMap.containsKey(float) instead 
net.openhft.collect.map.FloatDoubleMap.containsKey(Object)
          Use specialization FloatDoubleMap.containsKey(float) instead 
net.openhft.collect.map.FloatFloatMap.containsKey(Object)
          Use specialization FloatFloatMap.containsKey(float) instead 
net.openhft.collect.map.FloatIntMap.containsKey(Object)
          Use specialization FloatIntMap.containsKey(float) instead 
net.openhft.collect.map.FloatLongMap.containsKey(Object)
          Use specialization FloatLongMap.containsKey(float) instead 
net.openhft.collect.map.FloatObjMap.containsKey(Object)
          Use specialization FloatObjMap.containsKey(float) instead 
net.openhft.collect.map.FloatShortMap.containsKey(Object)
          Use specialization FloatShortMap.containsKey(float) instead 
net.openhft.collect.map.IntByteMap.containsKey(Object)
          Use specialization IntByteMap.containsKey(int) instead 
net.openhft.collect.map.IntCharMap.containsKey(Object)
          Use specialization IntCharMap.containsKey(int) instead 
net.openhft.collect.map.IntDoubleMap.containsKey(Object)
          Use specialization IntDoubleMap.containsKey(int) instead 
net.openhft.collect.map.IntFloatMap.containsKey(Object)
          Use specialization IntFloatMap.containsKey(int) instead 
net.openhft.collect.map.IntIntMap.containsKey(Object)
          Use specialization IntIntMap.containsKey(int) instead 
net.openhft.collect.map.IntLongMap.containsKey(Object)
          Use specialization IntLongMap.containsKey(int) instead 
net.openhft.collect.map.IntObjMap.containsKey(Object)
          Use specialization IntObjMap.containsKey(int) instead 
net.openhft.collect.map.IntShortMap.containsKey(Object)
          Use specialization IntShortMap.containsKey(int) instead 
net.openhft.collect.map.LongByteMap.containsKey(Object)
          Use specialization LongByteMap.containsKey(long) instead 
net.openhft.collect.map.LongCharMap.containsKey(Object)
          Use specialization LongCharMap.containsKey(long) instead 
net.openhft.collect.map.LongDoubleMap.containsKey(Object)
          Use specialization LongDoubleMap.containsKey(long) instead 
net.openhft.collect.map.LongFloatMap.containsKey(Object)
          Use specialization LongFloatMap.containsKey(long) instead 
net.openhft.collect.map.LongIntMap.containsKey(Object)
          Use specialization LongIntMap.containsKey(long) instead 
net.openhft.collect.map.LongLongMap.containsKey(Object)
          Use specialization LongLongMap.containsKey(long) instead 
net.openhft.collect.map.LongObjMap.containsKey(Object)
          Use specialization LongObjMap.containsKey(long) instead 
net.openhft.collect.map.LongShortMap.containsKey(Object)
          Use specialization LongShortMap.containsKey(long) instead 
net.openhft.collect.map.ShortByteMap.containsKey(Object)
          Use specialization ShortByteMap.containsKey(short) instead 
net.openhft.collect.map.ShortCharMap.containsKey(Object)
          Use specialization ShortCharMap.containsKey(short) instead 
net.openhft.collect.map.ShortDoubleMap.containsKey(Object)
          Use specialization ShortDoubleMap.containsKey(short) instead 
net.openhft.collect.map.ShortFloatMap.containsKey(Object)
          Use specialization ShortFloatMap.containsKey(short) instead 
net.openhft.collect.map.ShortIntMap.containsKey(Object)
          Use specialization ShortIntMap.containsKey(short) instead 
net.openhft.collect.map.ShortLongMap.containsKey(Object)
          Use specialization ShortLongMap.containsKey(short) instead 
net.openhft.collect.map.ShortObjMap.containsKey(Object)
          Use specialization ShortObjMap.containsKey(short) instead 
net.openhft.collect.map.ShortShortMap.containsKey(Object)
          Use specialization ShortShortMap.containsKey(short) instead 
net.openhft.collect.map.ByteByteMap.containsValue(Object)
          Use specialization ByteByteMap.containsValue(byte) instead 
net.openhft.collect.map.ByteCharMap.containsValue(Object)
          Use specialization ByteCharMap.containsValue(char) instead 
net.openhft.collect.map.ByteDoubleMap.containsValue(Object)
          Use specialization ByteDoubleMap.containsValue(double) instead 
net.openhft.collect.map.ByteFloatMap.containsValue(Object)
          Use specialization ByteFloatMap.containsValue(float) instead 
net.openhft.collect.map.ByteIntMap.containsValue(Object)
          Use specialization ByteIntMap.containsValue(int) instead 
net.openhft.collect.map.ByteLongMap.containsValue(Object)
          Use specialization ByteLongMap.containsValue(long) instead 
net.openhft.collect.map.ByteShortMap.containsValue(Object)
          Use specialization ByteShortMap.containsValue(short) instead 
net.openhft.collect.map.CharByteMap.containsValue(Object)
          Use specialization CharByteMap.containsValue(byte) instead 
net.openhft.collect.map.CharCharMap.containsValue(Object)
          Use specialization CharCharMap.containsValue(char) instead 
net.openhft.collect.map.CharDoubleMap.containsValue(Object)
          Use specialization CharDoubleMap.containsValue(double) instead 
net.openhft.collect.map.CharFloatMap.containsValue(Object)
          Use specialization CharFloatMap.containsValue(float) instead 
net.openhft.collect.map.CharIntMap.containsValue(Object)
          Use specialization CharIntMap.containsValue(int) instead 
net.openhft.collect.map.CharLongMap.containsValue(Object)
          Use specialization CharLongMap.containsValue(long) instead 
net.openhft.collect.map.CharShortMap.containsValue(Object)
          Use specialization CharShortMap.containsValue(short) instead 
net.openhft.collect.map.DoubleByteMap.containsValue(Object)
          Use specialization DoubleByteMap.containsValue(byte) instead 
net.openhft.collect.map.DoubleCharMap.containsValue(Object)
          Use specialization DoubleCharMap.containsValue(char) instead 
net.openhft.collect.map.DoubleDoubleMap.containsValue(Object)
          Use specialization DoubleDoubleMap.containsValue(double) instead 
net.openhft.collect.map.DoubleFloatMap.containsValue(Object)
          Use specialization DoubleFloatMap.containsValue(float) instead 
net.openhft.collect.map.DoubleIntMap.containsValue(Object)
          Use specialization DoubleIntMap.containsValue(int) instead 
net.openhft.collect.map.DoubleLongMap.containsValue(Object)
          Use specialization DoubleLongMap.containsValue(long) instead 
net.openhft.collect.map.DoubleShortMap.containsValue(Object)
          Use specialization DoubleShortMap.containsValue(short) instead 
net.openhft.collect.map.FloatByteMap.containsValue(Object)
          Use specialization FloatByteMap.containsValue(byte) instead 
net.openhft.collect.map.FloatCharMap.containsValue(Object)
          Use specialization FloatCharMap.containsValue(char) instead 
net.openhft.collect.map.FloatDoubleMap.containsValue(Object)
          Use specialization FloatDoubleMap.containsValue(double) instead 
net.openhft.collect.map.FloatFloatMap.containsValue(Object)
          Use specialization FloatFloatMap.containsValue(float) instead 
net.openhft.collect.map.FloatIntMap.containsValue(Object)
          Use specialization FloatIntMap.containsValue(int) instead 
net.openhft.collect.map.FloatLongMap.containsValue(Object)
          Use specialization FloatLongMap.containsValue(long) instead 
net.openhft.collect.map.FloatShortMap.containsValue(Object)
          Use specialization FloatShortMap.containsValue(short) instead 
net.openhft.collect.map.IntByteMap.containsValue(Object)
          Use specialization IntByteMap.containsValue(byte) instead 
net.openhft.collect.map.IntCharMap.containsValue(Object)
          Use specialization IntCharMap.containsValue(char) instead 
net.openhft.collect.map.IntDoubleMap.containsValue(Object)
          Use specialization IntDoubleMap.containsValue(double) instead 
net.openhft.collect.map.IntFloatMap.containsValue(Object)
          Use specialization IntFloatMap.containsValue(float) instead 
net.openhft.collect.map.IntIntMap.containsValue(Object)
          Use specialization IntIntMap.containsValue(int) instead 
net.openhft.collect.map.IntLongMap.containsValue(Object)
          Use specialization IntLongMap.containsValue(long) instead 
net.openhft.collect.map.IntShortMap.containsValue(Object)
          Use specialization IntShortMap.containsValue(short) instead 
net.openhft.collect.map.LongByteMap.containsValue(Object)
          Use specialization LongByteMap.containsValue(byte) instead 
net.openhft.collect.map.LongCharMap.containsValue(Object)
          Use specialization LongCharMap.containsValue(char) instead 
net.openhft.collect.map.LongDoubleMap.containsValue(Object)
          Use specialization LongDoubleMap.containsValue(double) instead 
net.openhft.collect.map.LongFloatMap.containsValue(Object)
          Use specialization LongFloatMap.containsValue(float) instead 
net.openhft.collect.map.LongIntMap.containsValue(Object)
          Use specialization LongIntMap.containsValue(int) instead 
net.openhft.collect.map.LongLongMap.containsValue(Object)
          Use specialization LongLongMap.containsValue(long) instead 
net.openhft.collect.map.LongShortMap.containsValue(Object)
          Use specialization LongShortMap.containsValue(short) instead 
net.openhft.collect.map.ObjByteMap.containsValue(Object)
          Use specialization ObjByteMap.containsValue(byte) instead 
net.openhft.collect.map.ObjCharMap.containsValue(Object)
          Use specialization ObjCharMap.containsValue(char) instead 
net.openhft.collect.map.ObjDoubleMap.containsValue(Object)
          Use specialization ObjDoubleMap.containsValue(double) instead 
net.openhft.collect.map.ObjFloatMap.containsValue(Object)
          Use specialization ObjFloatMap.containsValue(float) instead 
net.openhft.collect.map.ObjIntMap.containsValue(Object)
          Use specialization ObjIntMap.containsValue(int) instead 
net.openhft.collect.map.ObjLongMap.containsValue(Object)
          Use specialization ObjLongMap.containsValue(long) instead 
net.openhft.collect.map.ObjShortMap.containsValue(Object)
          Use specialization ObjShortMap.containsValue(short) instead 
net.openhft.collect.map.ShortByteMap.containsValue(Object)
          Use specialization ShortByteMap.containsValue(byte) instead 
net.openhft.collect.map.ShortCharMap.containsValue(Object)
          Use specialization ShortCharMap.containsValue(char) instead 
net.openhft.collect.map.ShortDoubleMap.containsValue(Object)
          Use specialization ShortDoubleMap.containsValue(double) instead 
net.openhft.collect.map.ShortFloatMap.containsValue(Object)
          Use specialization ShortFloatMap.containsValue(float) instead 
net.openhft.collect.map.ShortIntMap.containsValue(Object)
          Use specialization ShortIntMap.containsValue(int) instead 
net.openhft.collect.map.ShortLongMap.containsValue(Object)
          Use specialization ShortLongMap.containsValue(long) instead 
net.openhft.collect.map.ShortShortMap.containsValue(Object)
          Use specialization ShortShortMap.containsValue(short) instead 
net.openhft.collect.map.ByteByteMap.get(Object)
          Use specialization ByteByteMap.get(byte) instead 
net.openhft.collect.map.ByteCharMap.get(Object)
          Use specialization ByteCharMap.get(byte) instead 
net.openhft.collect.map.ByteDoubleMap.get(Object)
          Use specialization ByteDoubleMap.get(byte) instead 
net.openhft.collect.map.ByteFloatMap.get(Object)
          Use specialization ByteFloatMap.get(byte) instead 
net.openhft.collect.map.ByteIntMap.get(Object)
          Use specialization ByteIntMap.get(byte) instead 
net.openhft.collect.map.ByteLongMap.get(Object)
          Use specialization ByteLongMap.get(byte) instead 
net.openhft.collect.map.ByteObjMap.get(Object)
          Use specialization ByteObjMap.get(byte) instead 
net.openhft.collect.map.ByteShortMap.get(Object)
          Use specialization ByteShortMap.get(byte) instead 
net.openhft.collect.map.CharByteMap.get(Object)
          Use specialization CharByteMap.get(char) instead 
net.openhft.collect.map.CharCharMap.get(Object)
          Use specialization CharCharMap.get(char) instead 
net.openhft.collect.map.CharDoubleMap.get(Object)
          Use specialization CharDoubleMap.get(char) instead 
net.openhft.collect.map.CharFloatMap.get(Object)
          Use specialization CharFloatMap.get(char) instead 
net.openhft.collect.map.CharIntMap.get(Object)
          Use specialization CharIntMap.get(char) instead 
net.openhft.collect.map.CharLongMap.get(Object)
          Use specialization CharLongMap.get(char) instead 
net.openhft.collect.map.CharObjMap.get(Object)
          Use specialization CharObjMap.get(char) instead 
net.openhft.collect.map.CharShortMap.get(Object)
          Use specialization CharShortMap.get(char) instead 
net.openhft.collect.map.DoubleByteMap.get(Object)
          Use specialization DoubleByteMap.get(double) instead 
net.openhft.collect.map.DoubleCharMap.get(Object)
          Use specialization DoubleCharMap.get(double) instead 
net.openhft.collect.map.DoubleDoubleMap.get(Object)
          Use specialization DoubleDoubleMap.get(double) instead 
net.openhft.collect.map.DoubleFloatMap.get(Object)
          Use specialization DoubleFloatMap.get(double) instead 
net.openhft.collect.map.DoubleIntMap.get(Object)
          Use specialization DoubleIntMap.get(double) instead 
net.openhft.collect.map.DoubleLongMap.get(Object)
          Use specialization DoubleLongMap.get(double) instead 
net.openhft.collect.map.DoubleObjMap.get(Object)
          Use specialization DoubleObjMap.get(double) instead 
net.openhft.collect.map.DoubleShortMap.get(Object)
          Use specialization DoubleShortMap.get(double) instead 
net.openhft.collect.map.FloatByteMap.get(Object)
          Use specialization FloatByteMap.get(float) instead 
net.openhft.collect.map.FloatCharMap.get(Object)
          Use specialization FloatCharMap.get(float) instead 
net.openhft.collect.map.FloatDoubleMap.get(Object)
          Use specialization FloatDoubleMap.get(float) instead 
net.openhft.collect.map.FloatFloatMap.get(Object)
          Use specialization FloatFloatMap.get(float) instead 
net.openhft.collect.map.FloatIntMap.get(Object)
          Use specialization FloatIntMap.get(float) instead 
net.openhft.collect.map.FloatLongMap.get(Object)
          Use specialization FloatLongMap.get(float) instead 
net.openhft.collect.map.FloatObjMap.get(Object)
          Use specialization FloatObjMap.get(float) instead 
net.openhft.collect.map.FloatShortMap.get(Object)
          Use specialization FloatShortMap.get(float) instead 
net.openhft.collect.map.IntByteMap.get(Object)
          Use specialization IntByteMap.get(int) instead 
net.openhft.collect.map.IntCharMap.get(Object)
          Use specialization IntCharMap.get(int) instead 
net.openhft.collect.map.IntDoubleMap.get(Object)
          Use specialization IntDoubleMap.get(int) instead 
net.openhft.collect.map.IntFloatMap.get(Object)
          Use specialization IntFloatMap.get(int) instead 
net.openhft.collect.map.IntIntMap.get(Object)
          Use specialization IntIntMap.get(int) instead 
net.openhft.collect.map.IntLongMap.get(Object)
          Use specialization IntLongMap.get(int) instead 
net.openhft.collect.map.IntObjMap.get(Object)
          Use specialization IntObjMap.get(int) instead 
net.openhft.collect.map.IntShortMap.get(Object)
          Use specialization IntShortMap.get(int) instead 
net.openhft.collect.map.LongByteMap.get(Object)
          Use specialization LongByteMap.get(long) instead 
net.openhft.collect.map.LongCharMap.get(Object)
          Use specialization LongCharMap.get(long) instead 
net.openhft.collect.map.LongDoubleMap.get(Object)
          Use specialization LongDoubleMap.get(long) instead 
net.openhft.collect.map.LongFloatMap.get(Object)
          Use specialization LongFloatMap.get(long) instead 
net.openhft.collect.map.LongIntMap.get(Object)
          Use specialization LongIntMap.get(long) instead 
net.openhft.collect.map.LongLongMap.get(Object)
          Use specialization LongLongMap.get(long) instead 
net.openhft.collect.map.LongObjMap.get(Object)
          Use specialization LongObjMap.get(long) instead 
net.openhft.collect.map.LongShortMap.get(Object)
          Use specialization LongShortMap.get(long) instead 
net.openhft.collect.map.ObjByteMap.get(Object)
          Use specialization ObjByteMap.getByte(Object) instead 
net.openhft.collect.map.ObjCharMap.get(Object)
          Use specialization ObjCharMap.getChar(Object) instead 
net.openhft.collect.map.ObjDoubleMap.get(Object)
          Use specialization ObjDoubleMap.getDouble(Object) instead 
net.openhft.collect.map.ObjFloatMap.get(Object)
          Use specialization ObjFloatMap.getFloat(Object) instead 
net.openhft.collect.map.ObjIntMap.get(Object)
          Use specialization ObjIntMap.getInt(Object) instead 
net.openhft.collect.map.ObjLongMap.get(Object)
          Use specialization ObjLongMap.getLong(Object) instead 
net.openhft.collect.map.ObjShortMap.get(Object)
          Use specialization ObjShortMap.getShort(Object) instead 
net.openhft.collect.map.ShortByteMap.get(Object)
          Use specialization ShortByteMap.get(short) instead 
net.openhft.collect.map.ShortCharMap.get(Object)
          Use specialization ShortCharMap.get(short) instead 
net.openhft.collect.map.ShortDoubleMap.get(Object)
          Use specialization ShortDoubleMap.get(short) instead 
net.openhft.collect.map.ShortFloatMap.get(Object)
          Use specialization ShortFloatMap.get(short) instead 
net.openhft.collect.map.ShortIntMap.get(Object)
          Use specialization ShortIntMap.get(short) instead 
net.openhft.collect.map.ShortLongMap.get(Object)
          Use specialization ShortLongMap.get(short) instead 
net.openhft.collect.map.ShortObjMap.get(Object)
          Use specialization ShortObjMap.get(short) instead 
net.openhft.collect.map.ShortShortMap.get(Object)
          Use specialization ShortShortMap.get(short) instead 
net.openhft.collect.map.ByteByteMap.getOrDefault(Object, Byte)
          Use specialization ByteByteMap.getOrDefault(byte, byte) instead 
net.openhft.collect.map.CharByteMap.getOrDefault(Object, Byte)
          Use specialization CharByteMap.getOrDefault(char, byte) instead 
net.openhft.collect.map.DoubleByteMap.getOrDefault(Object, Byte)
          Use specialization DoubleByteMap.getOrDefault(double, byte) instead 
net.openhft.collect.map.FloatByteMap.getOrDefault(Object, Byte)
          Use specialization FloatByteMap.getOrDefault(float, byte) instead 
net.openhft.collect.map.IntByteMap.getOrDefault(Object, Byte)
          Use specialization IntByteMap.getOrDefault(int, byte) instead 
net.openhft.collect.map.LongByteMap.getOrDefault(Object, Byte)
          Use specialization LongByteMap.getOrDefault(long, byte) instead 
net.openhft.collect.map.ObjByteMap.getOrDefault(Object, Byte)
          Use specialization ObjByteMap.getOrDefault(Object, byte) instead 
net.openhft.collect.map.ShortByteMap.getOrDefault(Object, Byte)
          Use specialization ShortByteMap.getOrDefault(short, byte) instead 
net.openhft.collect.map.ByteCharMap.getOrDefault(Object, Character)
          Use specialization ByteCharMap.getOrDefault(byte, char) instead 
net.openhft.collect.map.CharCharMap.getOrDefault(Object, Character)
          Use specialization CharCharMap.getOrDefault(char, char) instead 
net.openhft.collect.map.DoubleCharMap.getOrDefault(Object, Character)
          Use specialization DoubleCharMap.getOrDefault(double, char) instead 
net.openhft.collect.map.FloatCharMap.getOrDefault(Object, Character)
          Use specialization FloatCharMap.getOrDefault(float, char) instead 
net.openhft.collect.map.IntCharMap.getOrDefault(Object, Character)
          Use specialization IntCharMap.getOrDefault(int, char) instead 
net.openhft.collect.map.LongCharMap.getOrDefault(Object, Character)
          Use specialization LongCharMap.getOrDefault(long, char) instead 
net.openhft.collect.map.ObjCharMap.getOrDefault(Object, Character)
          Use specialization ObjCharMap.getOrDefault(Object, char) instead 
net.openhft.collect.map.ShortCharMap.getOrDefault(Object, Character)
          Use specialization ShortCharMap.getOrDefault(short, char) instead 
net.openhft.collect.map.ByteDoubleMap.getOrDefault(Object, Double)
          Use specialization ByteDoubleMap.getOrDefault(byte, double) instead 
net.openhft.collect.map.CharDoubleMap.getOrDefault(Object, Double)
          Use specialization CharDoubleMap.getOrDefault(char, double) instead 
net.openhft.collect.map.DoubleDoubleMap.getOrDefault(Object, Double)
          Use specialization DoubleDoubleMap.getOrDefault(double, double) instead 
net.openhft.collect.map.FloatDoubleMap.getOrDefault(Object, Double)
          Use specialization FloatDoubleMap.getOrDefault(float, double) instead 
net.openhft.collect.map.IntDoubleMap.getOrDefault(Object, Double)
          Use specialization IntDoubleMap.getOrDefault(int, double) instead 
net.openhft.collect.map.LongDoubleMap.getOrDefault(Object, Double)
          Use specialization LongDoubleMap.getOrDefault(long, double) instead 
net.openhft.collect.map.ObjDoubleMap.getOrDefault(Object, Double)
          Use specialization ObjDoubleMap.getOrDefault(Object, double) instead 
net.openhft.collect.map.ShortDoubleMap.getOrDefault(Object, Double)
          Use specialization ShortDoubleMap.getOrDefault(short, double) instead 
net.openhft.collect.map.ByteFloatMap.getOrDefault(Object, Float)
          Use specialization ByteFloatMap.getOrDefault(byte, float) instead 
net.openhft.collect.map.CharFloatMap.getOrDefault(Object, Float)
          Use specialization CharFloatMap.getOrDefault(char, float) instead 
net.openhft.collect.map.DoubleFloatMap.getOrDefault(Object, Float)
          Use specialization DoubleFloatMap.getOrDefault(double, float) instead 
net.openhft.collect.map.FloatFloatMap.getOrDefault(Object, Float)
          Use specialization FloatFloatMap.getOrDefault(float, float) instead 
net.openhft.collect.map.IntFloatMap.getOrDefault(Object, Float)
          Use specialization IntFloatMap.getOrDefault(int, float) instead 
net.openhft.collect.map.LongFloatMap.getOrDefault(Object, Float)
          Use specialization LongFloatMap.getOrDefault(long, float) instead 
net.openhft.collect.map.ObjFloatMap.getOrDefault(Object, Float)
          Use specialization ObjFloatMap.getOrDefault(Object, float) instead 
net.openhft.collect.map.ShortFloatMap.getOrDefault(Object, Float)
          Use specialization ShortFloatMap.getOrDefault(short, float) instead 
net.openhft.collect.map.ByteIntMap.getOrDefault(Object, Integer)
          Use specialization ByteIntMap.getOrDefault(byte, int) instead 
net.openhft.collect.map.CharIntMap.getOrDefault(Object, Integer)
          Use specialization CharIntMap.getOrDefault(char, int) instead 
net.openhft.collect.map.DoubleIntMap.getOrDefault(Object, Integer)
          Use specialization DoubleIntMap.getOrDefault(double, int) instead 
net.openhft.collect.map.FloatIntMap.getOrDefault(Object, Integer)
          Use specialization FloatIntMap.getOrDefault(float, int) instead 
net.openhft.collect.map.IntIntMap.getOrDefault(Object, Integer)
          Use specialization IntIntMap.getOrDefault(int, int) instead 
net.openhft.collect.map.LongIntMap.getOrDefault(Object, Integer)
          Use specialization LongIntMap.getOrDefault(long, int) instead 
net.openhft.collect.map.ObjIntMap.getOrDefault(Object, Integer)
          Use specialization ObjIntMap.getOrDefault(Object, int) instead 
net.openhft.collect.map.ShortIntMap.getOrDefault(Object, Integer)
          Use specialization ShortIntMap.getOrDefault(short, int) instead 
net.openhft.collect.map.ByteLongMap.getOrDefault(Object, Long)
          Use specialization ByteLongMap.getOrDefault(byte, long) instead 
net.openhft.collect.map.CharLongMap.getOrDefault(Object, Long)
          Use specialization CharLongMap.getOrDefault(char, long) instead 
net.openhft.collect.map.DoubleLongMap.getOrDefault(Object, Long)
          Use specialization DoubleLongMap.getOrDefault(double, long) instead 
net.openhft.collect.map.FloatLongMap.getOrDefault(Object, Long)
          Use specialization FloatLongMap.getOrDefault(float, long) instead 
net.openhft.collect.map.IntLongMap.getOrDefault(Object, Long)
          Use specialization IntLongMap.getOrDefault(int, long) instead 
net.openhft.collect.map.LongLongMap.getOrDefault(Object, Long)
          Use specialization LongLongMap.getOrDefault(long, long) instead 
net.openhft.collect.map.ObjLongMap.getOrDefault(Object, Long)
          Use specialization ObjLongMap.getOrDefault(Object, long) instead 
net.openhft.collect.map.ShortLongMap.getOrDefault(Object, Long)
          Use specialization ShortLongMap.getOrDefault(short, long) instead 
net.openhft.collect.map.ByteShortMap.getOrDefault(Object, Short)
          Use specialization ByteShortMap.getOrDefault(byte, short) instead 
net.openhft.collect.map.CharShortMap.getOrDefault(Object, Short)
          Use specialization CharShortMap.getOrDefault(char, short) instead 
net.openhft.collect.map.DoubleShortMap.getOrDefault(Object, Short)
          Use specialization DoubleShortMap.getOrDefault(double, short) instead 
net.openhft.collect.map.FloatShortMap.getOrDefault(Object, Short)
          Use specialization FloatShortMap.getOrDefault(float, short) instead 
net.openhft.collect.map.IntShortMap.getOrDefault(Object, Short)
          Use specialization IntShortMap.getOrDefault(int, short) instead 
net.openhft.collect.map.LongShortMap.getOrDefault(Object, Short)
          Use specialization LongShortMap.getOrDefault(long, short) instead 
net.openhft.collect.map.ObjShortMap.getOrDefault(Object, Short)
          Use specialization ObjShortMap.getOrDefault(Object, short) instead 
net.openhft.collect.map.ShortShortMap.getOrDefault(Object, Short)
          Use specialization ShortShortMap.getOrDefault(short, short) instead 
net.openhft.collect.map.ByteObjMap.getOrDefault(Object, V)
          Use specialization ByteObjMap.getOrDefault(byte, Object) instead 
net.openhft.collect.map.CharObjMap.getOrDefault(Object, V)
          Use specialization CharObjMap.getOrDefault(char, Object) instead 
net.openhft.collect.map.DoubleObjMap.getOrDefault(Object, V)
          Use specialization DoubleObjMap.getOrDefault(double, Object) instead 
net.openhft.collect.map.FloatObjMap.getOrDefault(Object, V)
          Use specialization FloatObjMap.getOrDefault(float, Object) instead 
net.openhft.collect.map.IntObjMap.getOrDefault(Object, V)
          Use specialization IntObjMap.getOrDefault(int, Object) instead 
net.openhft.collect.map.LongObjMap.getOrDefault(Object, V)
          Use specialization LongObjMap.getOrDefault(long, Object) instead 
net.openhft.collect.map.ShortObjMap.getOrDefault(Object, V)
          Use specialization ShortObjMap.getOrDefault(short, Object) instead 
net.openhft.collect.map.ByteByteMap.put(Byte, Byte)
          Use specialization ByteByteMap.put(byte, byte) instead 
net.openhft.collect.map.ByteCharMap.put(Byte, Character)
          Use specialization ByteCharMap.put(byte, char) instead 
net.openhft.collect.map.ByteDoubleMap.put(Byte, Double)
          Use specialization ByteDoubleMap.put(byte, double) instead 
net.openhft.collect.map.ByteFloatMap.put(Byte, Float)
          Use specialization ByteFloatMap.put(byte, float) instead 
net.openhft.collect.map.ByteIntMap.put(Byte, Integer)
          Use specialization ByteIntMap.put(byte, int) instead 
net.openhft.collect.map.ByteLongMap.put(Byte, Long)
          Use specialization ByteLongMap.put(byte, long) instead 
net.openhft.collect.map.ByteShortMap.put(Byte, Short)
          Use specialization ByteShortMap.put(byte, short) instead 
net.openhft.collect.map.ByteObjMap.put(Byte, V)
          Use specialization ByteObjMap.put(byte, Object) instead 
net.openhft.collect.map.CharByteMap.put(Character, Byte)
          Use specialization CharByteMap.put(char, byte) instead 
net.openhft.collect.map.CharCharMap.put(Character, Character)
          Use specialization CharCharMap.put(char, char) instead 
net.openhft.collect.map.CharDoubleMap.put(Character, Double)
          Use specialization CharDoubleMap.put(char, double) instead 
net.openhft.collect.map.CharFloatMap.put(Character, Float)
          Use specialization CharFloatMap.put(char, float) instead 
net.openhft.collect.map.CharIntMap.put(Character, Integer)
          Use specialization CharIntMap.put(char, int) instead 
net.openhft.collect.map.CharLongMap.put(Character, Long)
          Use specialization CharLongMap.put(char, long) instead 
net.openhft.collect.map.CharShortMap.put(Character, Short)
          Use specialization CharShortMap.put(char, short) instead 
net.openhft.collect.map.CharObjMap.put(Character, V)
          Use specialization CharObjMap.put(char, Object) instead 
net.openhft.collect.map.DoubleByteMap.put(Double, Byte)
          Use specialization DoubleByteMap.put(double, byte) instead 
net.openhft.collect.map.DoubleCharMap.put(Double, Character)
          Use specialization DoubleCharMap.put(double, char) instead 
net.openhft.collect.map.DoubleDoubleMap.put(Double, Double)
          Use specialization DoubleDoubleMap.put(double, double) instead 
net.openhft.collect.map.DoubleFloatMap.put(Double, Float)
          Use specialization DoubleFloatMap.put(double, float) instead 
net.openhft.collect.map.DoubleIntMap.put(Double, Integer)
          Use specialization DoubleIntMap.put(double, int) instead 
net.openhft.collect.map.DoubleLongMap.put(Double, Long)
          Use specialization DoubleLongMap.put(double, long) instead 
net.openhft.collect.map.DoubleShortMap.put(Double, Short)
          Use specialization DoubleShortMap.put(double, short) instead 
net.openhft.collect.map.DoubleObjMap.put(Double, V)
          Use specialization DoubleObjMap.put(double, Object) instead 
net.openhft.collect.map.FloatByteMap.put(Float, Byte)
          Use specialization FloatByteMap.put(float, byte) instead 
net.openhft.collect.map.FloatCharMap.put(Float, Character)
          Use specialization FloatCharMap.put(float, char) instead 
net.openhft.collect.map.FloatDoubleMap.put(Float, Double)
          Use specialization FloatDoubleMap.put(float, double) instead 
net.openhft.collect.map.FloatFloatMap.put(Float, Float)
          Use specialization FloatFloatMap.put(float, float) instead 
net.openhft.collect.map.FloatIntMap.put(Float, Integer)
          Use specialization FloatIntMap.put(float, int) instead 
net.openhft.collect.map.FloatLongMap.put(Float, Long)
          Use specialization FloatLongMap.put(float, long) instead 
net.openhft.collect.map.FloatShortMap.put(Float, Short)
          Use specialization FloatShortMap.put(float, short) instead 
net.openhft.collect.map.FloatObjMap.put(Float, V)
          Use specialization FloatObjMap.put(float, Object) instead 
net.openhft.collect.map.IntByteMap.put(Integer, Byte)
          Use specialization IntByteMap.put(int, byte) instead 
net.openhft.collect.map.IntCharMap.put(Integer, Character)
          Use specialization IntCharMap.put(int, char) instead 
net.openhft.collect.map.IntDoubleMap.put(Integer, Double)
          Use specialization IntDoubleMap.put(int, double) instead 
net.openhft.collect.map.IntFloatMap.put(Integer, Float)
          Use specialization IntFloatMap.put(int, float) instead 
net.openhft.collect.map.IntIntMap.put(Integer, Integer)
          Use specialization IntIntMap.put(int, int) instead 
net.openhft.collect.map.IntLongMap.put(Integer, Long)
          Use specialization IntLongMap.put(int, long) instead 
net.openhft.collect.map.IntShortMap.put(Integer, Short)
          Use specialization IntShortMap.put(int, short) instead 
net.openhft.collect.map.IntObjMap.put(Integer, V)
          Use specialization IntObjMap.put(int, Object) instead 
net.openhft.collect.map.ObjByteMap.put(K, Byte)
          Use specialization ObjByteMap.put(Object, byte) instead 
net.openhft.collect.map.ObjCharMap.put(K, Character)
          Use specialization ObjCharMap.put(Object, char) instead 
net.openhft.collect.map.ObjDoubleMap.put(K, Double)
          Use specialization ObjDoubleMap.put(Object, double) instead 
net.openhft.collect.map.ObjFloatMap.put(K, Float)
          Use specialization ObjFloatMap.put(Object, float) instead 
net.openhft.collect.map.ObjIntMap.put(K, Integer)
          Use specialization ObjIntMap.put(Object, int) instead 
net.openhft.collect.map.ObjLongMap.put(K, Long)
          Use specialization ObjLongMap.put(Object, long) instead 
net.openhft.collect.map.ObjShortMap.put(K, Short)
          Use specialization ObjShortMap.put(Object, short) instead 
net.openhft.collect.map.LongByteMap.put(Long, Byte)
          Use specialization LongByteMap.put(long, byte) instead 
net.openhft.collect.map.LongCharMap.put(Long, Character)
          Use specialization LongCharMap.put(long, char) instead 
net.openhft.collect.map.LongDoubleMap.put(Long, Double)
          Use specialization LongDoubleMap.put(long, double) instead 
net.openhft.collect.map.LongFloatMap.put(Long, Float)
          Use specialization LongFloatMap.put(long, float) instead 
net.openhft.collect.map.LongIntMap.put(Long, Integer)
          Use specialization LongIntMap.put(long, int) instead 
net.openhft.collect.map.LongLongMap.put(Long, Long)
          Use specialization LongLongMap.put(long, long) instead 
net.openhft.collect.map.LongShortMap.put(Long, Short)
          Use specialization LongShortMap.put(long, short) instead 
net.openhft.collect.map.LongObjMap.put(Long, V)
          Use specialization LongObjMap.put(long, Object) instead 
net.openhft.collect.map.ShortByteMap.put(Short, Byte)
          Use specialization ShortByteMap.put(short, byte) instead 
net.openhft.collect.map.ShortCharMap.put(Short, Character)
          Use specialization ShortCharMap.put(short, char) instead 
net.openhft.collect.map.ShortDoubleMap.put(Short, Double)
          Use specialization ShortDoubleMap.put(short, double) instead 
net.openhft.collect.map.ShortFloatMap.put(Short, Float)
          Use specialization ShortFloatMap.put(short, float) instead 
net.openhft.collect.map.ShortIntMap.put(Short, Integer)
          Use specialization ShortIntMap.put(short, int) instead 
net.openhft.collect.map.ShortLongMap.put(Short, Long)
          Use specialization ShortLongMap.put(short, long) instead 
net.openhft.collect.map.ShortShortMap.put(Short, Short)
          Use specialization ShortShortMap.put(short, short) instead 
net.openhft.collect.map.ShortObjMap.put(Short, V)
          Use specialization ShortObjMap.put(short, Object) instead 
net.openhft.collect.map.ByteByteMap.putIfAbsent(Byte, Byte)
          Use specialization ByteByteMap.putIfAbsent(byte, byte) instead 
net.openhft.collect.map.ByteCharMap.putIfAbsent(Byte, Character)
          Use specialization ByteCharMap.putIfAbsent(byte, char) instead 
net.openhft.collect.map.ByteDoubleMap.putIfAbsent(Byte, Double)
          Use specialization ByteDoubleMap.putIfAbsent(byte, double) instead 
net.openhft.collect.map.ByteFloatMap.putIfAbsent(Byte, Float)
          Use specialization ByteFloatMap.putIfAbsent(byte, float) instead 
net.openhft.collect.map.ByteIntMap.putIfAbsent(Byte, Integer)
          Use specialization ByteIntMap.putIfAbsent(byte, int) instead 
net.openhft.collect.map.ByteLongMap.putIfAbsent(Byte, Long)
          Use specialization ByteLongMap.putIfAbsent(byte, long) instead 
net.openhft.collect.map.ByteShortMap.putIfAbsent(Byte, Short)
          Use specialization ByteShortMap.putIfAbsent(byte, short) instead 
net.openhft.collect.map.ByteObjMap.putIfAbsent(Byte, V)
          Use specialization ByteObjMap.putIfAbsent(byte, Object) instead 
net.openhft.collect.map.CharByteMap.putIfAbsent(Character, Byte)
          Use specialization CharByteMap.putIfAbsent(char, byte) instead 
net.openhft.collect.map.CharCharMap.putIfAbsent(Character, Character)
          Use specialization CharCharMap.putIfAbsent(char, char) instead 
net.openhft.collect.map.CharDoubleMap.putIfAbsent(Character, Double)
          Use specialization CharDoubleMap.putIfAbsent(char, double) instead 
net.openhft.collect.map.CharFloatMap.putIfAbsent(Character, Float)
          Use specialization CharFloatMap.putIfAbsent(char, float) instead 
net.openhft.collect.map.CharIntMap.putIfAbsent(Character, Integer)
          Use specialization CharIntMap.putIfAbsent(char, int) instead 
net.openhft.collect.map.CharLongMap.putIfAbsent(Character, Long)
          Use specialization CharLongMap.putIfAbsent(char, long) instead 
net.openhft.collect.map.CharShortMap.putIfAbsent(Character, Short)
          Use specialization CharShortMap.putIfAbsent(char, short) instead 
net.openhft.collect.map.CharObjMap.putIfAbsent(Character, V)
          Use specialization CharObjMap.putIfAbsent(char, Object) instead 
net.openhft.collect.map.DoubleByteMap.putIfAbsent(Double, Byte)
          Use specialization DoubleByteMap.putIfAbsent(double, byte) instead 
net.openhft.collect.map.DoubleCharMap.putIfAbsent(Double, Character)
          Use specialization DoubleCharMap.putIfAbsent(double, char) instead 
net.openhft.collect.map.DoubleDoubleMap.putIfAbsent(Double, Double)
          Use specialization DoubleDoubleMap.putIfAbsent(double, double) instead 
net.openhft.collect.map.DoubleFloatMap.putIfAbsent(Double, Float)
          Use specialization DoubleFloatMap.putIfAbsent(double, float) instead 
net.openhft.collect.map.DoubleIntMap.putIfAbsent(Double, Integer)
          Use specialization DoubleIntMap.putIfAbsent(double, int) instead 
net.openhft.collect.map.DoubleLongMap.putIfAbsent(Double, Long)
          Use specialization DoubleLongMap.putIfAbsent(double, long) instead 
net.openhft.collect.map.DoubleShortMap.putIfAbsent(Double, Short)
          Use specialization DoubleShortMap.putIfAbsent(double, short) instead 
net.openhft.collect.map.DoubleObjMap.putIfAbsent(Double, V)
          Use specialization DoubleObjMap.putIfAbsent(double, Object) instead 
net.openhft.collect.map.FloatByteMap.putIfAbsent(Float, Byte)
          Use specialization FloatByteMap.putIfAbsent(float, byte) instead 
net.openhft.collect.map.FloatCharMap.putIfAbsent(Float, Character)
          Use specialization FloatCharMap.putIfAbsent(float, char) instead 
net.openhft.collect.map.FloatDoubleMap.putIfAbsent(Float, Double)
          Use specialization FloatDoubleMap.putIfAbsent(float, double) instead 
net.openhft.collect.map.FloatFloatMap.putIfAbsent(Float, Float)
          Use specialization FloatFloatMap.putIfAbsent(float, float) instead 
net.openhft.collect.map.FloatIntMap.putIfAbsent(Float, Integer)
          Use specialization FloatIntMap.putIfAbsent(float, int) instead 
net.openhft.collect.map.FloatLongMap.putIfAbsent(Float, Long)
          Use specialization FloatLongMap.putIfAbsent(float, long) instead 
net.openhft.collect.map.FloatShortMap.putIfAbsent(Float, Short)
          Use specialization FloatShortMap.putIfAbsent(float, short) instead 
net.openhft.collect.map.FloatObjMap.putIfAbsent(Float, V)
          Use specialization FloatObjMap.putIfAbsent(float, Object) instead 
net.openhft.collect.map.IntByteMap.putIfAbsent(Integer, Byte)
          Use specialization IntByteMap.putIfAbsent(int, byte) instead 
net.openhft.collect.map.IntCharMap.putIfAbsent(Integer, Character)
          Use specialization IntCharMap.putIfAbsent(int, char) instead 
net.openhft.collect.map.IntDoubleMap.putIfAbsent(Integer, Double)
          Use specialization IntDoubleMap.putIfAbsent(int, double) instead 
net.openhft.collect.map.IntFloatMap.putIfAbsent(Integer, Float)
          Use specialization IntFloatMap.putIfAbsent(int, float) instead 
net.openhft.collect.map.IntIntMap.putIfAbsent(Integer, Integer)
          Use specialization IntIntMap.putIfAbsent(int, int) instead 
net.openhft.collect.map.IntLongMap.putIfAbsent(Integer, Long)
          Use specialization IntLongMap.putIfAbsent(int, long) instead 
net.openhft.collect.map.IntShortMap.putIfAbsent(Integer, Short)
          Use specialization IntShortMap.putIfAbsent(int, short) instead 
net.openhft.collect.map.IntObjMap.putIfAbsent(Integer, V)
          Use specialization IntObjMap.putIfAbsent(int, Object) instead 
net.openhft.collect.map.ObjByteMap.putIfAbsent(K, Byte)
          Use specialization ObjByteMap.putIfAbsent(Object, byte) instead 
net.openhft.collect.map.ObjCharMap.putIfAbsent(K, Character)
          Use specialization ObjCharMap.putIfAbsent(Object, char) instead 
net.openhft.collect.map.ObjDoubleMap.putIfAbsent(K, Double)
          Use specialization ObjDoubleMap.putIfAbsent(Object, double) instead 
net.openhft.collect.map.ObjFloatMap.putIfAbsent(K, Float)
          Use specialization ObjFloatMap.putIfAbsent(Object, float) instead 
net.openhft.collect.map.ObjIntMap.putIfAbsent(K, Integer)
          Use specialization ObjIntMap.putIfAbsent(Object, int) instead 
net.openhft.collect.map.ObjLongMap.putIfAbsent(K, Long)
          Use specialization ObjLongMap.putIfAbsent(Object, long) instead 
net.openhft.collect.map.ObjShortMap.putIfAbsent(K, Short)
          Use specialization ObjShortMap.putIfAbsent(Object, short) instead 
net.openhft.collect.map.LongByteMap.putIfAbsent(Long, Byte)
          Use specialization LongByteMap.putIfAbsent(long, byte) instead 
net.openhft.collect.map.LongCharMap.putIfAbsent(Long, Character)
          Use specialization LongCharMap.putIfAbsent(long, char) instead 
net.openhft.collect.map.LongDoubleMap.putIfAbsent(Long, Double)
          Use specialization LongDoubleMap.putIfAbsent(long, double) instead 
net.openhft.collect.map.LongFloatMap.putIfAbsent(Long, Float)
          Use specialization LongFloatMap.putIfAbsent(long, float) instead 
net.openhft.collect.map.LongIntMap.putIfAbsent(Long, Integer)
          Use specialization LongIntMap.putIfAbsent(long, int) instead 
net.openhft.collect.map.LongLongMap.putIfAbsent(Long, Long)
          Use specialization LongLongMap.putIfAbsent(long, long) instead 
net.openhft.collect.map.LongShortMap.putIfAbsent(Long, Short)
          Use specialization LongShortMap.putIfAbsent(long, short) instead 
net.openhft.collect.map.LongObjMap.putIfAbsent(Long, V)
          Use specialization LongObjMap.putIfAbsent(long, Object) instead 
net.openhft.collect.map.ShortByteMap.putIfAbsent(Short, Byte)
          Use specialization ShortByteMap.putIfAbsent(short, byte) instead 
net.openhft.collect.map.ShortCharMap.putIfAbsent(Short, Character)
          Use specialization ShortCharMap.putIfAbsent(short, char) instead 
net.openhft.collect.map.ShortDoubleMap.putIfAbsent(Short, Double)
          Use specialization ShortDoubleMap.putIfAbsent(short, double) instead 
net.openhft.collect.map.ShortFloatMap.putIfAbsent(Short, Float)
          Use specialization ShortFloatMap.putIfAbsent(short, float) instead 
net.openhft.collect.map.ShortIntMap.putIfAbsent(Short, Integer)
          Use specialization ShortIntMap.putIfAbsent(short, int) instead 
net.openhft.collect.map.ShortLongMap.putIfAbsent(Short, Long)
          Use specialization ShortLongMap.putIfAbsent(short, long) instead 
net.openhft.collect.map.ShortShortMap.putIfAbsent(Short, Short)
          Use specialization ShortShortMap.putIfAbsent(short, short) instead 
net.openhft.collect.map.ShortObjMap.putIfAbsent(Short, V)
          Use specialization ShortObjMap.putIfAbsent(short, Object) instead 
net.openhft.collect.ByteCollection.remove(Object)
          Use specialization ByteCollection.removeByte(byte) instead 
net.openhft.collect.CharCollection.remove(Object)
          Use specialization CharCollection.removeChar(char) instead 
net.openhft.collect.DoubleCollection.remove(Object)
          Use specialization DoubleCollection.removeDouble(double) instead 
net.openhft.collect.FloatCollection.remove(Object)
          Use specialization FloatCollection.removeFloat(float) instead 
net.openhft.collect.IntCollection.remove(Object)
          Use specialization IntCollection.removeInt(int) instead 
net.openhft.collect.LongCollection.remove(Object)
          Use specialization LongCollection.removeLong(long) instead 
net.openhft.collect.ShortCollection.remove(Object)
          Use specialization ShortCollection.removeShort(short) instead 
net.openhft.collect.map.ByteByteMap.remove(Object)
          Use specialization ByteByteMap.remove(byte) instead 
net.openhft.collect.map.ByteCharMap.remove(Object)
          Use specialization ByteCharMap.remove(byte) instead 
net.openhft.collect.map.ByteDoubleMap.remove(Object)
          Use specialization ByteDoubleMap.remove(byte) instead 
net.openhft.collect.map.ByteFloatMap.remove(Object)
          Use specialization ByteFloatMap.remove(byte) instead 
net.openhft.collect.map.ByteIntMap.remove(Object)
          Use specialization ByteIntMap.remove(byte) instead 
net.openhft.collect.map.ByteLongMap.remove(Object)
          Use specialization ByteLongMap.remove(byte) instead 
net.openhft.collect.map.ByteObjMap.remove(Object)
          Use specialization ByteObjMap.remove(byte) instead 
net.openhft.collect.map.ByteShortMap.remove(Object)
          Use specialization ByteShortMap.remove(byte) instead 
net.openhft.collect.map.CharByteMap.remove(Object)
          Use specialization CharByteMap.remove(char) instead 
net.openhft.collect.map.CharCharMap.remove(Object)
          Use specialization CharCharMap.remove(char) instead 
net.openhft.collect.map.CharDoubleMap.remove(Object)
          Use specialization CharDoubleMap.remove(char) instead 
net.openhft.collect.map.CharFloatMap.remove(Object)
          Use specialization CharFloatMap.remove(char) instead 
net.openhft.collect.map.CharIntMap.remove(Object)
          Use specialization CharIntMap.remove(char) instead 
net.openhft.collect.map.CharLongMap.remove(Object)
          Use specialization CharLongMap.remove(char) instead 
net.openhft.collect.map.CharObjMap.remove(Object)
          Use specialization CharObjMap.remove(char) instead 
net.openhft.collect.map.CharShortMap.remove(Object)
          Use specialization CharShortMap.remove(char) instead 
net.openhft.collect.map.DoubleByteMap.remove(Object)
          Use specialization DoubleByteMap.remove(double) instead 
net.openhft.collect.map.DoubleCharMap.remove(Object)
          Use specialization DoubleCharMap.remove(double) instead 
net.openhft.collect.map.DoubleDoubleMap.remove(Object)
          Use specialization DoubleDoubleMap.remove(double) instead 
net.openhft.collect.map.DoubleFloatMap.remove(Object)
          Use specialization DoubleFloatMap.remove(double) instead 
net.openhft.collect.map.DoubleIntMap.remove(Object)
          Use specialization DoubleIntMap.remove(double) instead 
net.openhft.collect.map.DoubleLongMap.remove(Object)
          Use specialization DoubleLongMap.remove(double) instead 
net.openhft.collect.map.DoubleObjMap.remove(Object)
          Use specialization DoubleObjMap.remove(double) instead 
net.openhft.collect.map.DoubleShortMap.remove(Object)
          Use specialization DoubleShortMap.remove(double) instead 
net.openhft.collect.map.FloatByteMap.remove(Object)
          Use specialization FloatByteMap.remove(float) instead 
net.openhft.collect.map.FloatCharMap.remove(Object)
          Use specialization FloatCharMap.remove(float) instead 
net.openhft.collect.map.FloatDoubleMap.remove(Object)
          Use specialization FloatDoubleMap.remove(float) instead 
net.openhft.collect.map.FloatFloatMap.remove(Object)
          Use specialization FloatFloatMap.remove(float) instead 
net.openhft.collect.map.FloatIntMap.remove(Object)
          Use specialization FloatIntMap.remove(float) instead 
net.openhft.collect.map.FloatLongMap.remove(Object)
          Use specialization FloatLongMap.remove(float) instead 
net.openhft.collect.map.FloatObjMap.remove(Object)
          Use specialization FloatObjMap.remove(float) instead 
net.openhft.collect.map.FloatShortMap.remove(Object)
          Use specialization FloatShortMap.remove(float) instead 
net.openhft.collect.map.IntByteMap.remove(Object)
          Use specialization IntByteMap.remove(int) instead 
net.openhft.collect.map.IntCharMap.remove(Object)
          Use specialization IntCharMap.remove(int) instead 
net.openhft.collect.map.IntDoubleMap.remove(Object)
          Use specialization IntDoubleMap.remove(int) instead 
net.openhft.collect.map.IntFloatMap.remove(Object)
          Use specialization IntFloatMap.remove(int) instead 
net.openhft.collect.map.IntIntMap.remove(Object)
          Use specialization IntIntMap.remove(int) instead 
net.openhft.collect.map.IntLongMap.remove(Object)
          Use specialization IntLongMap.remove(int) instead 
net.openhft.collect.map.IntObjMap.remove(Object)
          Use specialization IntObjMap.remove(int) instead 
net.openhft.collect.map.IntShortMap.remove(Object)
          Use specialization IntShortMap.remove(int) instead 
net.openhft.collect.map.LongByteMap.remove(Object)
          Use specialization LongByteMap.remove(long) instead 
net.openhft.collect.map.LongCharMap.remove(Object)
          Use specialization LongCharMap.remove(long) instead 
net.openhft.collect.map.LongDoubleMap.remove(Object)
          Use specialization LongDoubleMap.remove(long) instead 
net.openhft.collect.map.LongFloatMap.remove(Object)
          Use specialization LongFloatMap.remove(long) instead 
net.openhft.collect.map.LongIntMap.remove(Object)
          Use specialization LongIntMap.remove(long) instead 
net.openhft.collect.map.LongLongMap.remove(Object)
          Use specialization LongLongMap.remove(long) instead 
net.openhft.collect.map.LongObjMap.remove(Object)
          Use specialization LongObjMap.remove(long) instead 
net.openhft.collect.map.LongShortMap.remove(Object)
          Use specialization LongShortMap.remove(long) instead 
net.openhft.collect.map.ObjByteMap.remove(Object)
          Use specialization ObjByteMap.removeAsByte(Object) instead 
net.openhft.collect.map.ObjCharMap.remove(Object)
          Use specialization ObjCharMap.removeAsChar(Object) instead 
net.openhft.collect.map.ObjDoubleMap.remove(Object)
          Use specialization ObjDoubleMap.removeAsDouble(Object) instead 
net.openhft.collect.map.ObjFloatMap.remove(Object)
          Use specialization ObjFloatMap.removeAsFloat(Object) instead 
net.openhft.collect.map.ObjIntMap.remove(Object)
          Use specialization ObjIntMap.removeAsInt(Object) instead 
net.openhft.collect.map.ObjLongMap.remove(Object)
          Use specialization ObjLongMap.removeAsLong(Object) instead 
net.openhft.collect.map.ObjShortMap.remove(Object)
          Use specialization ObjShortMap.removeAsShort(Object) instead 
net.openhft.collect.map.ShortByteMap.remove(Object)
          Use specialization ShortByteMap.remove(short) instead 
net.openhft.collect.map.ShortCharMap.remove(Object)
          Use specialization ShortCharMap.remove(short) instead 
net.openhft.collect.map.ShortDoubleMap.remove(Object)
          Use specialization ShortDoubleMap.remove(short) instead 
net.openhft.collect.map.ShortFloatMap.remove(Object)
          Use specialization ShortFloatMap.remove(short) instead 
net.openhft.collect.map.ShortIntMap.remove(Object)
          Use specialization ShortIntMap.remove(short) instead 
net.openhft.collect.map.ShortLongMap.remove(Object)
          Use specialization ShortLongMap.remove(short) instead 
net.openhft.collect.map.ShortObjMap.remove(Object)
          Use specialization ShortObjMap.remove(short) instead 
net.openhft.collect.map.ShortShortMap.remove(Object)
          Use specialization ShortShortMap.remove(short) instead 
net.openhft.collect.map.ByteByteMap.remove(Object, Object)
          Use specialization ByteByteMap.remove(byte, byte) instead 
net.openhft.collect.map.ByteCharMap.remove(Object, Object)
          Use specialization ByteCharMap.remove(byte, char) instead 
net.openhft.collect.map.ByteDoubleMap.remove(Object, Object)
          Use specialization ByteDoubleMap.remove(byte, double) instead 
net.openhft.collect.map.ByteFloatMap.remove(Object, Object)
          Use specialization ByteFloatMap.remove(byte, float) instead 
net.openhft.collect.map.ByteIntMap.remove(Object, Object)
          Use specialization ByteIntMap.remove(byte, int) instead 
net.openhft.collect.map.ByteLongMap.remove(Object, Object)
          Use specialization ByteLongMap.remove(byte, long) instead 
net.openhft.collect.map.ByteObjMap.remove(Object, Object)
          Use specialization ByteObjMap.remove(byte, Object) instead 
net.openhft.collect.map.ByteShortMap.remove(Object, Object)
          Use specialization ByteShortMap.remove(byte, short) instead 
net.openhft.collect.map.CharByteMap.remove(Object, Object)
          Use specialization CharByteMap.remove(char, byte) instead 
net.openhft.collect.map.CharCharMap.remove(Object, Object)
          Use specialization CharCharMap.remove(char, char) instead 
net.openhft.collect.map.CharDoubleMap.remove(Object, Object)
          Use specialization CharDoubleMap.remove(char, double) instead 
net.openhft.collect.map.CharFloatMap.remove(Object, Object)
          Use specialization CharFloatMap.remove(char, float) instead 
net.openhft.collect.map.CharIntMap.remove(Object, Object)
          Use specialization CharIntMap.remove(char, int) instead 
net.openhft.collect.map.CharLongMap.remove(Object, Object)
          Use specialization CharLongMap.remove(char, long) instead 
net.openhft.collect.map.CharObjMap.remove(Object, Object)
          Use specialization CharObjMap.remove(char, Object) instead 
net.openhft.collect.map.CharShortMap.remove(Object, Object)
          Use specialization CharShortMap.remove(char, short) instead 
net.openhft.collect.map.DoubleByteMap.remove(Object, Object)
          Use specialization DoubleByteMap.remove(double, byte) instead 
net.openhft.collect.map.DoubleCharMap.remove(Object, Object)
          Use specialization DoubleCharMap.remove(double, char) instead 
net.openhft.collect.map.DoubleDoubleMap.remove(Object, Object)
          Use specialization DoubleDoubleMap.remove(double, double) instead 
net.openhft.collect.map.DoubleFloatMap.remove(Object, Object)
          Use specialization DoubleFloatMap.remove(double, float) instead 
net.openhft.collect.map.DoubleIntMap.remove(Object, Object)
          Use specialization DoubleIntMap.remove(double, int) instead 
net.openhft.collect.map.DoubleLongMap.remove(Object, Object)
          Use specialization DoubleLongMap.remove(double, long) instead 
net.openhft.collect.map.DoubleObjMap.remove(Object, Object)
          Use specialization DoubleObjMap.remove(double, Object) instead 
net.openhft.collect.map.DoubleShortMap.remove(Object, Object)
          Use specialization DoubleShortMap.remove(double, short) instead 
net.openhft.collect.map.FloatByteMap.remove(Object, Object)
          Use specialization FloatByteMap.remove(float, byte) instead 
net.openhft.collect.map.FloatCharMap.remove(Object, Object)
          Use specialization FloatCharMap.remove(float, char) instead 
net.openhft.collect.map.FloatDoubleMap.remove(Object, Object)
          Use specialization FloatDoubleMap.remove(float, double) instead 
net.openhft.collect.map.FloatFloatMap.remove(Object, Object)
          Use specialization FloatFloatMap.remove(float, float) instead 
net.openhft.collect.map.FloatIntMap.remove(Object, Object)
          Use specialization FloatIntMap.remove(float, int) instead 
net.openhft.collect.map.FloatLongMap.remove(Object, Object)
          Use specialization FloatLongMap.remove(float, long) instead 
net.openhft.collect.map.FloatObjMap.remove(Object, Object)
          Use specialization FloatObjMap.remove(float, Object) instead 
net.openhft.collect.map.FloatShortMap.remove(Object, Object)
          Use specialization FloatShortMap.remove(float, short) instead 
net.openhft.collect.map.IntByteMap.remove(Object, Object)
          Use specialization IntByteMap.remove(int, byte) instead 
net.openhft.collect.map.IntCharMap.remove(Object, Object)
          Use specialization IntCharMap.remove(int, char) instead 
net.openhft.collect.map.IntDoubleMap.remove(Object, Object)
          Use specialization IntDoubleMap.remove(int, double) instead 
net.openhft.collect.map.IntFloatMap.remove(Object, Object)
          Use specialization IntFloatMap.remove(int, float) instead 
net.openhft.collect.map.IntIntMap.remove(Object, Object)
          Use specialization IntIntMap.remove(int, int) instead 
net.openhft.collect.map.IntLongMap.remove(Object, Object)
          Use specialization IntLongMap.remove(int, long) instead 
net.openhft.collect.map.IntObjMap.remove(Object, Object)
          Use specialization IntObjMap.remove(int, Object) instead 
net.openhft.collect.map.IntShortMap.remove(Object, Object)
          Use specialization IntShortMap.remove(int, short) instead 
net.openhft.collect.map.LongByteMap.remove(Object, Object)
          Use specialization LongByteMap.remove(long, byte) instead 
net.openhft.collect.map.LongCharMap.remove(Object, Object)
          Use specialization LongCharMap.remove(long, char) instead 
net.openhft.collect.map.LongDoubleMap.remove(Object, Object)
          Use specialization LongDoubleMap.remove(long, double) instead 
net.openhft.collect.map.LongFloatMap.remove(Object, Object)
          Use specialization LongFloatMap.remove(long, float) instead 
net.openhft.collect.map.LongIntMap.remove(Object, Object)
          Use specialization LongIntMap.remove(long, int) instead 
net.openhft.collect.map.LongLongMap.remove(Object, Object)
          Use specialization LongLongMap.remove(long, long) instead 
net.openhft.collect.map.LongObjMap.remove(Object, Object)
          Use specialization LongObjMap.remove(long, Object) instead 
net.openhft.collect.map.LongShortMap.remove(Object, Object)
          Use specialization LongShortMap.remove(long, short) instead 
net.openhft.collect.map.ObjByteMap.remove(Object, Object)
          Use specialization ObjByteMap.remove(Object, byte) instead 
net.openhft.collect.map.ObjCharMap.remove(Object, Object)
          Use specialization ObjCharMap.remove(Object, char) instead 
net.openhft.collect.map.ObjDoubleMap.remove(Object, Object)
          Use specialization ObjDoubleMap.remove(Object, double) instead 
net.openhft.collect.map.ObjFloatMap.remove(Object, Object)
          Use specialization ObjFloatMap.remove(Object, float) instead 
net.openhft.collect.map.ObjIntMap.remove(Object, Object)
          Use specialization ObjIntMap.remove(Object, int) instead 
net.openhft.collect.map.ObjLongMap.remove(Object, Object)
          Use specialization ObjLongMap.remove(Object, long) instead 
net.openhft.collect.map.ObjShortMap.remove(Object, Object)
          Use specialization ObjShortMap.remove(Object, short) instead 
net.openhft.collect.map.ShortByteMap.remove(Object, Object)
          Use specialization ShortByteMap.remove(short, byte) instead 
net.openhft.collect.map.ShortCharMap.remove(Object, Object)
          Use specialization ShortCharMap.remove(short, char) instead 
net.openhft.collect.map.ShortDoubleMap.remove(Object, Object)
          Use specialization ShortDoubleMap.remove(short, double) instead 
net.openhft.collect.map.ShortFloatMap.remove(Object, Object)
          Use specialization ShortFloatMap.remove(short, float) instead 
net.openhft.collect.map.ShortIntMap.remove(Object, Object)
          Use specialization ShortIntMap.remove(short, int) instead 
net.openhft.collect.map.ShortLongMap.remove(Object, Object)
          Use specialization ShortLongMap.remove(short, long) instead 
net.openhft.collect.map.ShortObjMap.remove(Object, Object)
          Use specialization ShortObjMap.remove(short, Object) instead 
net.openhft.collect.map.ShortShortMap.remove(Object, Object)
          Use specialization ShortShortMap.remove(short, short) instead 
net.openhft.collect.map.ByteByteMap.replace(Byte, Byte)
          Use specialization ByteByteMap.replace(byte, byte) instead 
net.openhft.collect.map.ByteByteMap.replace(Byte, Byte, Byte)
          Use specialization ByteByteMap.replace(byte, byte, byte) instead 
net.openhft.collect.map.ByteCharMap.replace(Byte, Character)
          Use specialization ByteCharMap.replace(byte, char) instead 
net.openhft.collect.map.ByteCharMap.replace(Byte, Character, Character)
          Use specialization ByteCharMap.replace(byte, char, char) instead 
net.openhft.collect.map.ByteDoubleMap.replace(Byte, Double)
          Use specialization ByteDoubleMap.replace(byte, double) instead 
net.openhft.collect.map.ByteDoubleMap.replace(Byte, Double, Double)
          Use specialization ByteDoubleMap.replace(byte, double, double) instead 
net.openhft.collect.map.ByteFloatMap.replace(Byte, Float)
          Use specialization ByteFloatMap.replace(byte, float) instead 
net.openhft.collect.map.ByteFloatMap.replace(Byte, Float, Float)
          Use specialization ByteFloatMap.replace(byte, float, float) instead 
net.openhft.collect.map.ByteIntMap.replace(Byte, Integer)
          Use specialization ByteIntMap.replace(byte, int) instead 
net.openhft.collect.map.ByteIntMap.replace(Byte, Integer, Integer)
          Use specialization ByteIntMap.replace(byte, int, int) instead 
net.openhft.collect.map.ByteLongMap.replace(Byte, Long)
          Use specialization ByteLongMap.replace(byte, long) instead 
net.openhft.collect.map.ByteLongMap.replace(Byte, Long, Long)
          Use specialization ByteLongMap.replace(byte, long, long) instead 
net.openhft.collect.map.ByteShortMap.replace(Byte, Short)
          Use specialization ByteShortMap.replace(byte, short) instead 
net.openhft.collect.map.ByteShortMap.replace(Byte, Short, Short)
          Use specialization ByteShortMap.replace(byte, short, short) instead 
net.openhft.collect.map.ByteObjMap.replace(Byte, V)
          Use specialization ByteObjMap.replace(byte, Object) instead 
net.openhft.collect.map.ByteObjMap.replace(Byte, V, V)
          Use specialization ByteObjMap.replace(byte, Object, Object) instead 
net.openhft.collect.map.CharByteMap.replace(Character, Byte)
          Use specialization CharByteMap.replace(char, byte) instead 
net.openhft.collect.map.CharByteMap.replace(Character, Byte, Byte)
          Use specialization CharByteMap.replace(char, byte, byte) instead 
net.openhft.collect.map.CharCharMap.replace(Character, Character)
          Use specialization CharCharMap.replace(char, char) instead 
net.openhft.collect.map.CharCharMap.replace(Character, Character, Character)
          Use specialization CharCharMap.replace(char, char, char) instead 
net.openhft.collect.map.CharDoubleMap.replace(Character, Double)
          Use specialization CharDoubleMap.replace(char, double) instead 
net.openhft.collect.map.CharDoubleMap.replace(Character, Double, Double)
          Use specialization CharDoubleMap.replace(char, double, double) instead 
net.openhft.collect.map.CharFloatMap.replace(Character, Float)
          Use specialization CharFloatMap.replace(char, float) instead 
net.openhft.collect.map.CharFloatMap.replace(Character, Float, Float)
          Use specialization CharFloatMap.replace(char, float, float) instead 
net.openhft.collect.map.CharIntMap.replace(Character, Integer)
          Use specialization CharIntMap.replace(char, int) instead 
net.openhft.collect.map.CharIntMap.replace(Character, Integer, Integer)
          Use specialization CharIntMap.replace(char, int, int) instead 
net.openhft.collect.map.CharLongMap.replace(Character, Long)
          Use specialization CharLongMap.replace(char, long) instead 
net.openhft.collect.map.CharLongMap.replace(Character, Long, Long)
          Use specialization CharLongMap.replace(char, long, long) instead 
net.openhft.collect.map.CharShortMap.replace(Character, Short)
          Use specialization CharShortMap.replace(char, short) instead 
net.openhft.collect.map.CharShortMap.replace(Character, Short, Short)
          Use specialization CharShortMap.replace(char, short, short) instead 
net.openhft.collect.map.CharObjMap.replace(Character, V)
          Use specialization CharObjMap.replace(char, Object) instead 
net.openhft.collect.map.CharObjMap.replace(Character, V, V)
          Use specialization CharObjMap.replace(char, Object, Object) instead 
net.openhft.collect.map.DoubleByteMap.replace(Double, Byte)
          Use specialization DoubleByteMap.replace(double, byte) instead 
net.openhft.collect.map.DoubleByteMap.replace(Double, Byte, Byte)
          Use specialization DoubleByteMap.replace(double, byte, byte) instead 
net.openhft.collect.map.DoubleCharMap.replace(Double, Character)
          Use specialization DoubleCharMap.replace(double, char) instead 
net.openhft.collect.map.DoubleCharMap.replace(Double, Character, Character)
          Use specialization DoubleCharMap.replace(double, char, char) instead 
net.openhft.collect.map.DoubleDoubleMap.replace(Double, Double)
          Use specialization DoubleDoubleMap.replace(double, double) instead 
net.openhft.collect.map.DoubleDoubleMap.replace(Double, Double, Double)
          Use specialization DoubleDoubleMap.replace(double, double, double) instead 
net.openhft.collect.map.DoubleFloatMap.replace(Double, Float)
          Use specialization DoubleFloatMap.replace(double, float) instead 
net.openhft.collect.map.DoubleFloatMap.replace(Double, Float, Float)
          Use specialization DoubleFloatMap.replace(double, float, float) instead 
net.openhft.collect.map.DoubleIntMap.replace(Double, Integer)
          Use specialization DoubleIntMap.replace(double, int) instead 
net.openhft.collect.map.DoubleIntMap.replace(Double, Integer, Integer)
          Use specialization DoubleIntMap.replace(double, int, int) instead 
net.openhft.collect.map.DoubleLongMap.replace(Double, Long)
          Use specialization DoubleLongMap.replace(double, long) instead 
net.openhft.collect.map.DoubleLongMap.replace(Double, Long, Long)
          Use specialization DoubleLongMap.replace(double, long, long) instead 
net.openhft.collect.map.DoubleShortMap.replace(Double, Short)
          Use specialization DoubleShortMap.replace(double, short) instead 
net.openhft.collect.map.DoubleShortMap.replace(Double, Short, Short)
          Use specialization DoubleShortMap.replace(double, short, short) instead 
net.openhft.collect.map.DoubleObjMap.replace(Double, V)
          Use specialization DoubleObjMap.replace(double, Object) instead 
net.openhft.collect.map.DoubleObjMap.replace(Double, V, V)
          Use specialization DoubleObjMap.replace(double, Object, Object) instead 
net.openhft.collect.map.FloatByteMap.replace(Float, Byte)
          Use specialization FloatByteMap.replace(float, byte) instead 
net.openhft.collect.map.FloatByteMap.replace(Float, Byte, Byte)
          Use specialization FloatByteMap.replace(float, byte, byte) instead 
net.openhft.collect.map.FloatCharMap.replace(Float, Character)
          Use specialization FloatCharMap.replace(float, char) instead 
net.openhft.collect.map.FloatCharMap.replace(Float, Character, Character)
          Use specialization FloatCharMap.replace(float, char, char) instead 
net.openhft.collect.map.FloatDoubleMap.replace(Float, Double)
          Use specialization FloatDoubleMap.replace(float, double) instead 
net.openhft.collect.map.FloatDoubleMap.replace(Float, Double, Double)
          Use specialization FloatDoubleMap.replace(float, double, double) instead 
net.openhft.collect.map.FloatFloatMap.replace(Float, Float)
          Use specialization FloatFloatMap.replace(float, float) instead 
net.openhft.collect.map.FloatFloatMap.replace(Float, Float, Float)
          Use specialization FloatFloatMap.replace(float, float, float) instead 
net.openhft.collect.map.FloatIntMap.replace(Float, Integer)
          Use specialization FloatIntMap.replace(float, int) instead 
net.openhft.collect.map.FloatIntMap.replace(Float, Integer, Integer)
          Use specialization FloatIntMap.replace(float, int, int) instead 
net.openhft.collect.map.FloatLongMap.replace(Float, Long)
          Use specialization FloatLongMap.replace(float, long) instead 
net.openhft.collect.map.FloatLongMap.replace(Float, Long, Long)
          Use specialization FloatLongMap.replace(float, long, long) instead 
net.openhft.collect.map.FloatShortMap.replace(Float, Short)
          Use specialization FloatShortMap.replace(float, short) instead 
net.openhft.collect.map.FloatShortMap.replace(Float, Short, Short)
          Use specialization FloatShortMap.replace(float, short, short) instead 
net.openhft.collect.map.FloatObjMap.replace(Float, V)
          Use specialization FloatObjMap.replace(float, Object) instead 
net.openhft.collect.map.FloatObjMap.replace(Float, V, V)
          Use specialization FloatObjMap.replace(float, Object, Object) instead 
net.openhft.collect.map.IntByteMap.replace(Integer, Byte)
          Use specialization IntByteMap.replace(int, byte) instead 
net.openhft.collect.map.IntByteMap.replace(Integer, Byte, Byte)
          Use specialization IntByteMap.replace(int, byte, byte) instead 
net.openhft.collect.map.IntCharMap.replace(Integer, Character)
          Use specialization IntCharMap.replace(int, char) instead 
net.openhft.collect.map.IntCharMap.replace(Integer, Character, Character)
          Use specialization IntCharMap.replace(int, char, char) instead 
net.openhft.collect.map.IntDoubleMap.replace(Integer, Double)
          Use specialization IntDoubleMap.replace(int, double) instead 
net.openhft.collect.map.IntDoubleMap.replace(Integer, Double, Double)
          Use specialization IntDoubleMap.replace(int, double, double) instead 
net.openhft.collect.map.IntFloatMap.replace(Integer, Float)
          Use specialization IntFloatMap.replace(int, float) instead 
net.openhft.collect.map.IntFloatMap.replace(Integer, Float, Float)
          Use specialization IntFloatMap.replace(int, float, float) instead 
net.openhft.collect.map.IntIntMap.replace(Integer, Integer)
          Use specialization IntIntMap.replace(int, int) instead 
net.openhft.collect.map.IntIntMap.replace(Integer, Integer, Integer)
          Use specialization IntIntMap.replace(int, int, int) instead 
net.openhft.collect.map.IntLongMap.replace(Integer, Long)
          Use specialization IntLongMap.replace(int, long) instead 
net.openhft.collect.map.IntLongMap.replace(Integer, Long, Long)
          Use specialization IntLongMap.replace(int, long, long) instead 
net.openhft.collect.map.IntShortMap.replace(Integer, Short)
          Use specialization IntShortMap.replace(int, short) instead 
net.openhft.collect.map.IntShortMap.replace(Integer, Short, Short)
          Use specialization IntShortMap.replace(int, short, short) instead 
net.openhft.collect.map.IntObjMap.replace(Integer, V)
          Use specialization IntObjMap.replace(int, Object) instead 
net.openhft.collect.map.IntObjMap.replace(Integer, V, V)
          Use specialization IntObjMap.replace(int, Object, Object) instead 
net.openhft.collect.map.ObjByteMap.replace(K, Byte)
          Use specialization ObjByteMap.replace(Object, byte) instead 
net.openhft.collect.map.ObjByteMap.replace(K, Byte, Byte)
          Use specialization ObjByteMap.replace(Object, byte, byte) instead 
net.openhft.collect.map.ObjCharMap.replace(K, Character)
          Use specialization ObjCharMap.replace(Object, char) instead 
net.openhft.collect.map.ObjCharMap.replace(K, Character, Character)
          Use specialization ObjCharMap.replace(Object, char, char) instead 
net.openhft.collect.map.ObjDoubleMap.replace(K, Double)
          Use specialization ObjDoubleMap.replace(Object, double) instead 
net.openhft.collect.map.ObjDoubleMap.replace(K, Double, Double)
          Use specialization ObjDoubleMap.replace(Object, double, double) instead 
net.openhft.collect.map.ObjFloatMap.replace(K, Float)
          Use specialization ObjFloatMap.replace(Object, float) instead 
net.openhft.collect.map.ObjFloatMap.replace(K, Float, Float)
          Use specialization ObjFloatMap.replace(Object, float, float) instead 
net.openhft.collect.map.ObjIntMap.replace(K, Integer)
          Use specialization ObjIntMap.replace(Object, int) instead 
net.openhft.collect.map.ObjIntMap.replace(K, Integer, Integer)
          Use specialization ObjIntMap.replace(Object, int, int) instead 
net.openhft.collect.map.ObjLongMap.replace(K, Long)
          Use specialization ObjLongMap.replace(Object, long) instead 
net.openhft.collect.map.ObjLongMap.replace(K, Long, Long)
          Use specialization ObjLongMap.replace(Object, long, long) instead 
net.openhft.collect.map.ObjShortMap.replace(K, Short)
          Use specialization ObjShortMap.replace(Object, short) instead 
net.openhft.collect.map.ObjShortMap.replace(K, Short, Short)
          Use specialization ObjShortMap.replace(Object, short, short) instead 
net.openhft.collect.map.LongByteMap.replace(Long, Byte)
          Use specialization LongByteMap.replace(long, byte) instead 
net.openhft.collect.map.LongByteMap.replace(Long, Byte, Byte)
          Use specialization LongByteMap.replace(long, byte, byte) instead 
net.openhft.collect.map.LongCharMap.replace(Long, Character)
          Use specialization LongCharMap.replace(long, char) instead 
net.openhft.collect.map.LongCharMap.replace(Long, Character, Character)
          Use specialization LongCharMap.replace(long, char, char) instead 
net.openhft.collect.map.LongDoubleMap.replace(Long, Double)
          Use specialization LongDoubleMap.replace(long, double) instead 
net.openhft.collect.map.LongDoubleMap.replace(Long, Double, Double)
          Use specialization LongDoubleMap.replace(long, double, double) instead 
net.openhft.collect.map.LongFloatMap.replace(Long, Float)
          Use specialization LongFloatMap.replace(long, float) instead 
net.openhft.collect.map.LongFloatMap.replace(Long, Float, Float)
          Use specialization LongFloatMap.replace(long, float, float) instead 
net.openhft.collect.map.LongIntMap.replace(Long, Integer)
          Use specialization LongIntMap.replace(long, int) instead 
net.openhft.collect.map.LongIntMap.replace(Long, Integer, Integer)
          Use specialization LongIntMap.replace(long, int, int) instead 
net.openhft.collect.map.LongLongMap.replace(Long, Long)
          Use specialization LongLongMap.replace(long, long) instead 
net.openhft.collect.map.LongLongMap.replace(Long, Long, Long)
          Use specialization LongLongMap.replace(long, long, long) instead 
net.openhft.collect.map.LongShortMap.replace(Long, Short)
          Use specialization LongShortMap.replace(long, short) instead 
net.openhft.collect.map.LongShortMap.replace(Long, Short, Short)
          Use specialization LongShortMap.replace(long, short, short) instead 
net.openhft.collect.map.LongObjMap.replace(Long, V)
          Use specialization LongObjMap.replace(long, Object) instead 
net.openhft.collect.map.LongObjMap.replace(Long, V, V)
          Use specialization LongObjMap.replace(long, Object, Object) instead 
net.openhft.collect.map.ShortByteMap.replace(Short, Byte)
          Use specialization ShortByteMap.replace(short, byte) instead 
net.openhft.collect.map.ShortByteMap.replace(Short, Byte, Byte)
          Use specialization ShortByteMap.replace(short, byte, byte) instead 
net.openhft.collect.map.ShortCharMap.replace(Short, Character)
          Use specialization ShortCharMap.replace(short, char) instead 
net.openhft.collect.map.ShortCharMap.replace(Short, Character, Character)
          Use specialization ShortCharMap.replace(short, char, char) instead 
net.openhft.collect.map.ShortDoubleMap.replace(Short, Double)
          Use specialization ShortDoubleMap.replace(short, double) instead 
net.openhft.collect.map.ShortDoubleMap.replace(Short, Double, Double)
          Use specialization ShortDoubleMap.replace(short, double, double) instead 
net.openhft.collect.map.ShortFloatMap.replace(Short, Float)
          Use specialization ShortFloatMap.replace(short, float) instead 
net.openhft.collect.map.ShortFloatMap.replace(Short, Float, Float)
          Use specialization ShortFloatMap.replace(short, float, float) instead 
net.openhft.collect.map.ShortIntMap.replace(Short, Integer)
          Use specialization ShortIntMap.replace(short, int) instead 
net.openhft.collect.map.ShortIntMap.replace(Short, Integer, Integer)
          Use specialization ShortIntMap.replace(short, int, int) instead 
net.openhft.collect.map.ShortLongMap.replace(Short, Long)
          Use specialization ShortLongMap.replace(short, long) instead 
net.openhft.collect.map.ShortLongMap.replace(Short, Long, Long)
          Use specialization ShortLongMap.replace(short, long, long) instead 
net.openhft.collect.map.ShortShortMap.replace(Short, Short)
          Use specialization ShortShortMap.replace(short, short) instead 
net.openhft.collect.map.ShortShortMap.replace(Short, Short, Short)
          Use specialization ShortShortMap.replace(short, short, short) instead 
net.openhft.collect.map.ShortObjMap.replace(Short, V)
          Use specialization ShortObjMap.replace(short, Object) instead 
net.openhft.collect.map.ShortObjMap.replace(Short, V, V)
          Use specialization ShortObjMap.replace(short, Object, Object) instead 
net.openhft.collect.ByteCollection.toArray()
          Use specialization ByteCollection.toByteArray() instead 
net.openhft.collect.CharCollection.toArray()
          Use specialization CharCollection.toCharArray() instead 
net.openhft.collect.DoubleCollection.toArray()
          Use specialization DoubleCollection.toDoubleArray() instead 
net.openhft.collect.FloatCollection.toArray()
          Use specialization FloatCollection.toFloatArray() instead 
net.openhft.collect.IntCollection.toArray()
          Use specialization IntCollection.toIntArray() instead 
net.openhft.collect.LongCollection.toArray()
          Use specialization LongCollection.toLongArray() instead 
net.openhft.collect.ShortCollection.toArray()
          Use specialization ShortCollection.toShortArray() instead 
net.openhft.collect.ByteCollection.toArray(T[])
          Use specialization ByteCollection.toArray(byte[]) instead 
net.openhft.collect.CharCollection.toArray(T[])
          Use specialization CharCollection.toArray(char[]) instead 
net.openhft.collect.DoubleCollection.toArray(T[])
          Use specialization DoubleCollection.toArray(double[]) instead 
net.openhft.collect.FloatCollection.toArray(T[])
          Use specialization FloatCollection.toArray(float[]) instead 
net.openhft.collect.IntCollection.toArray(T[])
          Use specialization IntCollection.toArray(int[]) instead 
net.openhft.collect.LongCollection.toArray(T[])
          Use specialization LongCollection.toArray(long[]) instead 
net.openhft.collect.ShortCollection.toArray(T[])
          Use specialization ShortCollection.toArray(short[]) instead 
 

Overview  Package  Class  Tree   Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES