Back to project page reflect-app.
The source code is released under:
Apache License
If you think the Android project reflect-app listed in this page is inappropriate, such as containing malicious code/tools or violating the copyright, please email info at java2s dot com, thanks.
/* * Copyright (C) 2010 The Android Open Source Project * Copyright (C) 2012 Google Inc./*from w w w. j a v a2 s. co m*/ * * 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 com.google.gson.internal; import java.io.ObjectStreamException; import java.io.Serializable; import java.util.AbstractMap; import java.util.AbstractSet; import java.util.Arrays; import java.util.Comparator; import java.util.ConcurrentModificationException; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.NoSuchElementException; import java.util.Set; /** * A map of comparable keys to values. Unlike {@code TreeMap}, this class uses * insertion order for iteration order. Comparison order is only used as an * optimization for efficient insertion and removal. * * <p>This implementation was derived from Android 4.1's TreeMap and * LinkedHashMap classes. */ public final class LinkedHashTreeMap<K, V> extends AbstractMap<K, V> implements Serializable { @SuppressWarnings({ "unchecked", "rawtypes" }) // to avoid Comparable<Comparable<Comparable<...>>> private static final Comparator<Comparable> NATURAL_ORDER = new Comparator<Comparable>() { public int compare(Comparable a, Comparable b) { return a.compareTo(b); } }; Comparator<? super K> comparator; Node<K, V>[] table; final Node<K, V> header; int size = 0; int modCount = 0; int threshold; /** * Create a natural order, empty tree map whose keys must be mutually * comparable and non-null. */ @SuppressWarnings("unchecked") // unsafe! this assumes K is comparable public LinkedHashTreeMap() { this((Comparator<? super K>) NATURAL_ORDER); } /** * Create a tree map ordered by {@code comparator}. This map's keys may only * be null if {@code comparator} permits. * * @param comparator the comparator to order elements with, or {@code null} to * use the natural ordering. */ @SuppressWarnings({ "unchecked", "rawtypes" }) // unsafe! if comparator is null, this assumes K is comparable public LinkedHashTreeMap(Comparator<? super K> comparator) { this.comparator = comparator != null ? comparator : (Comparator) NATURAL_ORDER; this.header = new Node<K, V>(); this.table = new Node[16]; // TODO: sizing/resizing policies this.threshold = (table.length / 2) + (table.length / 4); // 3/4 capacity } @Override public int size() { return size; } @Override public V get(Object key) { Node<K, V> node = findByObject(key); return node != null ? node.value : null; } @Override public boolean containsKey(Object key) { return findByObject(key) != null; } @Override public V put(K key, V value) { if (key == null) { throw new NullPointerException("key == null"); } Node<K, V> created = find(key, true); V result = created.value; created.value = value; return result; } @Override public void clear() { Arrays.fill(table, null); size = 0; modCount++; // Clear all links to help GC Node<K, V> header = this.header; for (Node<K, V> e = header.next; e != header; ) { Node<K, V> next = e.next; e.next = e.prev = null; e = next; } header.next = header.prev = header; } @Override public V remove(Object key) { Node<K, V> node = removeInternalByKey(key); return node != null ? node.value : null; } /** * Returns the node at or adjacent to the given key, creating it if requested. * * @throws ClassCastException if {@code key} and the tree's keys aren't * mutually comparable. */ Node<K, V> find(K key, boolean create) { Comparator<? super K> comparator = this.comparator; Node<K, V>[] table = this.table; int hash = secondaryHash(key.hashCode()); int index = hash & (table.length - 1); Node<K, V> nearest = table[index]; int comparison = 0; if (nearest != null) { // Micro-optimization: avoid polymorphic calls to Comparator.compare(). @SuppressWarnings("unchecked") // Throws a ClassCastException below if there's trouble. Comparable<Object> comparableKey = (comparator == NATURAL_ORDER) ? (Comparable<Object>) key : null; while (true) { comparison = (comparableKey != null) ? comparableKey.compareTo(nearest.key) : comparator.compare(key, nearest.key); // We found the requested key. if (comparison == 0) { return nearest; } // If it exists, the key is in a subtree. Go deeper. Node<K, V> child = (comparison < 0) ? nearest.left : nearest.right; if (child == null) { break; } nearest = child; } } // The key doesn't exist in this tree. if (!create) { return null; } // Create the node and add it to the tree or the table. Node<K, V> header = this.header; Node<K, V> created; if (nearest == null) { // Check that the value is comparable if we didn't do any comparisons. if (comparator == NATURAL_ORDER && !(key instanceof Comparable)) { throw new ClassCastException(key.getClass().getName() + " is not Comparable"); } created = new Node<K, V>(nearest, key, hash, header, header.prev); table[index] = created; } else { created = new Node<K, V>(nearest, key, hash, header, header.prev); if (comparison < 0) { // nearest.key is higher nearest.left = created; } else { // comparison > 0, nearest.key is lower nearest.right = created; } rebalance(nearest, true); } if (size++ > threshold) { doubleCapacity(); } modCount++; return created; } @SuppressWarnings("unchecked") Node<K, V> findByObject(Object key) { try { return key != null ? find((K) key, false) : null; } catch (ClassCastException e) { return null; } } /** * Returns this map's entry that has the same key and value as {@code * entry}, or null if this map has no such entry. * * <p>This method uses the comparator for key equality rather than {@code * equals}. If this map's comparator isn't consistent with equals (such as * {@code String.CASE_INSENSITIVE_ORDER}), then {@code remove()} and {@code * contains()} will violate the collections API. */ Node<K, V> findByEntry(Entry<?, ?> entry) { Node<K, V> mine = findByObject(entry.getKey()); boolean valuesEqual = mine != null && equal(mine.value, entry.getValue()); return valuesEqual ? mine : null; } private boolean equal(Object a, Object b) { return a == b || (a != null && a.equals(b)); } /** * Applies a supplemental hash function to a given hashCode, which defends * against poor quality hash functions. This is critical because HashMap * uses power-of-two length hash tables, that otherwise encounter collisions * for hashCodes that do not differ in lower or upper bits. */ private static int secondaryHash(int h) { // Doug Lea's supplemental hash function h ^= (h >>> 20) ^ (h >>> 12); return h ^ (h >>> 7) ^ (h >>> 4); } /** * Removes {@code node} from this tree, rearranging the tree's structure as * necessary. * * @param unlink true to also unlink this node from the iteration linked list. */ void removeInternal(Node<K, V> node, boolean unlink) { if (unlink) { node.prev.next = node.next; node.next.prev = node.prev; node.next = node.prev = null; // Help the GC (for performance) } Node<K, V> left = node.left; Node<K, V> right = node.right; Node<K, V> originalParent = node.parent; if (left != null && right != null) { /* * To remove a node with both left and right subtrees, move an * adjacent node from one of those subtrees into this node's place. * * Removing the adjacent node may change this node's subtrees. This * node may no longer have two subtrees once the adjacent node is * gone! */ Node<K, V> adjacent = (left.height > right.height) ? left.last() : right.first(); removeInternal(adjacent, false); // takes care of rebalance and size-- int leftHeight = 0; left = node.left; if (left != null) { leftHeight = left.height; adjacent.left = left; left.parent = adjacent; node.left = null; } int rightHeight = 0; right = node.right; if (right != null) { rightHeight = right.height; adjacent.right = right; right.parent = adjacent; node.right = null; } adjacent.height = Math.max(leftHeight, rightHeight) + 1; replaceInParent(node, adjacent); return; } else if (left != null) { replaceInParent(node, left); node.left = null; } else if (right != null) { replaceInParent(node, right); node.right = null; } else { replaceInParent(node, null); } rebalance(originalParent, false); size--; modCount++; } Node<K, V> removeInternalByKey(Object key) { Node<K, V> node = findByObject(key); if (node != null) { removeInternal(node, true); } return node; } private void replaceInParent(Node<K, V> node, Node<K, V> replacement) { Node<K, V> parent = node.parent; node.parent = null; if (replacement != null) { replacement.parent = parent; } if (parent != null) { if (parent.left == node) { parent.left = replacement; } else { assert (parent.right == node); parent.right = replacement; } } else { int index = node.hash & (table.length - 1); table[index] = replacement; } } /** * Rebalances the tree by making any AVL rotations necessary between the * newly-unbalanced node and the tree's root. * * @param insert true if the node was unbalanced by an insert; false if it * was by a removal. */ private void rebalance(Node<K, V> unbalanced, boolean insert) { for (Node<K, V> node = unbalanced; node != null; node = node.parent) { Node<K, V> left = node.left; Node<K, V> right = node.right; int leftHeight = left != null ? left.height : 0; int rightHeight = right != null ? right.height : 0; int delta = leftHeight - rightHeight; if (delta == -2) { Node<K, V> rightLeft = right.left; Node<K, V> rightRight = right.right; int rightRightHeight = rightRight != null ? rightRight.height : 0; int rightLeftHeight = rightLeft != null ? rightLeft.height : 0; int rightDelta = rightLeftHeight - rightRightHeight; if (rightDelta == -1 || (rightDelta == 0 && !insert)) { rotateLeft(node); // AVL right right } else { assert (rightDelta == 1); rotateRight(right); // AVL right left rotateLeft(node); } if (insert) { break; // no further rotations will be necessary } } else if (delta == 2) { Node<K, V> leftLeft = left.left; Node<K, V> leftRight = left.right; int leftRightHeight = leftRight != null ? leftRight.height : 0; int leftLeftHeight = leftLeft != null ? leftLeft.height : 0; int leftDelta = leftLeftHeight - leftRightHeight; if (leftDelta == 1 || (leftDelta == 0 && !insert)) { rotateRight(node); // AVL left left } else { assert (leftDelta == -1); rotateLeft(left); // AVL left right rotateRight(node); } if (insert) { break; // no further rotations will be necessary } } else if (delta == 0) { node.height = leftHeight + 1; // leftHeight == rightHeight if (insert) { break; // the insert caused balance, so rebalancing is done! } } else { assert (delta == -1 || delta == 1); node.height = Math.max(leftHeight, rightHeight) + 1; if (!insert) { break; // the height hasn't changed, so rebalancing is done! } } } } /** * Rotates the subtree so that its root's right child is the new root. */ private void rotateLeft(Node<K, V> root) { Node<K, V> left = root.left; Node<K, V> pivot = root.right; Node<K, V> pivotLeft = pivot.left; Node<K, V> pivotRight = pivot.right; // move the pivot's left child to the root's right root.right = pivotLeft; if (pivotLeft != null) { pivotLeft.parent = root; } replaceInParent(root, pivot); // move the root to the pivot's left pivot.left = root; root.parent = pivot; // fix heights root.height = Math.max(left != null ? left.height : 0, pivotLeft != null ? pivotLeft.height : 0) + 1; pivot.height = Math.max(root.height, pivotRight != null ? pivotRight.height : 0) + 1; } /** * Rotates the subtree so that its root's left child is the new root. */ private void rotateRight(Node<K, V> root) { Node<K, V> pivot = root.left; Node<K, V> right = root.right; Node<K, V> pivotLeft = pivot.left; Node<K, V> pivotRight = pivot.right; // move the pivot's right child to the root's left root.left = pivotRight; if (pivotRight != null) { pivotRight.parent = root; } replaceInParent(root, pivot); // move the root to the pivot's right pivot.right = root; root.parent = pivot; // fixup heights root.height = Math.max(right != null ? right.height : 0, pivotRight != null ? pivotRight.height : 0) + 1; pivot.height = Math.max(root.height, pivotLeft != null ? pivotLeft.height : 0) + 1; } private EntrySet entrySet; private KeySet keySet; @Override public Set<Entry<K, V>> entrySet() { EntrySet result = entrySet; return result != null ? result : (entrySet = new EntrySet()); } @Override public Set<K> keySet() { KeySet result = keySet; return result != null ? result : (keySet = new KeySet()); } static final class Node<K, V> implements Entry<K, V> { Node<K, V> parent; Node<K, V> left; Node<K, V> right; Node<K, V> next; Node<K, V> prev; final K key; final int hash; V value; int height; /** Create the header entry */ Node() { key = null; hash = -1; next = prev = this; } /** Create a regular entry */ Node(Node<K, V> parent, K key, int hash, Node<K, V> next, Node<K, V> prev) { this.parent = parent; this.key = key; this.hash = hash; this.height = 1; this.next = next; this.prev = prev; prev.next = this; next.prev = this; } public K getKey() { return key; } public V getValue() { return value; } public V setValue(V value) { V oldValue = this.value; this.value = value; return oldValue; } @SuppressWarnings("rawtypes") @Override public boolean equals(Object o) { if (o instanceof Entry) { Entry other = (Entry) o; return (key == null ? other.getKey() == null : key.equals(other.getKey())) && (value == null ? other.getValue() == null : value.equals(other.getValue())); } return false; } @Override public int hashCode() { return (key == null ? 0 : key.hashCode()) ^ (value == null ? 0 : value.hashCode()); } @Override public String toString() { return key + "=" + value; } /** * Returns the first node in this subtree. */ public Node<K, V> first() { Node<K, V> node = this; Node<K, V> child = node.left; while (child != null) { node = child; child = node.left; } return node; } /** * Returns the last node in this subtree. */ public Node<K, V> last() { Node<K, V> node = this; Node<K, V> child = node.right; while (child != null) { node = child; child = node.right; } return node; } } private void doubleCapacity() { table = doubleCapacity(table); threshold = (table.length / 2) + (table.length / 4); // 3/4 capacity } /** * Returns a new array containing the same nodes as {@code oldTable}, but with * twice as many trees, each of (approximately) half the previous size. */ static <K, V> Node<K, V>[] doubleCapacity(Node<K, V>[] oldTable) { // TODO: don't do anything if we're already at MAX_CAPACITY int oldCapacity = oldTable.length; @SuppressWarnings("unchecked") // Arrays and generics don't get along. Node<K, V>[] newTable = new Node[oldCapacity * 2]; AvlIterator<K, V> iterator = new AvlIterator<K, V>(); AvlBuilder<K, V> leftBuilder = new AvlBuilder<K, V>(); AvlBuilder<K, V> rightBuilder = new AvlBuilder<K, V>(); // Split each tree into two trees. for (int i = 0; i < oldCapacity; i++) { Node<K, V> root = oldTable[i]; if (root == null) { continue; } // Compute the sizes of the left and right trees. iterator.reset(root); int leftSize = 0; int rightSize = 0; for (Node<K, V> node; (node = iterator.next()) != null; ) { if ((node.hash & oldCapacity) == 0) { leftSize++; } else { rightSize++; } } // Split the tree into two. Node<K, V> leftRoot = null; Node<K, V> rightRoot = null; if (leftSize > 0 && rightSize > 0) { leftBuilder.reset(leftSize); rightBuilder.reset(rightSize); iterator.reset(root); for (Node<K, V> node; (node = iterator.next()) != null; ) { if ((node.hash & oldCapacity) == 0) { leftBuilder.add(node); } else { rightBuilder.add(node); } } leftRoot = leftBuilder.root(); rightRoot = rightBuilder.root(); } else if (leftSize > 0) { leftRoot = root; } else { rightRoot = root; } // Populate the enlarged array with these new roots. newTable[i] = leftRoot; newTable[i + oldCapacity] = rightRoot; } return newTable; } /** * Walks an AVL tree in iteration order. Once a node has been returned, its * left, right and parent links are <strong>no longer used</strong>. For this * reason it is safe to transform these links as you walk a tree. * * <p><strong>Warning:</strong> this iterator is destructive. It clears the * parent node of all nodes in the tree. It is an error to make a partial * iteration of a tree. */ static class AvlIterator<K, V> { /** This stack is a singly linked list, linked by the 'parent' field. */ private Node<K, V> stackTop; void reset(Node<K, V> root) { Node<K, V> stackTop = null; for (Node<K, V> n = root; n != null; n = n.left) { n.parent = stackTop; stackTop = n; // Stack push. } this.stackTop = stackTop; } public Node<K, V> next() { Node<K, V> stackTop = this.stackTop; if (stackTop == null) { return null; } Node<K, V> result = stackTop; stackTop = result.parent; result.parent = null; for (Node<K, V> n = result.right; n != null; n = n.left) { n.parent = stackTop; stackTop = n; // Stack push. } this.stackTop = stackTop; return result; } } /** * Builds AVL trees of a predetermined size by accepting nodes of increasing * value. To use: * <ol> * <li>Call {@link #reset} to initialize the target size <i>size</i>. * <li>Call {@link #add} <i>size</i> times with increasing values. * <li>Call {@link #root} to get the root of the balanced tree. * </ol> * * <p>The returned tree will satisfy the AVL constraint: for every node * <i>N</i>, the height of <i>N.left</i> and <i>N.right</i> is different by at * most 1. It accomplishes this by omitting deepest-level leaf nodes when * building trees whose size isn't a power of 2 minus 1. * * <p>Unlike rebuilding a tree from scratch, this approach requires no value * comparisons. Using this class to create a tree of size <i>S</i> is * {@code O(S)}. */ final static class AvlBuilder<K, V> { /** This stack is a singly linked list, linked by the 'parent' field. */ private Node<K, V> stack; private int leavesToSkip; private int leavesSkipped; private int size; void reset(int targetSize) { // compute the target tree size. This is a power of 2 minus one, like 15 or 31. int treeCapacity = Integer.highestOneBit(targetSize) * 2 - 1; leavesToSkip = treeCapacity - targetSize; size = 0; leavesSkipped = 0; stack = null; } void add(Node<K, V> node) { node.left = node.parent = node.right = null; node.height = 1; // Skip a leaf if necessary. if (leavesToSkip > 0 && (size & 1) == 0) { size++; leavesToSkip--; leavesSkipped++; } node.parent = stack; stack = node; // Stack push. size++; // Skip a leaf if necessary. if (leavesToSkip > 0 && (size & 1) == 0) { size++; leavesToSkip--; leavesSkipped++; } /* * Combine 3 nodes into subtrees whenever the size is one less than a * multiple of 4. For example we combine the nodes A, B, C into a * 3-element tree with B as the root. * * Combine two subtrees and a spare single value whenever the size is one * less than a multiple of 8. For example at 8 we may combine subtrees * (A B C) and (E F G) with D as the root to form ((A B C) D (E F G)). * * Just as we combine single nodes when size nears a multiple of 4, and * 3-element trees when size nears a multiple of 8, we combine subtrees of * size (N-1) whenever the total size is 2N-1 whenever N is a power of 2. */ for (int scale = 4; (size & scale - 1) == scale - 1; scale *= 2) { if (leavesSkipped == 0) { // Pop right, center and left, then make center the top of the stack. Node<K, V> right = stack; Node<K, V> center = right.parent; Node<K, V> left = center.parent; center.parent = left.parent; stack = center; // Construct a tree. center.left = left; center.right = right; center.height = right.height + 1; left.parent = center; right.parent = center; } else if (leavesSkipped == 1) { // Pop right and center, then make center the top of the stack. Node<K, V> right = stack; Node<K, V> center = right.parent; stack = center; // Construct a tree with no left child. center.right = right; center.height = right.height + 1; right.parent = center; leavesSkipped = 0; } else if (leavesSkipped == 2) { leavesSkipped = 0; } } } Node<K, V> root() { Node<K, V> stackTop = this.stack; if (stackTop.parent != null) { throw new IllegalStateException(); } return stackTop; } } private abstract class LinkedTreeMapIterator<T> implements Iterator<T> { Node<K, V> next = header.next; Node<K, V> lastReturned = null; int expectedModCount = modCount; public final boolean hasNext() { return next != header; } final Node<K, V> nextNode() { Node<K, V> e = next; if (e == header) { throw new NoSuchElementException(); } if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } next = e.next; return lastReturned = e; } public final void remove() { if (lastReturned == null) { throw new IllegalStateException(); } removeInternal(lastReturned, true); lastReturned = null; expectedModCount = modCount; } } class EntrySet extends AbstractSet<Entry<K, V>> { @Override public int size() { return size; } @Override public Iterator<Entry<K, V>> iterator() { return new LinkedTreeMapIterator<Entry<K, V>>() { public Entry<K, V> next() { return nextNode(); } }; } @Override public boolean contains(Object o) { return o instanceof Entry && findByEntry((Entry<?, ?>) o) != null; } @Override public boolean remove(Object o) { if (!(o instanceof Entry)) { return false; } Node<K, V> node = findByEntry((Entry<?, ?>) o); if (node == null) { return false; } removeInternal(node, true); return true; } @Override public void clear() { LinkedHashTreeMap.this.clear(); } } class KeySet extends AbstractSet<K> { @Override public int size() { return size; } @Override public Iterator<K> iterator() { return new LinkedTreeMapIterator<K>() { public K next() { return nextNode().key; } }; } @Override public boolean contains(Object o) { return containsKey(o); } @Override public boolean remove(Object key) { return removeInternalByKey(key) != null; } @Override public void clear() { LinkedHashTreeMap.this.clear(); } } /** * If somebody is unlucky enough to have to serialize one of these, serialize * it as a LinkedHashMap so that they won't need Gson on the other side to * deserialize it. Using serialization defeats our DoS defence, so most apps * shouldn't use it. */ private Object writeReplace() throws ObjectStreamException { return new LinkedHashMap<K, V>(this); } }