/** Note the same entry instance is returned each time this method is called. */
public Entry next() {
if (!hasNext) throw new NoSuchElementException();
if (!valid) throw new GdxRuntimeException("#iterator() cannot be used nested.");
int[] keyTable = map.keyTable;
if (nextIndex == INDEX_ZERO) {
entry.key = 0;
entry.value = map.zeroValue;
} else {
entry.key = keyTable[nextIndex];
entry.value = map.valueTable[nextIndex];
}
currentIndex = nextIndex;
findNextIndex();
return entry;
}
/**
* Reads the given number of entries from the input stream, returning the corresponding tree.
*
* @param s the input stream.
* @param n the (positive) number of entries to read.
* @param pred the entry containing the key that preceeds the first key in the tree.
* @param succ the entry containing the key that follows the last key in the tree.
*/
@SuppressWarnings("unchecked")
private Entry<K> readTree(
final java.io.ObjectInputStream s, final int n, final Entry<K> pred, final Entry<K> succ)
throws java.io.IOException, ClassNotFoundException {
if (n == 1) {
final Entry<K> top = new Entry<K>((K) s.readObject());
top.pred(pred);
top.succ(succ);
top.black(true);
return top;
}
if (n == 2) {
/* We handle separately this case so that recursion will
*always* be on nonempty subtrees. */
final Entry<K> top = new Entry<K>((K) s.readObject());
top.black(true);
top.right(new Entry<K>((K) s.readObject()));
top.right.pred(top);
top.pred(pred);
top.right.succ(succ);
return top;
}
// The right subtree is the largest one.
final int rightN = n / 2, leftN = n - rightN - 1;
final Entry<K> top = new Entry<K>();
top.left(readTree(s, leftN, pred, top));
top.key = (K) s.readObject();
top.black(true);
top.right(readTree(s, rightN, top, succ));
if (n + 2 == ((n + 2) & -(n + 2)))
top.right.black(false); // Quick test for determining whether n + 2 is a power of 2.
return top;
}
/** Expunges stale entries from the table. */
private void expungeStaleEntries() {
Entry<K, V> e;
while ((e = (Entry<K, V>) queue.poll()) != null) {
int h = e.hash;
int i = indexFor(h, table.length);
Entry<K, V> prev = table[i];
Entry<K, V> p = prev;
while (p != null) {
Entry<K, V> next = p.next;
if (p == e) {
if (prev == e) table[i] = next;
else {
prev.next = next;
if (prev == next) {
throw new RuntimeException("circular");
}
}
e.next = null; // Help GC
e.key = null; // " "
size--;
break;
}
prev = p;
p = next;
}
}
}
private Node insert(Node h, Key key, Value value, int ht) {
int j;
Entry t = new Entry(key, value, null);
// external node
if (ht == 0) {
for (j = 0; j < h.m; j++) {
if (less(key, h.children[j].key)) break;
}
}
// internal node
else {
for (j = 0; j < h.m; j++) {
if ((j + 1 == h.m) || less(key, h.children[j + 1].key)) {
Node u = insert(h.children[j++].next, key, value, ht - 1);
if (u == null) return null;
t.key = u.children[0].key;
t.next = u;
break;
}
}
}
for (int i = h.m; i > j; i--) h.children[i] = h.children[i - 1];
h.children[j] = t;
h.m++;
if (h.m < M) return null;
else return split(h);
}
/**
* Add an entry to the cache. The entry may or may not exist in the cache yet. This method will
* usually mark unknown entries as cold and known entries as hot.
*
* @param key the key (may not be null)
* @param hash the hash
* @param value the value (may not be null)
* @param memory the memory used for the given entry
* @return the old value, or null if there was no resident entry
*/
synchronized V put(long key, int hash, V value, int memory) {
if (value == null) {
throw DataUtils.newIllegalArgumentException("The value may not be null");
}
V old;
Entry<V> e = find(key, hash);
if (e == null) {
old = null;
} else {
old = e.value;
remove(key, hash);
}
e = new Entry<V>();
e.key = key;
e.value = value;
e.memory = memory;
int index = hash & mask;
e.mapNext = entries[index];
entries[index] = e;
usedMemory += memory;
if (usedMemory > maxMemory && mapSize > 0) {
// an old entry needs to be removed
evict(e);
}
mapSize++;
// added entries are always added to the stack
addToStack(e);
return old;
}
private static <V> Entry<V> copy(Entry<V> old) {
Entry<V> e = new Entry<V>();
e.key = old.key;
e.value = old.value;
e.memory = old.memory;
e.topMove = old.topMove;
return e;
}
/** Note the same entry instance is returned each time this method is called. */
public Entry<K> next() {
if (!hasNext) throw new NoSuchElementException();
K[] keyTable = map.keyTable;
entry.key = keyTable[nextIndex];
entry.value = map.valueTable[nextIndex];
currentIndex = nextIndex;
findNextIndex();
return entry;
}
private Entry<E> makeEntry(E key) {
Entry<E> entry = new Entry<E>();
entry.index = size();
entry.key = key;
entry.priority = Double.NEGATIVE_INFINITY;
indexToEntry.add(entry);
keyToEntry.put(key, entry);
return entry;
}
/** Note the same entry instance is returned each time this method is called. */
public Entry<K> next() {
if (!hasNext) throw new NoSuchElementException();
if (!valid) throw new GdxRuntimeException("#iterator() cannot be used nested.");
K[] keyTable = map.keyTable;
entry.key = keyTable[nextIndex];
entry.value = map.valueTable[nextIndex];
currentIndex = nextIndex;
findNextIndex();
return entry;
}
@SuppressWarnings("unchecked")
public Entry<K> clone() {
Entry<K> c;
try {
c = (Entry<K>) super.clone();
} catch (CloneNotSupportedException cantHappen) {
throw new InternalError();
}
c.key = key;
c.info = info;
return c;
}
/**
* Express a BinaryTreeNode as a String.
*
* @return a String representing the BinaryTreeNode.
*/
public String toString() {
String s = "";
if (leftChild != null) {
s = "(" + leftChild.toString() + ")";
}
s = s + entry.key().toString() + entry.value();
if (rightChild != null) {
s = s + "(" + rightChild.toString() + ")";
}
return s;
}
public Map<String, Object> extractJson(String value) {
if (isNullOrEmpty(value)) {
return Collections.emptyMap();
}
final Map<String, Object> json;
try {
json = mapper.readValue(value, new TypeReference<Map<String, Object>>() {});
} catch (IOException e) {
return Collections.emptyMap();
}
final Map<String, Object> results = new HashMap<>(json.size());
for (Map.Entry<String, Object> mapEntry : json.entrySet()) {
for (Entry entry : parseValue(mapEntry.getKey(), mapEntry.getValue())) {
results.put(entry.key(), entry.value());
}
}
return results;
}
/** Transfers all entries from src to dest tables */
private void transfer(Entry[] src, Entry[] dest) {
for (int j = 0; j < src.length; ++j) {
Entry<K, V> e = src[j];
src[j] = null;
while (e != null) {
Entry<K, V> next = e.next;
Object key = e.key;
if (key == null) {
e.next = null; // Help GC
e.key = null; // " "
size--;
} else {
int i = indexFor(e.hash, dest.length);
e.next = dest[i];
if (e == e.next) {
throw new RuntimeException("circular");
}
dest[i] = e;
}
e = next;
}
}
}
public LuaValue key() {
return entry.key();
}
@Override
public void putAll(List<Entry<K, V>> entries) {
for (Entry<K, V> entry : entries) put(entry.key(), entry.value());
}