it.unimi.dsi.fastutil.shorts.Short2IntArrayMap Maven / Gradle / Ivy
Show all versions of fastutil Show documentation
/* Copyright (C) 1991-2016 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
or any other header that includes
because the implicit include comes before any feature
test macros that may be defined in a source file before it first
explicitly includes a system header. GCC knows the name of this
header in order to preinclude it. */
/* glibc's intent is to support the IEC 559 math functionality, real
and complex. If the GCC (4.9 and later) predefined macros
specifying compiler intent are available, use them to determine
whether the overall intent is to support these features; otherwise,
presume an older compiler has intent to support these features and
define these macros by default. */
/* wchar_t uses Unicode 9.0.0. Version 9.0 of the Unicode Standard is
synchronized with ISO/IEC 10646:2014, fourth edition, plus
Amd. 1 and Amd. 2 and 273 characters from forthcoming 10646, fifth edition.
(Amd. 2 was published 2016-05-01,
see https://www.iso.org/obp/ui/#iso:std:iso-iec:10646:ed-4:v1:amd:2:v1:en) */
/* We do not support C11 . */
/* 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) */
/* Primitive-type-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.shorts;
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.ints.IntCollection;
import it.unimi.dsi.fastutil.ints.IntCollections;
import it.unimi.dsi.fastutil.ints.IntArraySet;
import it.unimi.dsi.fastutil.ints.IntArrays;
/**
* 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 Short2IntArrayMap extends AbstractShort2IntMap implements java.io.Serializable, Cloneable {
private static final long serialVersionUID = 1L;
/** The keys (valid up to {@link #size}, excluded). */
private transient short[] key;
/** The values (parallel to {@link #key}). */
private transient int[] 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 Short2IntArrayMap(final short[] key, final int[] 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 Short2IntArrayMap() {
this.key = ShortArrays.EMPTY_ARRAY;
this.value = IntArrays.EMPTY_ARRAY;
}
/**
* Creates a new empty array map of given capacity.
*
* @param capacity
* the initial capacity.
*/
public Short2IntArrayMap(final int capacity) {
this.key = new short[capacity];
this.value = new int[capacity];
}
/**
* Creates a new empty array map copying the entries of a given map.
*
* @param m
* a map.
*/
public Short2IntArrayMap(final Short2IntMap m) {
this(m.size());
putAll(m);
}
/**
* Creates a new empty array map copying the entries of a given map.
*
* @param m
* a map.
*/
public Short2IntArrayMap(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 Short2IntArrayMap(final short[] key, final int[] 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;
}
public Entry next() {
if (!hasNext()) throw new NoSuchElementException();
return new AbstractShort2IntMap.BasicEntry(key[curr = next], 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);
}
};
}
public ObjectIterator fastIterator() {
return new AbstractObjectIterator() {
int next = 0, curr = -1;
final BasicEntry entry = new BasicEntry(((short) 0), (0));
public boolean hasNext() {
return next < size;
}
public Entry next() {
if (!hasNext()) throw new NoSuchElementException();
entry.key = key[curr = next];
entry.value = 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);
}
};
}
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 Short)) return false;
if (e.getValue() == null || !(e.getValue() instanceof Integer)) return false;
final short k = ((((Short) (e.getKey())).shortValue()));
return Short2IntArrayMap.this.containsKey(k) && ((Short2IntArrayMap.this.get(k)) == (((((Integer) (e.getValue())).intValue()))));
}
@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 Short)) return false;
if (e.getValue() == null || !(e.getValue() instanceof Integer)) return false;
final short k = ((((Short) (e.getKey())).shortValue()));
final int v = ((((Integer) (e.getValue())).intValue()));
final int oldPos = Short2IntArrayMap.this.findKey(k);
if (oldPos == -1 || !((v) == (Short2IntArrayMap.this.value[oldPos]))) return false;
final int tail = size - oldPos - 1;
System.arraycopy(Short2IntArrayMap.this.key, oldPos + 1, Short2IntArrayMap.this.key, oldPos, tail);
System.arraycopy(Short2IntArrayMap.this.value, oldPos + 1, Short2IntArrayMap.this.value, oldPos, tail);
Short2IntArrayMap.this.size--;
return true;
}
}
public FastEntrySet short2IntEntrySet() {
return new EntrySet();
}
private int findKey(final short k) {
final short[] key = this.key;
for (int i = size; i-- != 0;)
if (((key[i]) == (k))) return i;
return -1;
}
public int get(final short k) {
final short[] key = this.key;
for (int i = size; i-- != 0;)
if (((key[i]) == (k))) return value[i];
return defRetValue;
}
public int size() {
return size;
}
@Override
public void clear() {
size = 0;
}
@Override
public boolean containsKey(final short k) {
return findKey(k) != -1;
}
@Override
public boolean containsValue(int v) {
for (int i = size; i-- != 0;)
if (((value[i]) == (v))) return true;
return false;
}
@Override
public boolean isEmpty() {
return size == 0;
}
@Override
public int put(short k, int v) {
final int oldKey = findKey(k);
if (oldKey != -1) {
final int oldValue = value[oldKey];
value[oldKey] = v;
return oldValue;
}
if (size == key.length) {
final short[] newKey = new short[size == 0 ? 2 : size * 2];
final int[] newValue = new int[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
public int remove(final short k) {
final int oldPos = findKey(k);
if (oldPos == -1) return defRetValue;
final int oldValue = 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--;
return oldValue;
}
@Override
public ShortSet keySet() {
return new ShortArraySet(key, size);
}
@Override
public IntCollection values() {
return IntCollections.unmodifiable(new IntArraySet(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.
*/
public Short2IntArrayMap clone() {
Short2IntArrayMap c;
try {
c = (Short2IntArrayMap) 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.writeShort(key[i]);
s.writeInt(value[i]);
}
}
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
key = new short[size];
value = new int[size];
for (int i = 0; i < size; i++) {
key[i] = s.readShort();
value[i] = s.readInt();
}
}
}