it.unimi.dsi.fastutil.floats.Float2ObjectArrayMap Maven / Gradle / Ivy
Show all versions of fastutil Show documentation
/* Generic definitions */
/* Assertions (useful to generate conditional code) */
/* Current type and class (and size, if applicable) */
/* Value methods */
/* Interfaces (keys) */
/* Interfaces (values) */
/* Abstract implementations (keys) */
/* Abstract implementations (values) */
/* Static containers (keys) */
/* Static containers (values) */
/* Implementations */
/* Synchronized wrappers */
/* Unmodifiable wrappers */
/* Other wrappers */
/* Methods (keys) */
/* Methods (values) */
/* Methods (keys/values) */
/* Methods that have special names depending on keys (but the special names depend on values) */
/* Equality */
/* Object/Reference-only definitions (keys) */
/* Primitive-type-only definitions (keys) */
/* Object/Reference-only definitions (values) */
/*
* Copyright (C) 2007-2016 Sebastiano Vigna
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package it.unimi.dsi.fastutil.floats;
import java.util.Map;
import java.util.NoSuchElementException;
import it.unimi.dsi.fastutil.objects.AbstractObjectIterator;
import it.unimi.dsi.fastutil.objects.AbstractObjectSet;
import it.unimi.dsi.fastutil.objects.ObjectIterator;
import it.unimi.dsi.fastutil.objects.ObjectCollection;
import it.unimi.dsi.fastutil.objects.ObjectCollections;
import it.unimi.dsi.fastutil.objects.ObjectArraySet;
import it.unimi.dsi.fastutil.objects.ObjectArrays;
/**
* A simple, brute-force implementation of a map based on two parallel backing
* arrays.
*
*
* The main purpose of this implementation is that of wrapping cleanly the
* brute-force approach to the storage of a very small number of pairs: just put
* them into two parallel arrays and scan linearly to find an item.
*/
public class Float2ObjectArrayMap extends AbstractFloat2ObjectMap
implements
java.io.Serializable,
Cloneable {
private static final long serialVersionUID = 1L;
/** The keys (valid up to {@link #size}, excluded). */
private transient float[] key;
/** The values (parallel to {@link #key}). */
private transient Object[] value;
/** The number of valid entries in {@link #key} and {@link #value}. */
private int size;
/**
* Creates a new empty array map with given key and value backing arrays.
* The resulting map will have as many entries as the given arrays.
*
*
* It is responsibility of the caller that the elements of key
* are distinct.
*
* @param key
* the key array.
* @param value
* the value array (it must have the same length as
* key).
*/
public Float2ObjectArrayMap(final float[] key, final Object[] value) {
this.key = key;
this.value = value;
size = key.length;
if (key.length != value.length)
throw new IllegalArgumentException(
"Keys and values have different lengths (" + key.length
+ ", " + value.length + ")");
}
/**
* Creates a new empty array map.
*/
public Float2ObjectArrayMap() {
this.key = FloatArrays.EMPTY_ARRAY;
this.value = ObjectArrays.EMPTY_ARRAY;
}
/**
* Creates a new empty array map of given capacity.
*
* @param capacity
* the initial capacity.
*/
public Float2ObjectArrayMap(final int capacity) {
this.key = new float[capacity];
this.value = new Object[capacity];
}
/**
* Creates a new empty array map copying the entries of a given map.
*
* @param m
* a map.
*/
public Float2ObjectArrayMap(final Float2ObjectMap m) {
this(m.size());
putAll(m);
}
/**
* Creates a new empty array map copying the entries of a given map.
*
* @param m
* a map.
*/
public Float2ObjectArrayMap(final Map m) {
this(m.size());
putAll(m);
}
/**
* Creates a new array map with given key and value backing arrays, using
* the given number of elements.
*
*
* It is responsibility of the caller that the first size
* elements of key are distinct.
*
* @param key
* the key array.
* @param value
* the value array (it must have the same length as
* key).
* @param size
* the number of valid elements in key and
* value.
*/
public Float2ObjectArrayMap(final float[] key, final Object[] value,
final int size) {
this.key = key;
this.value = value;
this.size = size;
if (key.length != value.length)
throw new IllegalArgumentException(
"Keys and values have different lengths (" + key.length
+ ", " + value.length + ")");
if (size > key.length)
throw new IllegalArgumentException("The provided size (" + size
+ ") is larger than or equal to the backing-arrays size ("
+ key.length + ")");
}
private final class EntrySet
extends
AbstractObjectSet>
implements
FastEntrySet {
@Override
public ObjectIterator> iterator() {
return new AbstractObjectIterator>() {
int curr = -1, next = 0;
public boolean hasNext() {
return next < size;
}
@SuppressWarnings("unchecked")
public Entry next() {
if (!hasNext())
throw new NoSuchElementException();
return new AbstractFloat2ObjectMap.BasicEntry(
key[curr = next], (V) value[next++]);
}
public void remove() {
if (curr == -1)
throw new IllegalStateException();
curr = -1;
final int tail = size-- - next--;
System.arraycopy(key, next + 1, key, next, tail);
System.arraycopy(value, next + 1, value, next, tail);
value[size] = null;
}
};
}
public ObjectIterator> fastIterator() {
return new AbstractObjectIterator>() {
int next = 0, curr = -1;
final BasicEntry entry = new BasicEntry((0), (null));
public boolean hasNext() {
return next < size;
}
@SuppressWarnings("unchecked")
public Entry next() {
if (!hasNext())
throw new NoSuchElementException();
entry.key = key[curr = next];
entry.value = (V) value[next++];
return entry;
}
public void remove() {
if (curr == -1)
throw new IllegalStateException();
curr = -1;
final int tail = size-- - next--;
System.arraycopy(key, next + 1, key, next, tail);
System.arraycopy(value, next + 1, value, next, tail);
value[size] = null;
}
};
}
public int size() {
return size;
}
public boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
final Map.Entry e = (Map.Entry) o;
if (e.getKey() == null || !(e.getKey() instanceof Float))
return false;
final float k = ((((Float) (e.getKey())).floatValue()));
return Float2ObjectArrayMap.this.containsKey(k)
&& ((Float2ObjectArrayMap.this.get(k)) == null ? ((e
.getValue())) == null : (Float2ObjectArrayMap.this
.get(k)).equals((e.getValue())));
}
@SuppressWarnings("unchecked")
@Override
public boolean remove(final Object o) {
if (!(o instanceof Map.Entry))
return false;
final Map.Entry e = (Map.Entry) o;
if (e.getKey() == null || !(e.getKey() instanceof Float))
return false;
final float k = ((((Float) (e.getKey())).floatValue()));
final V v = ((V) e.getValue());
final int oldPos = Float2ObjectArrayMap.this.findKey(k);
if (oldPos == -1
|| !((v) == null
? (Float2ObjectArrayMap.this.value[oldPos]) == null
: (v).equals(Float2ObjectArrayMap.this.value[oldPos])))
return false;
final int tail = size - oldPos - 1;
System.arraycopy(Float2ObjectArrayMap.this.key, oldPos + 1,
Float2ObjectArrayMap.this.key, oldPos, tail);
System.arraycopy(Float2ObjectArrayMap.this.value, oldPos + 1,
Float2ObjectArrayMap.this.value, oldPos, tail);
Float2ObjectArrayMap.this.size--;
Float2ObjectArrayMap.this.value[size] = null;
return true;
}
}
public FastEntrySet float2ObjectEntrySet() {
return new EntrySet();
}
private int findKey(final float k) {
final float[] key = this.key;
for (int i = size; i-- != 0;)
if ((Float.floatToIntBits(key[i]) == Float.floatToIntBits(k)))
return i;
return -1;
}
@SuppressWarnings("unchecked")
public V get(final float k) {
final float[] key = this.key;
for (int i = size; i-- != 0;)
if ((Float.floatToIntBits(key[i]) == Float.floatToIntBits(k)))
return (V) value[i];
return defRetValue;
}
public int size() {
return size;
}
@Override
public void clear() {
for (int i = size; i-- != 0;) {
value[i] = null;
}
size = 0;
}
@Override
public boolean containsKey(final float k) {
return findKey(k) != -1;
}
@Override
public boolean containsValue(Object v) {
for (int i = size; i-- != 0;)
if (((value[i]) == null ? (v) == null : (value[i]).equals(v)))
return true;
return false;
}
@Override
public boolean isEmpty() {
return size == 0;
}
@Override
@SuppressWarnings("unchecked")
public V put(float k, V v) {
final int oldKey = findKey(k);
if (oldKey != -1) {
final V oldValue = (V) value[oldKey];
value[oldKey] = v;
return oldValue;
}
if (size == key.length) {
final float[] newKey = new float[size == 0 ? 2 : size * 2];
final Object[] newValue = new Object[size == 0 ? 2 : size * 2];
for (int i = size; i-- != 0;) {
newKey[i] = key[i];
newValue[i] = value[i];
}
key = newKey;
value = newValue;
}
key[size] = k;
value[size] = v;
size++;
return defRetValue;
}
@Override
@SuppressWarnings("unchecked")
public V remove(final float k) {
final int oldPos = findKey(k);
if (oldPos == -1)
return defRetValue;
final V oldValue = (V) value[oldPos];
final int tail = size - oldPos - 1;
System.arraycopy(key, oldPos + 1, key, oldPos, tail);
System.arraycopy(value, oldPos + 1, value, oldPos, tail);
size--;
value[size] = null;
return oldValue;
}
@Override
public FloatSet keySet() {
return new FloatArraySet(key, size);
}
@Override
public ObjectCollection values() {
return ObjectCollections
.unmodifiable(new ObjectArraySet(value, size));
}
/**
* Returns a deep copy of this map.
*
*
* This method performs a deep copy of this hash map; the data stored in the
* map, however, is not cloned. Note that this makes a difference only for
* object keys.
*
* @return a deep copy of this map.
*/
@SuppressWarnings("unchecked")
public Float2ObjectArrayMap clone() {
Float2ObjectArrayMap c;
try {
c = (Float2ObjectArrayMap) super.clone();
} catch (CloneNotSupportedException cantHappen) {
throw new InternalError();
}
c.key = key.clone();
c.value = value.clone();
return c;
}
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
s.defaultWriteObject();
for (int i = 0; i < size; i++) {
s.writeFloat(key[i]);
s.writeObject(value[i]);
}
}
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
key = new float[size];
value = new Object[size];
for (int i = 0; i < size; i++) {
key[i] = s.readFloat();
value[i] = s.readObject();
}
}
}