java.io.SerializationHandleMap Maven / Gradle / Ivy
/*
* Copyright (C) 2010 The Android Open Source Project
*
* 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 java.io;
/**
* A specialization of IdentityHashMap for use when serializing objects.
* We need to assign each object we write an int 'handle' (densely packed but not starting
* at zero), and use the same handle any time we write the same object again.
*/
final class SerializationHandleMap {
/* Default load factor of 0.75; */
private static final int LOAD_FACTOR = 7500;
private Object[] keys;
private int[] values;
/* Actual number of key-value pairs. */
private int size;
/* Maximum number of elements that can be put in this map before having to rehash. */
private int threshold;
public SerializationHandleMap() {
this.size = 0;
this.threshold = 21; // Copied from IdentityHashMap.
int arraySize = (int) (((long) threshold * 10000) / LOAD_FACTOR);
resizeArrays(arraySize);
}
private void resizeArrays(int newSize) {
Object[] oldKeys = keys;
int[] oldValues = values;
this.keys = new Object[newSize];
this.values = new int[newSize];
if (oldKeys != null) {
for (int i = 0; i < oldKeys.length; ++i) {
Object key = oldKeys[i];
int value = oldValues[i];
int index = findIndex(key, keys);
keys[index] = key;
values[index] = value;
}
}
}
public int get(Object key) {
int index = findIndex(key, keys);
if (keys[index] == key) {
return values[index];
}
return -1;
}
/**
* Returns the index where the key is found at, or the index of the next
* empty spot if the key is not found in this table.
*/
private int findIndex(Object key, Object[] array) {
int length = array.length;
int index = getModuloHash(key, length);
int last = (index + length - 1) % length;
while (index != last) {
if (array[index] == key || array[index] == null) {
/*
* Found the key, or the next empty spot (which means key is not
* in the table)
*/
break;
}
index = (index + 1) % length;
}
return index;
}
private int getModuloHash(Object key, int length) {
return (System.identityHashCode(key) & 0x7FFFFFFF) % length;
}
public int put(Object key, int value) {
Object _key = key;
int _value = value;
int index = findIndex(_key, keys);
// if the key doesn't exist in the table
if (keys[index] != _key) {
if (++size > threshold) {
rehash();
index = findIndex(_key, keys);
}
// insert the key and assign the value to -1 initially
keys[index] = _key;
values[index] = -1;
}
// insert value to where it needs to go, return the old value
int result = values[index];
values[index] = _value;
return result;
}
private void rehash() {
int newSize = keys.length * 2;
resizeArrays(newSize);
threshold = (int) ((long) (keys.length) * LOAD_FACTOR / 10000);
}
public int remove(Object key) {
boolean hashedOk;
int index, next, hash;
int result;
Object object;
index = next = findIndex(key, keys);
if (keys[index] != key) {
return -1;
}
// store the value for this key
result = values[index];
// shift the following elements up if needed
// until we reach an empty spot
int length = keys.length;
while (true) {
next = (next + 2) % length;
object = keys[next];
if (object == null) {
break;
}
hash = getModuloHash(object, length);
hashedOk = hash > index;
if (next < index) {
hashedOk = hashedOk || (hash <= next);
} else {
hashedOk = hashedOk && (hash <= next);
}
if (!hashedOk) {
keys[index] = object;
values[index] = values[next];
index = next;
}
}
size--;
// clear both the key and the value
keys[index] = null;
values[index] = -1;
return result;
}
public boolean isEmpty() {
return size == 0;
}
}