/** {@inheritDoc} */
@Override
public boolean equals(Object other) {
if (!(other instanceof TLongFloatMap)) {
return false;
}
TLongFloatMap that = (TLongFloatMap) other;
if (that.size() != this.size()) {
return false;
}
float[] values = _values;
byte[] states = _states;
float this_no_entry_value = getNoEntryValue();
float that_no_entry_value = that.getNoEntryValue();
for (int i = values.length; i-- > 0; ) {
if (states[i] == FULL) {
long key = _set[i];
float that_value = that.get(key);
float this_value = values[i];
if ((this_value != that_value)
&& (this_value != this_no_entry_value)
&& (that_value != that_no_entry_value)) {
return false;
}
}
}
return true;
}
/** {@inheritDoc} */
public void putAll(TLongFloatMap map) {
ensureCapacity(map.size());
TLongFloatIterator iter = map.iterator();
while (iter.hasNext()) {
iter.advance();
this.put(iter.key(), iter.value());
}
}
@Override
public TFloatCollection valueCollection() {
synchronized (mutex) {
if (values == null) values = new TSynchronizedFloatCollection(m.valueCollection(), mutex);
return values;
}
}
@Override
public TLongSet keySet() {
synchronized (mutex) {
if (keySet == null) keySet = new TSynchronizedLongSet(m.keySet(), mutex);
return keySet;
}
}
/**
* Creates a new <code>TLongFloatHashMap</code> instance containing all of the entries in the map
* passed in.
*
* @param map a <tt>TLongFloatMap</tt> that will be duplicated.
*/
public TLongFloatHashMap(TLongFloatMap map) {
super(map.size());
if (map instanceof TLongFloatHashMap) {
TLongFloatHashMap hashmap = (TLongFloatHashMap) map;
this._loadFactor = hashmap._loadFactor;
this.no_entry_key = hashmap.no_entry_key;
this.no_entry_value = hashmap.no_entry_value;
//noinspection RedundantCast
if (this.no_entry_key != (long) 0) {
Arrays.fill(_set, this.no_entry_key);
}
//noinspection RedundantCast
if (this.no_entry_value != (float) 0) {
Arrays.fill(_values, this.no_entry_value);
}
setUp((int) Math.ceil(DEFAULT_CAPACITY / _loadFactor));
}
putAll(map);
}
@Override
public boolean equals(Object o) {
synchronized (mutex) {
return m.equals(o);
}
}
@Override
public int hashCode() {
synchronized (mutex) {
return m.hashCode();
}
}
@Override
public boolean adjustValue(long key, float amount) {
synchronized (mutex) {
return m.adjustValue(key, amount);
}
}
@Override
public float adjustOrPutValue(long key, float adjust_amount, float put_amount) {
synchronized (mutex) {
return m.adjustOrPutValue(key, adjust_amount, put_amount);
}
}
@Override
public boolean containsValue(float value) {
synchronized (mutex) {
return m.containsValue(value);
}
}
@Override
public float[] values(float[] array) {
synchronized (mutex) {
return m.values(array);
}
}
@Override
public boolean forEachEntry(TLongFloatProcedure procedure) {
synchronized (mutex) {
return m.forEachEntry(procedure);
}
}
@Override
public boolean isEmpty() {
synchronized (mutex) {
return m.isEmpty();
}
}
@Override
public float putIfAbsent(long key, float value) {
synchronized (mutex) {
return m.putIfAbsent(key, value);
}
}
@Override
public boolean forEachValue(TFloatProcedure procedure) {
synchronized (mutex) {
return m.forEachValue(procedure);
}
}
@Override
public float getNoEntryValue() {
return m.getNoEntryValue();
}
// these are unchanging over the life of the map, no need to lock
@Override
public long getNoEntryKey() {
return m.getNoEntryKey();
}
@Override
public TLongFloatIterator iterator() {
return m.iterator(); // Must be manually synched by user!
}
@Override
public String toString() {
synchronized (mutex) {
return m.toString();
}
}
@Override
public void transformValues(TFloatFunction function) {
synchronized (mutex) {
m.transformValues(function);
}
}
@Override
public int size() {
synchronized (mutex) {
return m.size();
}
}
@Override
public double distance(int i1, int i2) {
return (i1 == i2) ? 0. : cache.get(makeKey(i1 + min, i2 + min));
}
@Override
public boolean containsKey(long key) {
synchronized (mutex) {
return m.containsKey(key);
}
}
@Override
public long[] keys(long[] array) {
synchronized (mutex) {
return m.keys(array);
}
}
@Override
public float get(long key) {
synchronized (mutex) {
return m.get(key);
}
}
@Override
public float[] values() {
synchronized (mutex) {
return m.values();
}
}
@Override
public boolean retainEntries(TLongFloatProcedure procedure) {
synchronized (mutex) {
return m.retainEntries(procedure);
}
}
@Override
public long[] keys() {
synchronized (mutex) {
return m.keys();
}
}
@Override
public boolean increment(long key) {
synchronized (mutex) {
return m.increment(key);
}
}
@Override
public void clear() {
synchronized (mutex) {
m.clear();
}
}