org.apache.commons.collections4.bidimap.TreeBidiMap Maven / Gradle / Ivy
Show all versions of commons-collections4 Show documentation
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.collections4.bidimap;
import static org.apache.commons.collections4.bidimap.TreeBidiMap.DataElement.KEY;
import static org.apache.commons.collections4.bidimap.TreeBidiMap.DataElement.VALUE;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.AbstractSet;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
import org.apache.commons.collections4.KeyValue;
import org.apache.commons.collections4.MapIterator;
import org.apache.commons.collections4.OrderedBidiMap;
import org.apache.commons.collections4.OrderedIterator;
import org.apache.commons.collections4.OrderedMapIterator;
import org.apache.commons.collections4.iterators.EmptyOrderedMapIterator;
import org.apache.commons.collections4.keyvalue.UnmodifiableMapEntry;
/**
* Red-Black tree-based implementation of BidiMap where all objects added
* implement the Comparable interface.
*
* This class guarantees that the map will be in both ascending key order
* and ascending value order, sorted according to the natural order for
* the key's and value's classes.
*
* This Map is intended for applications that need to be able to look
* up a key-value pairing by either key or value, and need to do so
* with equal efficiency.
*
* While that goal could be accomplished by taking a pair of TreeMaps
* and redirecting requests to the appropriate TreeMap (e.g.,
* containsKey would be directed to the TreeMap that maps values to
* keys, containsValue would be directed to the TreeMap that maps keys
* to values), there are problems with that implementation.
* If the data contained in the TreeMaps is large, the cost of redundant
* storage becomes significant. The {@link DualTreeBidiMap} and
* {@link DualHashBidiMap} implementations use this approach.
*
* This solution keeps minimizes the data storage by holding data only once.
* The red-black algorithm is based on {@link java.util.TreeMap}, but has been modified
* to simultaneously map a tree node by key and by value. This doubles the
* cost of put operations (but so does using two TreeMaps), and nearly doubles
* the cost of remove operations (there is a savings in that the lookup of the
* node to be removed only has to be performed once). And since only one node
* contains the key and value, storage is significantly less than that
* required by two TreeMaps.
*
* The Map.Entry instances returned by the appropriate methods will
* not allow setValue() and will throw an
* UnsupportedOperationException on attempts to call that method.
*
* @since 3.0 (previously DoubleOrderedMap v2.0)
* @version $Id: TreeBidiMap.java 1683951 2015-06-06 20:19:03Z tn $
*/
public class TreeBidiMap, V extends Comparable>
implements OrderedBidiMap, Serializable {
static enum DataElement {
KEY("key"), VALUE("value");
private final String description;
/**
* Create a new TreeBidiMap.DataElement.
*
* @param description the description for the element
*/
private DataElement(final String description) {
this.description = description;
}
@Override
public String toString() {
return description;
}
}
private static final long serialVersionUID = 721969328361807L;
private transient Node[] rootNode;
private transient int nodeCount = 0;
private transient int modifications = 0;
private transient Set keySet;
private transient Set valuesSet;
private transient Set> entrySet;
private transient Inverse inverse = null;
//-----------------------------------------------------------------------
/**
* Constructs a new empty TreeBidiMap.
*/
@SuppressWarnings("unchecked")
public TreeBidiMap() {
super();
rootNode = new Node[2];
}
/**
* Constructs a new TreeBidiMap by copying an existing Map.
*
* @param map the map to copy
* @throws ClassCastException if the keys/values in the map are
* not Comparable or are not mutually comparable
* @throws NullPointerException if any key or value in the map is null
*/
public TreeBidiMap(final Map map) {
this();
putAll(map);
}
//-----------------------------------------------------------------------
/**
* Returns the number of key-value mappings in this map.
*
* @return the number of key-value mappings in this map
*/
@Override
public int size() {
return nodeCount;
}
/**
* Checks whether the map is empty or not.
*
* @return true if the map is empty
*/
@Override
public boolean isEmpty() {
return nodeCount == 0;
}
/**
* Checks whether this map contains the a mapping for the specified key.
*
* The key must implement Comparable.
*
* @param key key whose presence in this map is to be tested
* @return true if this map contains a mapping for the specified key
* @throws ClassCastException if the key is of an inappropriate type
* @throws NullPointerException if the key is null
*/
@Override
public boolean containsKey(final Object key) {
checkKey(key);
return lookupKey(key) != null;
}
/**
* Checks whether this map contains the a mapping for the specified value.
*
* The value must implement Comparable.
*
* @param value value whose presence in this map is to be tested
* @return true if this map contains a mapping for the specified value
* @throws ClassCastException if the value is of an inappropriate type
* @throws NullPointerException if the value is null
*/
@Override
public boolean containsValue(final Object value) {
checkValue(value);
return lookupValue(value) != null;
}
/**
* Gets the value to which this map maps the specified key.
* Returns null if the map contains no mapping for this key.
*
* The key must implement Comparable.
*
* @param key key whose associated value is to be returned
* @return the value to which this map maps the specified key,
* or null if the map contains no mapping for this key
* @throws ClassCastException if the key is of an inappropriate type
* @throws NullPointerException if the key is null
*/
@Override
public V get(final Object key) {
checkKey(key);
final Node node = lookupKey(key);
return node == null ? null : node.getValue();
}
/**
* Puts the key-value pair into the map, replacing any previous pair.
*
* When adding a key-value pair, the value may already exist in the map
* against a different key. That mapping is removed, to ensure that the
* value only occurs once in the inverse map.
*
* BidiMap map1 = new TreeBidiMap();
* map.put("A","B"); // contains A mapped to B, as per Map
* map.put("A","C"); // contains A mapped to C, as per Map
*
* BidiMap map2 = new TreeBidiMap();
* map.put("A","B"); // contains A mapped to B, as per Map
* map.put("C","B"); // contains C mapped to B, key A is removed
*
*
* Both key and value must implement Comparable.
*
* @param key key with which the specified value is to be associated
* @param value value to be associated with the specified key
* @return the previous value for the key
* @throws ClassCastException if the key is of an inappropriate type
* @throws NullPointerException if the key is null
*/
@Override
public V put(final K key, final V value) {
final V result = get(key);
doPut(key, value);
return result;
}
/**
* Puts all the mappings from the specified map into this map.
*
* All keys and values must implement Comparable.
*
* @param map the map to copy from
*/
@Override
public void putAll(final Map map) {
for (final Map.Entry e : map.entrySet()) {
put(e.getKey(), e.getValue());
}
}
/**
* Removes the mapping for this key from this map if present.
*
* The key must implement Comparable.
*
* @param key key whose mapping is to be removed from the map.
* @return previous value associated with specified key,
* or null if there was no mapping for key.
* @throws ClassCastException if the key is of an inappropriate type
* @throws NullPointerException if the key is null
*/
@Override
public V remove(final Object key) {
return doRemoveKey(key);
}
/**
* Removes all mappings from this map.
*/
@Override
public void clear() {
modify();
nodeCount = 0;
rootNode[KEY.ordinal()] = null;
rootNode[VALUE.ordinal()] = null;
}
//-----------------------------------------------------------------------
/**
* Returns the key to which this map maps the specified value.
* Returns null if the map contains no mapping for this value.
*
* The value must implement Comparable.
*
* @param value value whose associated key is to be returned.
* @return the key to which this map maps the specified value,
* or null if the map contains no mapping for this value.
* @throws ClassCastException if the value is of an inappropriate type
* @throws NullPointerException if the value is null
*/
@Override
public K getKey(final Object value) {
checkValue(value);
final Node node = lookupValue(value);
return node == null ? null : node.getKey();
}
/**
* Removes the mapping for this value from this map if present.
*
* The value must implement Comparable.
*
* @param value value whose mapping is to be removed from the map
* @return previous key associated with specified value,
* or null if there was no mapping for value.
* @throws ClassCastException if the value is of an inappropriate type
* @throws NullPointerException if the value is null
*/
@Override
public K removeValue(final Object value) {
return doRemoveValue(value);
}
//-----------------------------------------------------------------------
/**
* Gets the first (lowest) key currently in this map.
*
* @return the first (lowest) key currently in this sorted map
* @throws NoSuchElementException if this map is empty
*/
@Override
public K firstKey() {
if (nodeCount == 0) {
throw new NoSuchElementException("Map is empty");
}
return leastNode(rootNode[KEY.ordinal()], KEY).getKey();
}
/**
* Gets the last (highest) key currently in this map.
*
* @return the last (highest) key currently in this sorted map
* @throws NoSuchElementException if this map is empty
*/
@Override
public K lastKey() {
if (nodeCount == 0) {
throw new NoSuchElementException("Map is empty");
}
return greatestNode(rootNode[KEY.ordinal()], KEY).getKey();
}
/**
* Gets the next key after the one specified.
*
* The key must implement Comparable.
*
* @param key the key to search for next from
* @return the next key, null if no match or at end
*/
@Override
public K nextKey(final K key) {
checkKey(key);
final Node node = nextGreater(lookupKey(key), KEY);
return node == null ? null : node.getKey();
}
/**
* Gets the previous key before the one specified.
*
* The key must implement Comparable.
*
* @param key the key to search for previous from
* @return the previous key, null if no match or at start
*/
@Override
public K previousKey(final K key) {
checkKey(key);
final Node node = nextSmaller(lookupKey(key), KEY);
return node == null ? null : node.getKey();
}
//-----------------------------------------------------------------------
/**
* Returns a set view of the keys contained in this map in key order.
*
* The set is backed by the map, so changes to the map are reflected in
* the set, and vice-versa. If the map is modified while an iteration over
* the set is in progress, the results of the iteration are undefined.
*
* The set supports element removal, which removes the corresponding mapping
* from the map. It does not support the add or addAll operations.
*
* @return a set view of the keys contained in this map.
*/
@Override
public Set keySet() {
if (keySet == null) {
keySet = new KeyView(KEY);
}
return keySet;
}
//-----------------------------------------------------------------------
/**
* Returns a set view of the values contained in this map in key order.
* The returned object can be cast to a Set.
*
* The set is backed by the map, so changes to the map are reflected in
* the set, and vice-versa. If the map is modified while an iteration over
* the set is in progress, the results of the iteration are undefined.
*
* The set supports element removal, which removes the corresponding mapping
* from the map. It does not support the add or addAll operations.
*
* @return a set view of the values contained in this map.
*/
@Override
public Set values() {
if (valuesSet == null) {
valuesSet = new ValueView(KEY);
}
return valuesSet;
}
//-----------------------------------------------------------------------
/**
* Returns a set view of the entries contained in this map in key order.
* For simple iteration through the map, the MapIterator is quicker.
*
* The set is backed by the map, so changes to the map are reflected in
* the set, and vice-versa. If the map is modified while an iteration over
* the set is in progress, the results of the iteration are undefined.
*
* The set supports element removal, which removes the corresponding mapping
* from the map. It does not support the add or addAll operations.
* The returned MapEntry objects do not support setValue.
*
* @return a set view of the values contained in this map.
*/
@Override
public Set> entrySet() {
if (entrySet == null) {
entrySet = new EntryView();
}
return entrySet;
}
//-----------------------------------------------------------------------
@Override
public OrderedMapIterator mapIterator() {
if (isEmpty()) {
return EmptyOrderedMapIterator.emptyOrderedMapIterator();
}
return new ViewMapIterator(KEY);
}
//-----------------------------------------------------------------------
/**
* Gets the inverse map for comparison.
*
* @return the inverse map
*/
@Override
public OrderedBidiMap inverseBidiMap() {
if (inverse == null) {
inverse = new Inverse();
}
return inverse;
}
//-----------------------------------------------------------------------
/**
* Compares for equals as per the API.
*
* @param obj the object to compare to
* @return true if equal
*/
@Override
public boolean equals(final Object obj) {
return this.doEquals(obj, KEY);
}
/**
* Gets the hash code value for this map as per the API.
*
* @return the hash code value for this map
*/
@Override
public int hashCode() {
return this.doHashCode(KEY);
}
/**
* Returns a string version of this Map in standard format.
*
* @return a standard format string version of the map
*/
@Override
public String toString() {
return this.doToString(KEY);
}
//-----------------------------------------------------------------------
/**
* Put logic.
*
* @param key the key, always the main map key
* @param value the value, always the main map value
*/
private void doPut(final K key, final V value) {
checkKeyAndValue(key, value);
// store previous and remove previous mappings
doRemoveKey(key);
doRemoveValue(value);
Node node = rootNode[KEY.ordinal()];
if (node == null) {
// map is empty
final Node root = new Node(key, value);
rootNode[KEY.ordinal()] = root;
rootNode[VALUE.ordinal()] = root;
grow();
} else {
// add new mapping
while (true) {
final int cmp = compare(key, node.getKey());
if (cmp == 0) {
// shouldn't happen
throw new IllegalArgumentException("Cannot store a duplicate key (\"" + key + "\") in this Map");
} else if (cmp < 0) {
if (node.getLeft(KEY) != null) {
node = node.getLeft(KEY);
} else {
final Node newNode = new Node(key, value);
insertValue(newNode);
node.setLeft(newNode, KEY);
newNode.setParent(node, KEY);
doRedBlackInsert(newNode, KEY);
grow();
break;
}
} else { // cmp > 0
if (node.getRight(KEY) != null) {
node = node.getRight(KEY);
} else {
final Node newNode = new Node(key, value);
insertValue(newNode);
node.setRight(newNode, KEY);
newNode.setParent(node, KEY);
doRedBlackInsert(newNode, KEY);
grow();
break;
}
}
}
}
}
private V doRemoveKey(final Object key) {
final Node node = lookupKey(key);
if (node == null) {
return null;
}
doRedBlackDelete(node);
return node.getValue();
}
private K doRemoveValue(final Object value) {
final Node node = lookupValue(value);
if (node == null) {
return null;
}
doRedBlackDelete(node);
return node.getKey();
}
/**
* do the actual lookup of a piece of data
*
* @param data the key or value to be looked up
* @param index the KEY or VALUE int
* @return the desired Node, or null if there is no mapping of the
* specified data
*/
@SuppressWarnings("unchecked")
private > Node lookup(final Object data, final DataElement dataElement) {
Node rval = null;
Node node = rootNode[dataElement.ordinal()];
while (node != null) {
final int cmp = compare((T) data, (T) node.getData(dataElement));
if (cmp == 0) {
rval = node;
break;
} else {
node = cmp < 0 ? node.getLeft(dataElement) : node.getRight(dataElement);
}
}
return rval;
}
private Node lookupKey(final Object key) {
return this.lookup(key, KEY);
}
private Node lookupValue(final Object value) {
return this.lookup(value, VALUE);
}
/**
* get the next larger node from the specified node
*
* @param node the node to be searched from
* @param index the KEY or VALUE int
* @return the specified node
*/
private Node nextGreater(final Node node, final DataElement dataElement) {
Node rval;
if (node == null) {
rval = null;
} else if (node.getRight(dataElement) != null) {
// everything to the node's right is larger. The least of
// the right node's descendants is the next larger node
rval = leastNode(node.getRight(dataElement), dataElement);
} else {
// traverse up our ancestry until we find an ancestor that
// is null or one whose left child is our ancestor. If we
// find a null, then this node IS the largest node in the
// tree, and there is no greater node. Otherwise, we are
// the largest node in the subtree on that ancestor's left
// ... and that ancestor is the next greatest node
Node parent = node.getParent(dataElement);
Node child = node;
while (parent != null && child == parent.getRight(dataElement)) {
child = parent;
parent = parent.getParent(dataElement);
}
rval = parent;
}
return rval;
}
/**
* get the next larger node from the specified node
*
* @param node the node to be searched from
* @param index the KEY or VALUE int
* @return the specified node
*/
private Node nextSmaller(final Node node, final DataElement dataElement) {
Node rval;
if (node == null) {
rval = null;
} else if (node.getLeft(dataElement) != null) {
// everything to the node's left is smaller. The greatest of
// the left node's descendants is the next smaller node
rval = greatestNode(node.getLeft(dataElement), dataElement);
} else {
// traverse up our ancestry until we find an ancestor that
// is null or one whose right child is our ancestor. If we
// find a null, then this node IS the largest node in the
// tree, and there is no greater node. Otherwise, we are
// the largest node in the subtree on that ancestor's right
// ... and that ancestor is the next greatest node
Node parent = node.getParent(dataElement);
Node child = node;
while (parent != null && child == parent.getLeft(dataElement)) {
child = parent;
parent = parent.getParent(dataElement);
}
rval = parent;
}
return rval;
}
//-----------------------------------------------------------------------
/**
* Compare two objects
*
* @param o1 the first object
* @param o2 the second object
*
* @return negative value if o1 < o2; 0 if o1 == o2; positive
* value if o1 > o2
*/
private static > int compare(final T o1, final T o2) {
return o1.compareTo(o2);
}
/**
* Find the least node from a given node.
*
* @param node the node from which we will start searching
* @param index the KEY or VALUE int
* @return the smallest node, from the specified node, in the
* specified mapping
*/
private Node leastNode(final Node node, final DataElement dataElement) {
Node rval = node;
if (rval != null) {
while (rval.getLeft(dataElement) != null) {
rval = rval.getLeft(dataElement);
}
}
return rval;
}
/**
* Find the greatest node from a given node.
*
* @param node the node from which we will start searching
* @param index the KEY or VALUE int
* @return the greatest node, from the specified node
*/
private Node greatestNode(final Node node, final DataElement dataElement) {
Node rval = node;
if (rval != null) {
while (rval.getRight(dataElement) != null) {
rval = rval.getRight(dataElement);
}
}
return rval;
}
/**
* copy the color from one node to another, dealing with the fact
* that one or both nodes may, in fact, be null
*
* @param from the node whose color we're copying; may be null
* @param to the node whose color we're changing; may be null
* @param index the KEY or VALUE int
*/
private void copyColor(final Node from, final Node to, final DataElement dataElement) {
if (to != null) {
if (from == null) {
// by default, make it black
to.setBlack(dataElement);
} else {
to.copyColor(from, dataElement);
}
}
}
/**
* is the specified node red? if the node does not exist, no, it's
* black, thank you
*
* @param node the node (may be null) in question
* @param index the KEY or VALUE int
*/
private static boolean isRed(final Node node, final DataElement dataElement) {
return node != null && node.isRed(dataElement);
}
/**
* is the specified black red? if the node does not exist, sure,
* it's black, thank you
*
* @param node the node (may be null) in question
* @param index the KEY or VALUE int
*/
private static boolean isBlack(final Node node, final DataElement dataElement) {
return node == null || node.isBlack(dataElement);
}
/**
* force a node (if it exists) red
*
* @param node the node (may be null) in question
* @param index the KEY or VALUE int
*/
private static void makeRed(final Node node, final DataElement dataElement) {
if (node != null) {
node.setRed(dataElement);
}
}
/**
* force a node (if it exists) black
*
* @param node the node (may be null) in question
* @param index the KEY or VALUE int
*/
private static void makeBlack(final Node node, final DataElement dataElement) {
if (node != null) {
node.setBlack(dataElement);
}
}
/**
* get a node's grandparent. mind you, the node, its parent, or
* its grandparent may not exist. no problem
*
* @param node the node (may be null) in question
* @param index the KEY or VALUE int
*/
private Node getGrandParent(final Node node, final DataElement dataElement) {
return getParent(getParent(node, dataElement), dataElement);
}
/**
* get a node's parent. mind you, the node, or its parent, may not
* exist. no problem
*
* @param node the node (may be null) in question
* @param index the KEY or VALUE int
*/
private Node getParent(final Node node, final DataElement dataElement) {
return node == null ? null : node.getParent(dataElement);
}
/**
* get a node's right child. mind you, the node may not exist. no
* problem
*
* @param node the node (may be null) in question
* @param index the KEY or VALUE int
*/
private Node getRightChild(final Node node, final DataElement dataElement) {
return node == null ? null : node.getRight(dataElement);
}
/**
* get a node's left child. mind you, the node may not exist. no
* problem
*
* @param node the node (may be null) in question
* @param index the KEY or VALUE int
*/
private Node getLeftChild(final Node node, final DataElement dataElement) {
return node == null ? null : node.getLeft(dataElement);
}
/**
* do a rotate left. standard fare in the world of balanced trees
*
* @param node the node to be rotated
* @param index the KEY or VALUE int
*/
private void rotateLeft(final Node node, final DataElement dataElement) {
final Node rightChild = node.getRight(dataElement);
node.setRight(rightChild.getLeft(dataElement), dataElement);
if (rightChild.getLeft(dataElement) != null) {
rightChild.getLeft(dataElement).setParent(node, dataElement);
}
rightChild.setParent(node.getParent(dataElement), dataElement);
if (node.getParent(dataElement) == null) {
// node was the root ... now its right child is the root
rootNode[dataElement.ordinal()] = rightChild;
} else if (node.getParent(dataElement).getLeft(dataElement) == node) {
node.getParent(dataElement).setLeft(rightChild, dataElement);
} else {
node.getParent(dataElement).setRight(rightChild, dataElement);
}
rightChild.setLeft(node, dataElement);
node.setParent(rightChild, dataElement);
}
/**
* do a rotate right. standard fare in the world of balanced trees
*
* @param node the node to be rotated
* @param index the KEY or VALUE int
*/
private void rotateRight(final Node node, final DataElement dataElement) {
final Node leftChild = node.getLeft(dataElement);
node.setLeft(leftChild.getRight(dataElement), dataElement);
if (leftChild.getRight(dataElement) != null) {
leftChild.getRight(dataElement).setParent(node, dataElement);
}
leftChild.setParent(node.getParent(dataElement), dataElement);
if (node.getParent(dataElement) == null) {
// node was the root ... now its left child is the root
rootNode[dataElement.ordinal()] = leftChild;
} else if (node.getParent(dataElement).getRight(dataElement) == node) {
node.getParent(dataElement).setRight(leftChild, dataElement);
} else {
node.getParent(dataElement).setLeft(leftChild, dataElement);
}
leftChild.setRight(node, dataElement);
node.setParent(leftChild, dataElement);
}
/**
* complicated red-black insert stuff. Based on Sun's TreeMap
* implementation, though it's barely recognizable any more
*
* @param insertedNode the node to be inserted
* @param dataElement the KEY or VALUE int
*/
private void doRedBlackInsert(final Node insertedNode, final DataElement dataElement) {
Node currentNode = insertedNode;
makeRed(currentNode, dataElement);
while (currentNode != null
&& currentNode != rootNode[dataElement.ordinal()]
&& isRed(currentNode.getParent(dataElement), dataElement)) {
if (currentNode.isLeftChild(dataElement)) {
final Node y = getRightChild(getGrandParent(currentNode, dataElement), dataElement);
if (isRed(y, dataElement)) {
makeBlack(getParent(currentNode, dataElement), dataElement);
makeBlack(y, dataElement);
makeRed(getGrandParent(currentNode, dataElement), dataElement);
currentNode = getGrandParent(currentNode, dataElement);
} else {
//dead code?
if (currentNode.isRightChild(dataElement)) {
currentNode = getParent(currentNode, dataElement);
rotateLeft(currentNode, dataElement);
}
makeBlack(getParent(currentNode, dataElement), dataElement);
makeRed(getGrandParent(currentNode, dataElement), dataElement);
if (getGrandParent(currentNode, dataElement) != null) {
rotateRight(getGrandParent(currentNode, dataElement), dataElement);
}
}
} else {
// just like clause above, except swap left for right
final Node y = getLeftChild(getGrandParent(currentNode, dataElement), dataElement);
if (isRed(y, dataElement)) {
makeBlack(getParent(currentNode, dataElement), dataElement);
makeBlack(y, dataElement);
makeRed(getGrandParent(currentNode, dataElement), dataElement);
currentNode = getGrandParent(currentNode, dataElement);
} else {
//dead code?
if (currentNode.isLeftChild(dataElement)) {
currentNode = getParent(currentNode, dataElement);
rotateRight(currentNode, dataElement);
}
makeBlack(getParent(currentNode, dataElement), dataElement);
makeRed(getGrandParent(currentNode, dataElement), dataElement);
if (getGrandParent(currentNode, dataElement) != null) {
rotateLeft(getGrandParent(currentNode, dataElement), dataElement);
}
}
}
}
makeBlack(rootNode[dataElement.ordinal()], dataElement);
}
/**
* complicated red-black delete stuff. Based on Sun's TreeMap
* implementation, though it's barely recognizable any more
*
* @param deletedNode the node to be deleted
*/
private void doRedBlackDelete(final Node deletedNode) {
for (final DataElement dataElement : DataElement.values()) {
// if deleted node has both left and children, swap with
// the next greater node
if (deletedNode.getLeft(dataElement) != null && deletedNode.getRight(dataElement) != null) {
swapPosition(nextGreater(deletedNode, dataElement), deletedNode, dataElement);
}
final Node replacement = deletedNode.getLeft(dataElement) != null ?
deletedNode.getLeft(dataElement) : deletedNode.getRight(dataElement);
if (replacement != null) {
replacement.setParent(deletedNode.getParent(dataElement), dataElement);
if (deletedNode.getParent(dataElement) == null) {
rootNode[dataElement.ordinal()] = replacement;
} else if (deletedNode == deletedNode.getParent(dataElement).getLeft(dataElement)) {
deletedNode.getParent(dataElement).setLeft(replacement, dataElement);
} else {
deletedNode.getParent(dataElement).setRight(replacement, dataElement);
}
deletedNode.setLeft(null, dataElement);
deletedNode.setRight(null, dataElement);
deletedNode.setParent(null, dataElement);
if (isBlack(deletedNode, dataElement)) {
doRedBlackDeleteFixup(replacement, dataElement);
}
} else {
// replacement is null
if (deletedNode.getParent(dataElement) == null) {
// empty tree
rootNode[dataElement.ordinal()] = null;
} else {
// deleted node had no children
if (isBlack(deletedNode, dataElement)) {
doRedBlackDeleteFixup(deletedNode, dataElement);
}
if (deletedNode.getParent(dataElement) != null) {
if (deletedNode == deletedNode.getParent(dataElement).getLeft(dataElement)) {
deletedNode.getParent(dataElement).setLeft(null, dataElement);
} else {
deletedNode.getParent(dataElement).setRight(null, dataElement);
}
deletedNode.setParent(null, dataElement);
}
}
}
}
shrink();
}
/**
* complicated red-black delete stuff. Based on Sun's TreeMap
* implementation, though it's barely recognizable any more. This
* rebalances the tree (somewhat, as red-black trees are not
* perfectly balanced -- perfect balancing takes longer)
*
* @param replacementNode the node being replaced
* @param dataElement the KEY or VALUE int
*/
private void doRedBlackDeleteFixup(final Node replacementNode, final DataElement dataElement) {
Node currentNode = replacementNode;
while (currentNode != rootNode[dataElement.ordinal()] && isBlack(currentNode, dataElement)) {
if (currentNode.isLeftChild(dataElement)) {
Node siblingNode = getRightChild(getParent(currentNode, dataElement), dataElement);
if (isRed(siblingNode, dataElement)) {
makeBlack(siblingNode, dataElement);
makeRed(getParent(currentNode, dataElement), dataElement);
rotateLeft(getParent(currentNode, dataElement), dataElement);
siblingNode = getRightChild(getParent(currentNode, dataElement), dataElement);
}
if (isBlack(getLeftChild(siblingNode, dataElement), dataElement)
&& isBlack(getRightChild(siblingNode, dataElement), dataElement)) {
makeRed(siblingNode, dataElement);
currentNode = getParent(currentNode, dataElement);
} else {
if (isBlack(getRightChild(siblingNode, dataElement), dataElement)) {
makeBlack(getLeftChild(siblingNode, dataElement), dataElement);
makeRed(siblingNode, dataElement);
rotateRight(siblingNode, dataElement);
siblingNode = getRightChild(getParent(currentNode, dataElement), dataElement);
}
copyColor(getParent(currentNode, dataElement), siblingNode, dataElement);
makeBlack(getParent(currentNode, dataElement), dataElement);
makeBlack(getRightChild(siblingNode, dataElement), dataElement);
rotateLeft(getParent(currentNode, dataElement), dataElement);
currentNode = rootNode[dataElement.ordinal()];
}
} else {
Node siblingNode = getLeftChild(getParent(currentNode, dataElement), dataElement);
if (isRed(siblingNode, dataElement)) {
makeBlack(siblingNode, dataElement);
makeRed(getParent(currentNode, dataElement), dataElement);
rotateRight(getParent(currentNode, dataElement), dataElement);
siblingNode = getLeftChild(getParent(currentNode, dataElement), dataElement);
}
if (isBlack(getRightChild(siblingNode, dataElement), dataElement)
&& isBlack(getLeftChild(siblingNode, dataElement), dataElement)) {
makeRed(siblingNode, dataElement);
currentNode = getParent(currentNode, dataElement);
} else {
if (isBlack(getLeftChild(siblingNode, dataElement), dataElement)) {
makeBlack(getRightChild(siblingNode, dataElement), dataElement);
makeRed(siblingNode, dataElement);
rotateLeft(siblingNode, dataElement);
siblingNode = getLeftChild(getParent(currentNode, dataElement), dataElement);
}
copyColor(getParent(currentNode, dataElement), siblingNode, dataElement);
makeBlack(getParent(currentNode, dataElement), dataElement);
makeBlack(getLeftChild(siblingNode, dataElement), dataElement);
rotateRight(getParent(currentNode, dataElement), dataElement);
currentNode = rootNode[dataElement.ordinal()];
}
}
}
makeBlack(currentNode, dataElement);
}
/**
* swap two nodes (except for their content), taking care of
* special cases where one is the other's parent ... hey, it
* happens.
*
* @param x one node
* @param y another node
* @param dataElement the KEY or VALUE int
*/
private void swapPosition(final Node x, final Node y, final DataElement dataElement) {
// Save initial values.
final Node xFormerParent = x.getParent(dataElement);
final Node xFormerLeftChild = x.getLeft(dataElement);
final Node xFormerRightChild = x.getRight(dataElement);
final Node yFormerParent = y.getParent(dataElement);
final Node yFormerLeftChild = y.getLeft(dataElement);
final Node yFormerRightChild = y.getRight(dataElement);
final boolean xWasLeftChild =
x.getParent(dataElement) != null && x == x.getParent(dataElement).getLeft(dataElement);
final boolean yWasLeftChild =
y.getParent(dataElement) != null && y == y.getParent(dataElement).getLeft(dataElement);
// Swap, handling special cases of one being the other's parent.
if (x == yFormerParent) { // x was y's parent
x.setParent(y, dataElement);
if (yWasLeftChild) {
y.setLeft(x, dataElement);
y.setRight(xFormerRightChild, dataElement);
} else {
y.setRight(x, dataElement);
y.setLeft(xFormerLeftChild, dataElement);
}
} else {
x.setParent(yFormerParent, dataElement);
if (yFormerParent != null) {
if (yWasLeftChild) {
yFormerParent.setLeft(x, dataElement);
} else {
yFormerParent.setRight(x, dataElement);
}
}
y.setLeft(xFormerLeftChild, dataElement);
y.setRight(xFormerRightChild, dataElement);
}
if (y == xFormerParent) { // y was x's parent
y.setParent(x, dataElement);
if (xWasLeftChild) {
x.setLeft(y, dataElement);
x.setRight(yFormerRightChild, dataElement);
} else {
x.setRight(y, dataElement);
x.setLeft(yFormerLeftChild, dataElement);
}
} else {
y.setParent(xFormerParent, dataElement);
if (xFormerParent != null) {
if (xWasLeftChild) {
xFormerParent.setLeft(y, dataElement);
} else {
xFormerParent.setRight(y, dataElement);
}
}
x.setLeft(yFormerLeftChild, dataElement);
x.setRight(yFormerRightChild, dataElement);
}
// Fix children's parent pointers
if (x.getLeft(dataElement) != null) {
x.getLeft(dataElement).setParent(x, dataElement);
}
if (x.getRight(dataElement) != null) {
x.getRight(dataElement).setParent(x, dataElement);
}
if (y.getLeft(dataElement) != null) {
y.getLeft(dataElement).setParent(y, dataElement);
}
if (y.getRight(dataElement) != null) {
y.getRight(dataElement).setParent(y, dataElement);
}
x.swapColors(y, dataElement);
// Check if root changed
if (rootNode[dataElement.ordinal()] == x) {
rootNode[dataElement.ordinal()] = y;
} else if (rootNode[dataElement.ordinal()] == y) {
rootNode[dataElement.ordinal()] = x;
}
}
/**
* check if an object is fit to be proper input ... has to be
* Comparable and non-null
*
* @param o the object being checked
* @param index the KEY or VALUE int (used to put the right word in the
* exception message)
*
* @throws NullPointerException if o is null
* @throws ClassCastException if o is not Comparable
*/
private static void checkNonNullComparable(final Object o, final DataElement dataElement) {
if (o == null) {
throw new NullPointerException(dataElement + " cannot be null");
}
if (!(o instanceof Comparable)) {
throw new ClassCastException(dataElement + " must be Comparable");
}
}
/**
* check a key for validity (non-null and implements Comparable)
*
* @param key the key to be checked
*
* @throws NullPointerException if key is null
* @throws ClassCastException if key is not Comparable
*/
private static void checkKey(final Object key) {
checkNonNullComparable(key, KEY);
}
/**
* check a value for validity (non-null and implements Comparable)
*
* @param value the value to be checked
*
* @throws NullPointerException if value is null
* @throws ClassCastException if value is not Comparable
*/
private static void checkValue(final Object value) {
checkNonNullComparable(value, VALUE);
}
/**
* check a key and a value for validity (non-null and implements
* Comparable)
*
* @param key the key to be checked
* @param value the value to be checked
*
* @throws NullPointerException if key or value is null
* @throws ClassCastException if key or value is not Comparable
*/
private static void checkKeyAndValue(final Object key, final Object value) {
checkKey(key);
checkValue(value);
}
/**
* increment the modification count -- used to check for
* concurrent modification of the map through the map and through
* an Iterator from one of its Set or Collection views
*/
private void modify() {
modifications++;
}
/**
* bump up the size and note that the map has changed
*/
private void grow() {
modify();
nodeCount++;
}
/**
* decrement the size and note that the map has changed
*/
private void shrink() {
modify();
nodeCount--;
}
/**
* insert a node by its value
*
* @param newNode the node to be inserted
*
* @throws IllegalArgumentException if the node already exists
* in the value mapping
*/
private void insertValue(final Node newNode) throws IllegalArgumentException {
Node node = rootNode[VALUE.ordinal()];
while (true) {
final int cmp = compare(newNode.getValue(), node.getValue());
if (cmp == 0) {
throw new IllegalArgumentException(
"Cannot store a duplicate value (\"" + newNode.getData(VALUE) + "\") in this Map");
} else if (cmp < 0) {
if (node.getLeft(VALUE) != null) {
node = node.getLeft(VALUE);
} else {
node.setLeft(newNode, VALUE);
newNode.setParent(node, VALUE);
doRedBlackInsert(newNode, VALUE);
break;
}
} else { // cmp > 0
if (node.getRight(VALUE) != null) {
node = node.getRight(VALUE);
} else {
node.setRight(newNode, VALUE);
newNode.setParent(node, VALUE);
doRedBlackInsert(newNode, VALUE);
break;
}
}
}
}
//-----------------------------------------------------------------------
/**
* Compares for equals as per the API.
*
* @param obj the object to compare to
* @param type the KEY or VALUE int
* @return true if equal
*/
private boolean doEquals(final Object obj, final DataElement dataElement) {
if (obj == this) {
return true;
}
if (obj instanceof Map == false) {
return false;
}
final Map other = (Map) obj;
if (other.size() != size()) {
return false;
}
if (nodeCount > 0) {
try {
for (final MapIterator it = getMapIterator(dataElement); it.hasNext(); ) {
final Object key = it.next();
final Object value = it.getValue();
if (value.equals(other.get(key)) == false) {
return false;
}
}
} catch (final ClassCastException ex) {
return false;
} catch (final NullPointerException ex) {
return false;
}
}
return true;
}
/**
* Gets the hash code value for this map as per the API.
*
* @param type the KEY or VALUE int
* @return the hash code value for this map
*/
private int doHashCode(final DataElement dataElement) {
int total = 0;
if (nodeCount > 0) {
for (final MapIterator it = getMapIterator(dataElement); it.hasNext(); ) {
final Object key = it.next();
final Object value = it.getValue();
total += key.hashCode() ^ value.hashCode();
}
}
return total;
}
/**
* Gets the string form of this map as per AbstractMap.
*
* @param type the KEY or VALUE int
* @return the string form of this map
*/
private String doToString(final DataElement dataElement) {
if (nodeCount == 0) {
return "{}";
}
final StringBuilder buf = new StringBuilder(nodeCount * 32);
buf.append('{');
final MapIterator it = getMapIterator(dataElement);
boolean hasNext = it.hasNext();
while (hasNext) {
final Object key = it.next();
final Object value = it.getValue();
buf.append(key == this ? "(this Map)" : key)
.append('=')
.append(value == this ? "(this Map)" : value);
hasNext = it.hasNext();
if (hasNext) {
buf.append(", ");
}
}
buf.append('}');
return buf.toString();
}
private MapIterator getMapIterator(final DataElement dataElement) {
switch (dataElement) {
case KEY:
return new ViewMapIterator(KEY);
case VALUE:
return new InverseViewMapIterator(VALUE);
default:
throw new IllegalArgumentException();
}
}
/**
* Reads the content of the stream.
*/
@SuppressWarnings("unchecked") // This will fail at runtime if the stream is incorrect
private void readObject(final ObjectInputStream stream) throws IOException, ClassNotFoundException{
stream.defaultReadObject();
rootNode = new Node[2];
int size = stream.readInt();
for(int i = 0; i < size; i++){
K k =(K) stream.readObject();
V v =(V) stream.readObject();
put(k, v);
}
}
/**
* Writes the content to the stream for serialization.
*/
private void writeObject(final ObjectOutputStream stream) throws IOException{
stream.defaultWriteObject();
stream.writeInt(this.size());
for (final Entry entry : entrySet()) {
stream.writeObject(entry.getKey());
stream.writeObject(entry.getValue());
}
}
//-----------------------------------------------------------------------
/**
* A view of this map.
*/
abstract class View extends AbstractSet {
/** Whether to return KEY or VALUE order. */
final DataElement orderType;
/**
* Constructor.
* @param orderType the KEY or VALUE int for the order
* @param main the main map
*/
View(final DataElement orderType) {
super();
this.orderType = orderType;
}
@Override
public int size() {
return TreeBidiMap.this.size();
}
@Override
public void clear() {
TreeBidiMap.this.clear();
}
}
class KeyView extends View {
/**
* Create a new TreeBidiMap.KeyView.
*/
public KeyView(final DataElement orderType) {
super(orderType);
}
@Override
public Iterator iterator() {
return new ViewMapIterator(orderType);
}
@Override
public boolean contains(final Object obj) {
checkNonNullComparable(obj, KEY);
return lookupKey(obj) != null;
}
@Override
public boolean remove(final Object o) {
return doRemoveKey(o) != null;
}
}
class ValueView extends View {
/**
* Create a new TreeBidiMap.ValueView.
*/
public ValueView(final DataElement orderType) {
super(orderType);
}
@Override
public Iterator iterator() {
return new InverseViewMapIterator(orderType);
}
@Override
public boolean contains(final Object obj) {
checkNonNullComparable(obj, VALUE);
return lookupValue(obj) != null;
}
@Override
public boolean remove(final Object o) {
return doRemoveValue(o) != null;
}
}
/**
* A view of this map.
*/
class EntryView extends View> {
EntryView() {
super(KEY);
}
@Override
public boolean contains(final Object obj) {
if (obj instanceof Map.Entry == false) {
return false;
}
final Map.Entry entry = (Map.Entry) obj;
final Object value = entry.getValue();
final Node node = lookupKey(entry.getKey());
return node != null && node.getValue().equals(value);
}
@Override
public boolean remove(final Object obj) {
if (obj instanceof Map.Entry == false) {
return false;
}
final Map.Entry entry = (Map.Entry) obj;
final Object value = entry.getValue();
final Node node = lookupKey(entry.getKey());
if (node != null && node.getValue().equals(value)) {
doRedBlackDelete(node);
return true;
}
return false;
}
@Override
public Iterator> iterator() {
return new ViewMapEntryIterator();
}
}
/**
* A view of this map.
*/
class InverseEntryView extends View> {
InverseEntryView() {
super(VALUE);
}
@Override
public boolean contains(final Object obj) {
if (obj instanceof Map.Entry == false) {
return false;
}
final Map.Entry entry = (Map.Entry) obj;
final Object value = entry.getValue();
final Node node = lookupValue(entry.getKey());
return node != null && node.getKey().equals(value);
}
@Override
public boolean remove(final Object obj) {
if (obj instanceof Map.Entry == false) {
return false;
}
final Map.Entry entry = (Map.Entry) obj;
final Object value = entry.getValue();
final Node node = lookupValue(entry.getKey());
if (node != null && node.getKey().equals(value)) {
doRedBlackDelete(node);
return true;
}
return false;
}
@Override
public Iterator> iterator() {
return new InverseViewMapEntryIterator();
}
}
//-----------------------------------------------------------------------
/**
* An iterator over the map.
*/
abstract class ViewIterator {
/** Whether to return KEY or VALUE order. */
private final DataElement orderType;
/** The last node returned by the iterator. */
Node lastReturnedNode;
/** The next node to be returned by the iterator. */
private Node nextNode;
/** The previous node in the sequence returned by the iterator. */
private Node previousNode;
/** The modification count. */
private int expectedModifications;
/**
* Constructor.
* @param orderType the KEY or VALUE int for the order
* @param main the main map
*/
ViewIterator(final DataElement orderType) {
super();
this.orderType = orderType;
expectedModifications = modifications;
nextNode = leastNode(rootNode[orderType.ordinal()], orderType);
lastReturnedNode = null;
previousNode = null;
}
public final boolean hasNext() {
return nextNode != null;
}
protected Node navigateNext() {
if (nextNode == null) {
throw new NoSuchElementException();
}
if (modifications != expectedModifications) {
throw new ConcurrentModificationException();
}
lastReturnedNode = nextNode;
previousNode = nextNode;
nextNode = nextGreater(nextNode, orderType);
return lastReturnedNode;
}
public boolean hasPrevious() {
return previousNode != null;
}
protected Node navigatePrevious() {
if (previousNode == null) {
throw new NoSuchElementException();
}
if (modifications != expectedModifications) {
throw new ConcurrentModificationException();
}
nextNode = lastReturnedNode;
if (nextNode == null) {
nextNode = nextGreater(previousNode, orderType);
}
lastReturnedNode = previousNode;
previousNode = nextSmaller(previousNode, orderType);
return lastReturnedNode;
}
public final void remove() {
if (lastReturnedNode == null) {
throw new IllegalStateException();
}
if (modifications != expectedModifications) {
throw new ConcurrentModificationException();
}
doRedBlackDelete(lastReturnedNode);
expectedModifications++;
lastReturnedNode = null;
if (nextNode == null) {
previousNode = greatestNode(rootNode[orderType.ordinal()], orderType);
} else {
previousNode = nextSmaller(nextNode, orderType);
}
}
}
//-----------------------------------------------------------------------
/**
* An iterator over the map.
*/
class ViewMapIterator extends ViewIterator implements OrderedMapIterator {
/**
* Constructor.
*/
ViewMapIterator(final DataElement orderType) {
super(orderType);
}
@Override
public K getKey() {
if (lastReturnedNode == null) {
throw new IllegalStateException(
"Iterator getKey() can only be called after next() and before remove()");
}
return lastReturnedNode.getKey();
}
@Override
public V getValue() {
if (lastReturnedNode == null) {
throw new IllegalStateException(
"Iterator getValue() can only be called after next() and before remove()");
}
return lastReturnedNode.getValue();
}
@Override
public V setValue(final V obj) {
throw new UnsupportedOperationException();
}
@Override
public K next() {
return navigateNext().getKey();
}
@Override
public K previous() {
return navigatePrevious().getKey();
}
}
/**
* An iterator over the map.
*/
class InverseViewMapIterator extends ViewIterator implements OrderedMapIterator {
/**
* Create a new TreeBidiMap.InverseViewMapIterator.
*/
public InverseViewMapIterator(final DataElement orderType) {
super(orderType);
}
@Override
public V getKey() {
if (lastReturnedNode == null) {
throw new IllegalStateException(
"Iterator getKey() can only be called after next() and before remove()");
}
return lastReturnedNode.getValue();
}
@Override
public K getValue() {
if (lastReturnedNode == null) {
throw new IllegalStateException(
"Iterator getValue() can only be called after next() and before remove()");
}
return lastReturnedNode.getKey();
}
@Override
public K setValue(final K obj) {
throw new UnsupportedOperationException();
}
@Override
public V next() {
return navigateNext().getValue();
}
@Override
public V previous() {
return navigatePrevious().getValue();
}
}
/**
* An iterator over the map entries.
*/
class ViewMapEntryIterator extends ViewIterator implements OrderedIterator> {
/**
* Constructor.
*/
ViewMapEntryIterator() {
super(KEY);
}
@Override
public Map.Entry next() {
return navigateNext();
}
@Override
public Map.Entry previous() {
return navigatePrevious();
}
}
/**
* An iterator over the inverse map entries.
*/
class InverseViewMapEntryIterator extends ViewIterator implements OrderedIterator> {
/**
* Constructor.
*/
InverseViewMapEntryIterator() {
super(VALUE);
}
@Override
public Map.Entry next() {
return createEntry(navigateNext());
}
@Override
public Map.Entry previous() {
return createEntry(navigatePrevious());
}
private Map.Entry createEntry(final Node node) {
return new UnmodifiableMapEntry(node.getValue(), node.getKey());
}
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
/**
* A node used to store the data.
*/
static class Node, V extends Comparable> implements Map.Entry, KeyValue {
private final K key;
private final V value;
private final Node[] leftNode;
private final Node[] rightNode;
private final Node[] parentNode;
private final boolean[] blackColor;
private int hashcodeValue;
private boolean calculatedHashCode;
/**
* Make a new cell with given key and value, and with null
* links, and black (true) colors.
*
* @param key
* @param value
*/
@SuppressWarnings("unchecked")
Node(final K key, final V value) {
super();
this.key = key;
this.value = value;
leftNode = new Node[2];
rightNode = new Node[2];
parentNode = new Node[2];
blackColor = new boolean[] { true, true };
calculatedHashCode = false;
}
private Object getData(final DataElement dataElement) {
switch (dataElement) {
case KEY:
return getKey();
case VALUE:
return getValue();
default:
throw new IllegalArgumentException();
}
}
private void setLeft(final Node node, final DataElement dataElement) {
leftNode[dataElement.ordinal()] = node;
}
private Node getLeft(final DataElement dataElement) {
return leftNode[dataElement.ordinal()];
}
private void setRight(final Node node, final DataElement dataElement) {
rightNode[dataElement.ordinal()] = node;
}
private Node getRight(final DataElement dataElement) {
return rightNode[dataElement.ordinal()];
}
/**
* Set this node's parent node.
*
* @param node the new parent node
* @param index the KEY or VALUE int
*/
private void setParent(final Node node, final DataElement dataElement) {
parentNode[dataElement.ordinal()] = node;
}
/**
* Get the parent node.
*
* @param index the KEY or VALUE int
* @return the parent node, may be null
*/
private Node getParent(final DataElement dataElement) {
return parentNode[dataElement.ordinal()];
}
/**
* Exchange colors with another node.
*
* @param node the node to swap with
* @param index the KEY or VALUE int
*/
private void swapColors(final Node node, final DataElement dataElement) {
// Swap colors -- old hacker's trick
blackColor[dataElement.ordinal()] ^= node.blackColor[dataElement.ordinal()];
node.blackColor[dataElement.ordinal()] ^= blackColor[dataElement.ordinal()];
blackColor[dataElement.ordinal()] ^= node.blackColor[dataElement.ordinal()];
}
/**
* Is this node black?
*
* @param index the KEY or VALUE int
* @return true if black (which is represented as a true boolean)
*/
private boolean isBlack(final DataElement dataElement) {
return blackColor[dataElement.ordinal()];
}
/**
* Is this node red?
*
* @param index the KEY or VALUE int
* @return true if non-black
*/
private boolean isRed(final DataElement dataElement) {
return !blackColor[dataElement.ordinal()];
}
/**
* Make this node black.
*
* @param index the KEY or VALUE int
*/
private void setBlack(final DataElement dataElement) {
blackColor[dataElement.ordinal()] = true;
}
/**
* Make this node red.
*
* @param index the KEY or VALUE int
*/
private void setRed(final DataElement dataElement) {
blackColor[dataElement.ordinal()] = false;
}
/**
* Make this node the same color as another
*
* @param node the node whose color we're adopting
* @param index the KEY or VALUE int
*/
private void copyColor(final Node node, final DataElement dataElement) {
blackColor[dataElement.ordinal()] = node.blackColor[dataElement.ordinal()];
}
private boolean isLeftChild(final DataElement dataElement) {
return parentNode[dataElement.ordinal()] != null
&& parentNode[dataElement.ordinal()].leftNode[dataElement.ordinal()] == this;
}
private boolean isRightChild(final DataElement dataElement) {
return parentNode[dataElement.ordinal()] != null
&& parentNode[dataElement.ordinal()].rightNode[dataElement.ordinal()] == this;
}
//-------------------------------------------------------------------
/**
* Gets the key.
*
* @return the key corresponding to this entry.
*/
@Override
public K getKey() {
return key;
}
/**
* Gets the value.
*
* @return the value corresponding to this entry.
*/
@Override
public V getValue() {
return value;
}
/**
* Optional operation that is not permitted in this implementation
*
* @param ignored
* @return does not return
* @throws UnsupportedOperationException always
*/
@Override
public V setValue(final V ignored) throws UnsupportedOperationException {
throw new UnsupportedOperationException("Map.Entry.setValue is not supported");
}
/**
* Compares the specified object with this entry for equality.
* Returns true if the given object is also a map entry and
* the two entries represent the same mapping.
*
* @param obj the object to be compared for equality with this entry.
* @return true if the specified object is equal to this entry.
*/
@Override
public boolean equals(final Object obj) {
if (obj == this) {
return true;
}
if (!(obj instanceof Map.Entry)) {
return false;
}
final Map.Entry e = (Map.Entry) obj;
return getKey().equals(e.getKey()) && getValue().equals(e.getValue());
}
/**
* @return the hash code value for this map entry.
*/
@Override
public int hashCode() {
if (!calculatedHashCode) {
hashcodeValue = getKey().hashCode() ^ getValue().hashCode();
calculatedHashCode = true;
}
return hashcodeValue;
}
}
//-----------------------------------------------------------------------
/**
* The inverse map implementation.
*/
class Inverse implements OrderedBidiMap {
/** Store the keySet once created. */
private Set inverseKeySet;
/** Store the valuesSet once created. */
private Set inverseValuesSet;
/** Store the entrySet once created. */
private Set> inverseEntrySet;
@Override
public int size() {
return TreeBidiMap.this.size();
}
@Override
public boolean isEmpty() {
return TreeBidiMap.this.isEmpty();
}
@Override
public K get(final Object key) {
return TreeBidiMap.this.getKey(key);
}
@Override
public V getKey(final Object value) {
return TreeBidiMap.this.get(value);
}
@Override
public boolean containsKey(final Object key) {
return TreeBidiMap.this.containsValue(key);
}
@Override
public boolean containsValue(final Object value) {
return TreeBidiMap.this.containsKey(value);
}
@Override
public V firstKey() {
if (TreeBidiMap.this.nodeCount == 0) {
throw new NoSuchElementException("Map is empty");
}
return leastNode(TreeBidiMap.this.rootNode[VALUE.ordinal()], VALUE).getValue();
}
@Override
public V lastKey() {
if (TreeBidiMap.this.nodeCount == 0) {
throw new NoSuchElementException("Map is empty");
}
return greatestNode(TreeBidiMap.this.rootNode[VALUE.ordinal()], VALUE).getValue();
}
@Override
public V nextKey(final V key) {
checkKey(key);
final Node node = nextGreater(TreeBidiMap.this.lookup(key, VALUE), VALUE);
return node == null ? null : node.getValue();
}
@Override
public V previousKey(final V key) {
checkKey(key);
final Node node = TreeBidiMap.this.nextSmaller(TreeBidiMap.this.lookup(key, VALUE), VALUE);
return node == null ? null : node.getValue();
}
@Override
public K put(final V key, final K value) {
final K result = get(key);
TreeBidiMap.this.doPut(value, key);
return result;
}
@Override
public void putAll(final Map map) {
for (final Map.Entry e : map.entrySet()) {
put(e.getKey(), e.getValue());
}
}
@Override
public K remove(final Object key) {
return TreeBidiMap.this.removeValue(key);
}
@Override
public V removeValue(final Object value) {
return TreeBidiMap.this.remove(value);
}
@Override
public void clear() {
TreeBidiMap.this.clear();
}
@Override
public Set keySet() {
if (inverseKeySet == null) {
inverseKeySet = new ValueView(VALUE);
}
return inverseKeySet;
}
@Override
public Set values() {
if (inverseValuesSet == null) {
inverseValuesSet = new KeyView(VALUE);
}
return inverseValuesSet;
}
@Override
public Set> entrySet() {
if (inverseEntrySet == null) {
inverseEntrySet = new InverseEntryView();
}
return inverseEntrySet;
}
@Override
public OrderedMapIterator mapIterator() {
if (isEmpty()) {
return EmptyOrderedMapIterator.emptyOrderedMapIterator();
}
return new InverseViewMapIterator(VALUE);
}
@Override
public OrderedBidiMap inverseBidiMap() {
return TreeBidiMap.this;
}
@Override
public boolean equals(final Object obj) {
return TreeBidiMap.this.doEquals(obj, DataElement.VALUE);
}
@Override
public int hashCode() {
return TreeBidiMap.this.doHashCode(DataElement.VALUE);
}
@Override
public String toString() {
return TreeBidiMap.this.doToString(DataElement.VALUE);
}
}
}