com.squareup.moshi.LinkedHashTreeMap Maven / Gradle / Ivy

Go to download
/*
 * Copyright (C) 2010 The Android Open Source Project
 * Copyright (C) 2012 Google Inc.
 *
 * 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.squareup.moshi;

import java.io.ObjectStreamException;
import java.io.Serializable;
import java.util.*;

/**
 * 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.
 * 
 * 
This implementation was derived from Android 4.1's TreeMap and
 * LinkedHashMap classes.
 */
final class LinkedHashTreeMap extends AbstractMap implements Serializable {
    @SuppressWarnings({"unchecked", "rawtypes"}) // to avoid Comparable>>
    private static final Comparator NATURAL_ORDER = new Comparator() {
        @Override
        public int compare(Comparable a, Comparable b) {
            return a.compareTo(b);
        }
    };

    Comparator comparator;
    Node[] table;
    final Node 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.
     */
    LinkedHashTreeMap() {
        this(null);
    }

    /**
     * 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.
    })
    LinkedHashTreeMap(Comparator comparator) {
        this.comparator = comparator != null
                ? comparator
                : (Comparator) NATURAL_ORDER;
        this.header = new Node();
        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 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 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 header = this.header;
        for (Node e = header.next; e != header; ) {
            Node next = e.next;
            e.next = e.prev = null;
            e = next;
        }

        header.next = header.prev = header;
    }

    @Override
    public V remove(Object key) {
        Node 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 find(K key, boolean create) {
        Comparator comparator = this.comparator;
        Node[] table = this.table;
        int hash = secondaryHash(key.hashCode());
        int index = hash & (table.length - 1);
        Node 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