package org.infinispan.commons.equivalence;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
/**
* Custom hash-based linked list map which accepts no null keys nor null values,
* where equality and hash code calculations are done based on passed
* {@link org.infinispan.commons.equivalence.Equivalence} function implementations for keys
* and values, as opposed to relying on their own equals/hashCode/toString
* implementations. This is handy when using key/values whose mentioned
* methods cannot be overriden, i.e. arrays, and in situations where users
* want to avoid using wrapper objects.
*
* In order to provide linked list behaviour, entries are linked with each
* other in a predictable order.
*
* @author Galder Zamarreño
* @since 6.0
* @deprecated
*/
public class EquivalentLinkedHashMap<K, V> extends EquivalentHashMap<K, V> {
private transient LinkedNode<K, V> header;
private final IterationOrder iterationOrder;
public EquivalentLinkedHashMap(int initialCapacity, float loadFactor,
IterationOrder iterationOrder,
Equivalence<? super K> keyEq, Equivalence<? super V> valueEq) {
super(initialCapacity, loadFactor, keyEq, valueEq);
this.iterationOrder = iterationOrder;
addFirstEntry();
}
private void addFirstEntry() {
header = createLinkedNode();
header.before = header;
header.after = header;
}
@Override
void addEntry(int index, K key, V value, int hash) {
super.addEntry(index, key, value, hash);
LinkedNode<K,V> eldest = header.after;
if (removeEldestEntry(eldest)) {
remove(eldest.getKey());
}
}
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
return false;
}
@SuppressWarnings("unchecked")
private <K, V> LinkedNode<K, V> createLinkedNode() {
return new LinkedNode<K, V>(null, -1, null, null);
}
@Override
Node<K, V> createNode(K key, V value, int hash, Node<K, V> node) {
LinkedNode<K, V> linkedNode = new LinkedNode<K, V>(key, hash, value, node);
linkedNode.addBefore(header);
return linkedNode;
}
@Override
public V get(Object key) {
LinkedNode<K, V> n = getNode(key);
return n == null ? null : n.recordAccess(this);
}
@Override
public V remove(Object key) {
LinkedNode<K, V> prevNode = removeNode(key);
return prevNode == null ? null : prevNode.remove();
}
@Override
public void clear() {
super.clear();
header.before = header;
header.after = header;
}
private static final class LinkedNode<K, V> extends Node<K,V> {
LinkedNode<K, V> before;
LinkedNode<K, V> after;
private LinkedNode(K key, int hash, V value, Node<K, V> next) {
super(key, hash, value, next);
}
private V remove() {
before.after = after;
after.before = before;
return value;
}
private void addBefore(LinkedNode<K, V> entry) {
after = entry;
before = entry.before;
before.after = this;
after.before = this;
}
V recordAccess(EquivalentHashMap<K, V> m) {
EquivalentLinkedHashMap<K, V> linkedMap = (EquivalentLinkedHashMap<K, V>)m;
if (linkedMap.iterationOrder == IterationOrder.ACCESS_ORDER) {
linkedMap.modCount++;
remove();
addBefore(linkedMap.header);
}
return value;
}
@Override
protected V setValue(V value, EquivalentHashMap<K, V> map) {
V retValue = super.setValue(value, map);
recordAccess(map);
return retValue;
}
}
public enum IterationOrder {
ACCESS_ORDER, INSERT_ORDER;
public boolean toJdkAccessOrder() {
return this == ACCESS_ORDER;
}
}
/**
* Exported Entry for iterators
*/
private static class LinkedEntry<K,V> extends MapEntry<K,V> {
LinkedNode<K, V> before;
LinkedNode<K, V> after;
LinkedEntry(K key, V val, LinkedNode<K, V> before, LinkedNode<K, V> after, EquivalentHashMap<K, V> map) {
super(key, val, map);
this.before = before;
this.after = after;
}
}
private abstract class EquivalentLinkedHashIterator<T> implements Iterator<T> {
final EquivalentHashMap<K, V> map;
LinkedEntry<K, V> nextEntry;
LinkedEntry<K, V> lastReturned = null;
protected EquivalentLinkedHashIterator(EquivalentHashMap<K, V> map) {
this.map = map;
nextEntry = new LinkedEntry<K, V>(
header.after.key, header.after.value,
header.after.before, header.after.after, map);
}
/**
* The modCount value that the iterator believes that the backing
* List should have. If this expectation is violated, the iterator
* has detected concurrent modification.
*/
int expectedModCount = modCount;
public boolean hasNext() {
return !equals(nextEntry, header);
}
public void remove() {
if (lastReturned == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
EquivalentLinkedHashMap.this.remove(lastReturned.key);
lastReturned = null;
expectedModCount = modCount;
}
LinkedEntry<K,V> nextEntry() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (equals(nextEntry, header))
throw new NoSuchElementException();
LinkedEntry<K, V> e = nextEntry;
lastReturned = nextEntry;
nextEntry = new LinkedEntry<K, V>(
e.after.key, e.after.value,
e.after.before, e.after.after, map);
return e;
}
boolean equals(LinkedEntry<K, V> entry, LinkedNode<K, V> node) {
return entry.key == node.key
&& entry.val == node.value
&& entry.before == node.before
&& entry.after == node.after;
}
}
private class KeyIterator extends EquivalentLinkedHashIterator<K> {
protected KeyIterator(EquivalentHashMap<K, V> map) {
super(map);
}
public K next() {
return nextEntry().getKey();
}
}
private class ValueIterator extends EquivalentLinkedHashIterator<V> {
protected ValueIterator(EquivalentHashMap<K, V> map) {
super(map);
}
public V next() {
return nextEntry().val;
}
}
private class EntryIterator extends EquivalentLinkedHashIterator<Map.Entry<K, V>> {
protected EntryIterator(EquivalentHashMap<K, V> map) {
super(map);
}
public Map.Entry<K, V> next() {
return nextEntry();
}
}
Iterator<K> newKeyIterator() {
return new KeyIterator(this);
}
Iterator<V> newValueIterator() {
return new ValueIterator(this);
}
Iterator<Map.Entry<K,V>> newEntryIterator() {
return new EntryIterator(this);
}
}