    001/*
    002 * Licensed to the Apache Software Foundation (ASF) under one or more
    003 * contributor license agreements.  See the NOTICE file distributed with
    004 * this work for additional information regarding copyright ownership.
    005 * The ASF licenses this file to You under the Apache License, Version 2.0
    006 * (the "License"); you may not use this file except in compliance with
    007 * the License.  You may obtain a copy of the License at
    008 *
    009 *      http://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 * Unless required by applicable law or agreed to in writing, software
    012 * distributed under the License is distributed on an "AS IS" BASIS,
    013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 * See the License for the specific language governing permissions and
    015 * limitations under the License.
    016 */
    017package org.apache.commons.collections4.map;
    018
    019import java.io.IOException;
    020import java.io.ObjectInputStream;
    021import java.io.ObjectOutputStream;
    022import java.lang.ref.Reference;
    023import java.lang.ref.ReferenceQueue;
    024import java.lang.ref.SoftReference;
    025import java.lang.ref.WeakReference;
    026import java.util.ArrayList;
    027import java.util.Collection;
    028import java.util.ConcurrentModificationException;
    029import java.util.Iterator;
    030import java.util.List;
    031import java.util.Map;
    032import java.util.NoSuchElementException;
    033import java.util.Set;
    034
    035import org.apache.commons.collections4.MapIterator;
    036import org.apache.commons.collections4.keyvalue.DefaultMapEntry;
    037
    038/**
    039 * An abstract implementation of a hash-based map that allows the entries to
    040 * be removed by the garbage collector.
    041 * <p>
    042 * This class implements all the features necessary for a subclass reference
    043 * hash-based map. Key-value entries are stored in instances of the
    044 * <code>ReferenceEntry</code> class which can be overridden and replaced.
    045 * The iterators can similarly be replaced, without the need to replace the KeySet,
    046 * EntrySet and Values view classes.
    047 * </p>
    048 * <p>
    049 * Overridable methods are provided to change the default hashing behaviour, and
    050 * to change how entries are added to and removed from the map. Hopefully, all you
    051 * need for unusual subclasses is here.
    052 * </p>
    053 * <p>
    054 * When you construct an <code>AbstractReferenceMap</code>, you can specify what
    055 * kind of references are used to store the map's keys and values.
    056 * If non-hard references are used, then the garbage collector can remove
    057 * mappings if a key or value becomes unreachable, or if the JVM's memory is
    058 * running low. For information on how the different reference types behave,
    059 * see {@link Reference}.
    060 * </p>
    061 * <p>
    062 * Different types of references can be specified for keys and values.
    063 * The keys can be configured to be weak but the values hard,
    064 * in which case this class will behave like a
    065 * <a href="http://java.sun.com/j2se/1.4/docs/api/java/util/WeakHashMap.html">
    066 * <code>WeakHashMap</code></a>. However, you can also specify hard keys and
    067 * weak values, or any other combination. The default constructor uses
    068 * hard keys and soft values, providing a memory-sensitive cache.
    069 * </p>
    070 * <p>
    071 * This {@link Map} implementation does <i>not</i> allow null elements.
    072 * Attempting to add a null key or value to the map will raise a
    073 * <code>NullPointerException</code>.
    074 * </p>
    075 * <p>
    076 * All the available iterators can be reset back to the start by casting to
    077 * <code>ResettableIterator</code> and calling <code>reset()</code>.
    078 * </p>
    079 * <p>
    080 * This implementation is not synchronized.
    081 * You can use {@link java.util.Collections#synchronizedMap} to
    082 * provide synchronized access to a <code>ReferenceMap</code>.
    083 * </p>
    084 *
    085 * @param <K> the type of the keys in this map
    086 * @param <V> the type of the values in this map
    087 *
    088 * @see java.lang.ref.Reference
    089 * @since 3.1 (extracted from ReferenceMap in 3.0)
    090 */
    091public abstract class AbstractReferenceMap<K, V> extends AbstractHashedMap<K, V> {
    092
    093    /**
    094     * Reference type enum.
    095     */
    096    public enum ReferenceStrength {
    097        HARD(0), SOFT(1), WEAK(2);
    098
    099        /** value */
    100        public final int value;
    101
    102        /**
    103         * Resolve enum from int.
    104         * @param value  the int value
    105         * @return ReferenceType
    106         * @throws IllegalArgumentException if the specified value is invalid.
    107         */
    108        public static ReferenceStrength resolve(final int value) {
    109            switch (value) {
    110            case 0:
    111                return HARD;
    112            case 1:
    113                return SOFT;
    114            case 2:
    115                return WEAK;
    116            default:
    117                throw new IllegalArgumentException();
    118            }
    119        }
    120
    121        ReferenceStrength(final int value) {
    122            this.value = value;
    123        }
    124
    125    }
    126
    127    /**
    128     * The reference type for keys.
    129     */
    130    private ReferenceStrength keyType;
    131
    132    /**
    133     * The reference type for values.
    134     */
    135    private ReferenceStrength valueType;
    136
    137    /**
    138     * Should the value be automatically purged when the associated key has been collected?
    139     */
    140    private boolean purgeValues;
    141
    142    /**
    143     * ReferenceQueue used to eliminate stale mappings.
    144     * See purge.
    145     */
    146    private transient ReferenceQueue<Object> queue;
    147
    148    //-----------------------------------------------------------------------
    149    /**
    150     * Constructor used during deserialization.
    151     */
    152    protected AbstractReferenceMap() {
    153        super();
    154    }
    155
    156    /**
    157     * Constructs a new empty map with the specified reference types,
    158     * load factor and initial capacity.
    159     *
    160     * @param keyType  the type of reference to use for keys;
    161     *   must be {@link ReferenceStrength#HARD HARD},
    162     *   {@link ReferenceStrength#SOFT SOFT},
    163     *   {@link ReferenceStrength#WEAK WEAK}
    164     * @param valueType  the type of reference to use for values;
    165     *   must be {@link ReferenceStrength#HARD},
    166     *   {@link ReferenceStrength#SOFT SOFT},
    167     *   {@link ReferenceStrength#WEAK WEAK}
    168     * @param capacity  the initial capacity for the map
    169     * @param loadFactor  the load factor for the map
    170     * @param purgeValues  should the value be automatically purged when the
    171     *   key is garbage collected
    172     */
    173    protected AbstractReferenceMap(
    174            final ReferenceStrength keyType, final ReferenceStrength valueType, final int capacity,
    175            final float loadFactor, final boolean purgeValues) {
    176        super(capacity, loadFactor);
    177        this.keyType = keyType;
    178        this.valueType = valueType;
    179        this.purgeValues = purgeValues;
    180    }
    181
    182    /**
    183     * Initialise this subclass during construction, cloning or deserialization.
    184     */
    185    @Override
    186    protected void init() {
    187        queue = new ReferenceQueue<>();
    188    }
    189
    190    //-----------------------------------------------------------------------
    191    /**
    192     * Gets the size of the map.
    193     *
    194     * @return the size
    195     */
    196    @Override
    197    public int size() {
    198        purgeBeforeRead();
    199        return super.size();
    200    }
    201
    202    /**
    203     * Checks whether the map is currently empty.
    204     *
    205     * @return true if the map is currently size zero
    206     */
    207    @Override
    208    public boolean isEmpty() {
    209        purgeBeforeRead();
    210        return super.isEmpty();
    211    }
    212
    213    /**
    214     * Checks whether the map contains the specified key.
    215     *
    216     * @param key  the key to search for
    217     * @return true if the map contains the key
    218     */
    219    @Override
    220    public boolean containsKey(final Object key) {
    221        purgeBeforeRead();
    222        final Entry<K, V> entry = getEntry(key);
    223        if (entry == null) {
    224            return false;
    225        }
    226        return entry.getValue() != null;
    227    }
    228
    229    /**
    230     * Checks whether the map contains the specified value.
    231     *
    232     * @param value  the value to search for
    233     * @return true if the map contains the value
    234     */
    235    @Override
    236    public boolean containsValue(final Object value) {
    237        purgeBeforeRead();
    238        if (value == null) {
    239            return false;
    240        }
    241        return super.containsValue(value);
    242    }
    243
    244    /**
    245     * Gets the value mapped to the key specified.
    246     *
    247     * @param key  the key
    248     * @return the mapped value, null if no match
    249     */
    250    @Override
    251    public V get(final Object key) {
    252        purgeBeforeRead();
    253        final Entry<K, V> entry = getEntry(key);
    254        if (entry == null) {
    255            return null;
    256        }
    257        return entry.getValue();
    258    }
    259
    260
    261    /**
    262     * Puts a key-value mapping into this map.
    263     * Neither the key nor the value may be null.
    264     *
    265     * @param key  the key to add, must not be null
    266     * @param value  the value to add, must not be null
    267     * @return the value previously mapped to this key, null if none
    268     * @throws NullPointerException if either the key or value is null
    269     */
    270    @Override
    271    public V put(final K key, final V value) {
    272        if (key == null) {
    273            throw new NullPointerException("null keys not allowed");
    274        }
    275        if (value == null) {
    276            throw new NullPointerException("null values not allowed");
    277        }
    278
    279        purgeBeforeWrite();
    280        return super.put(key, value);
    281    }
    282
    283    /**
    284     * Removes the specified mapping from this map.
    285     *
    286     * @param key  the mapping to remove
    287     * @return the value mapped to the removed key, null if key not in map
    288     */
    289    @Override
    290    public V remove(final Object key) {
    291        if (key == null) {
    292            return null;
    293        }
    294        purgeBeforeWrite();
    295        return super.remove(key);
    296    }
    297
    298    /**
    299     * Clears this map.
    300     */
    301    @Override
    302    public void clear() {
    303        super.clear();
    304        // drain the queue
    305        while (queue.poll() != null) {
    306            // empty
    307        }
    308    }
    309
    310    //-----------------------------------------------------------------------
    311    /**
    312     * Gets a MapIterator over the reference map.
    313     * The iterator only returns valid key/value pairs.
    314     *
    315     * @return a map iterator
    316     */
    317    @Override
    318    public MapIterator<K, V> mapIterator() {
    319        return new ReferenceMapIterator<>(this);
    320    }
    321
    322    /**
    323     * Returns a set view of this map's entries.
    324     * An iterator returned entry is valid until <code>next()</code> is called again.
    325     * The <code>setValue()</code> method on the <code>toArray</code> entries has no effect.
    326     *
    327     * @return a set view of this map's entries
    328     */
    329    @Override
    330    public Set<Map.Entry<K, V>> entrySet() {
    331        if (entrySet == null) {
    332            entrySet = new ReferenceEntrySet<>(this);
    333        }
    334        return entrySet;
    335    }
    336
    337    /**
    338     * Returns a set view of this map's keys.
    339     *
    340     * @return a set view of this map's keys
    341     */
    342    @Override
    343    public Set<K> keySet() {
    344        if (keySet == null) {
    345            keySet = new ReferenceKeySet<>(this);
    346        }
    347        return keySet;
    348    }
    349
    350    /**
    351     * Returns a collection view of this map's values.
    352     *
    353     * @return a set view of this map's values
    354     */
    355    @Override
    356    public Collection<V> values() {
    357        if (values == null) {
    358            values = new ReferenceValues<>(this);
    359        }
    360        return values;
    361    }
    362
    363    //-----------------------------------------------------------------------
    364    /**
    365     * Purges stale mappings from this map before read operations.
    366     * <p>
    367     * This implementation calls {@link #purge()} to maintain a consistent state.
    368     */
    369    protected void purgeBeforeRead() {
    370        purge();
    371    }
    372
    373    /**
    374     * Purges stale mappings from this map before write operations.
    375     * <p>
    376     * This implementation calls {@link #purge()} to maintain a consistent state.
    377     */
    378    protected void purgeBeforeWrite() {
    379        purge();
    380    }
    381
    382    /**
    383     * Purges stale mappings from this map.
    384     * <p>
    385     * Note that this method is not synchronized!  Special
    386     * care must be taken if, for instance, you want stale
    387     * mappings to be removed on a periodic basis by some
    388     * background thread.
    389     */
    390    protected void purge() {
    391        Reference<?> ref = queue.poll();
    392        while (ref != null) {
    393            purge(ref);
    394            ref = queue.poll();
    395        }
    396    }
    397
    398    /**
    399     * Purges the specified reference.
    400     *
    401     * @param ref  the reference to purge
    402     */
    403    protected void purge(final Reference<?> ref) {
    404        // The hashCode of the reference is the hashCode of the
    405        // mapping key, even if the reference refers to the
    406        // mapping value...
    407        final int hash = ref.hashCode();
    408        final int index = hashIndex(hash, data.length);
    409        HashEntry<K, V> previous = null;
    410        HashEntry<K, V> entry = data[index];
    411        while (entry != null) {
    412            ReferenceEntry<K, V> refEntry = (ReferenceEntry<K, V>) entry;
    413            if (refEntry.purge(ref)) {
    414                if (previous == null) {
    415                    data[index] = entry.next;
    416                } else {
    417                    previous.next = entry.next;
    418                }
    419                this.size--;
    420                refEntry.onPurge();
    421                return;
    422            }
    423            previous = entry;
    424            entry = entry.next;
    425        }
    426
    427    }
    428
    429    //-----------------------------------------------------------------------
    430    /**
    431     * Gets the entry mapped to the key specified.
    432     *
    433     * @param key  the key
    434     * @return the entry, null if no match
    435     */
    436    @Override
    437    protected HashEntry<K, V> getEntry(final Object key) {
    438        if (key == null) {
    439            return null;
    440        }
    441        return super.getEntry(key);
    442    }
    443
    444    /**
    445     * Gets the hash code for a MapEntry.
    446     * Subclasses can override this, for example to use the identityHashCode.
    447     *
    448     * @param key  the key to get a hash code for, may be null
    449     * @param value  the value to get a hash code for, may be null
    450     * @return the hash code, as per the MapEntry specification
    451     */
    452    protected int hashEntry(final Object key, final Object value) {
    453        return (key == null ? 0 : key.hashCode()) ^
    454               (value == null ? 0 : value.hashCode());
    455    }
    456
    457    /**
    458     * Compares two keys, in internal converted form, to see if they are equal.
    459     * <p>
    460     * This implementation converts the key from the entry to a real reference
    461     * before comparison.
    462     *
    463     * @param key1  the first key to compare passed in from outside
    464     * @param key2  the second key extracted from the entry via <code>entry.key</code>
    465     * @return true if equal
    466     */
    467    @Override
    468    @SuppressWarnings("unchecked")
    469    protected boolean isEqualKey(final Object key1, Object key2) {
    470        key2 = keyType == ReferenceStrength.HARD ? key2 : ((Reference<K>) key2).get();
    471        return key1 == key2 || key1.equals(key2);
    472    }
    473
    474    /**
    475     * Creates a ReferenceEntry instead of a HashEntry.
    476     *
    477     * @param next  the next entry in sequence
    478     * @param hashCode  the hash code to use
    479     * @param key  the key to store
    480     * @param value  the value to store
    481     * @return the newly created entry
    482     */
    483    @Override
    484    protected ReferenceEntry<K, V> createEntry(final HashEntry<K, V> next, final int hashCode,
    485                                               final K key, final V value) {
    486        return new ReferenceEntry<>(this, next, hashCode, key, value);
    487    }
    488
    489    /**
    490     * Creates an entry set iterator.
    491     *
    492     * @return the entrySet iterator
    493     */
    494    @Override
    495    protected Iterator<Map.Entry<K, V>> createEntrySetIterator() {
    496        return new ReferenceEntrySetIterator<>(this);
    497    }
    498
    499    /**
    500     * Creates an key set iterator.
    501     *
    502     * @return the keySet iterator
    503     */
    504    @Override
    505    protected Iterator<K> createKeySetIterator() {
    506        return new ReferenceKeySetIterator<>(this);
    507    }
    508
    509    /**
    510     * Creates an values iterator.
    511     *
    512     * @return the values iterator
    513     */
    514    @Override
    515    protected Iterator<V> createValuesIterator() {
    516        return new ReferenceValuesIterator<>(this);
    517    }
    518
    519    //-----------------------------------------------------------------------
    520    /**
    521     * EntrySet implementation.
    522     */
    523    static class ReferenceEntrySet<K, V> extends EntrySet<K, V> {
    524
    525        protected ReferenceEntrySet(final AbstractHashedMap<K, V> parent) {
    526            super(parent);
    527        }
    528
    529        @Override
    530        public Object[] toArray() {
    531            return toArray(new Object[size()]);
    532        }
    533
    534        @Override
    535        public <T> T[] toArray(final T[] arr) {
    536            // special implementation to handle disappearing entries
    537            final ArrayList<Map.Entry<K, V>> list = new ArrayList<>(size());
    538            for (final Map.Entry<K, V> entry : this) {
    539                list.add(new DefaultMapEntry<>(entry));
    540            }
    541            return list.toArray(arr);
    542        }
    543    }
    544
    545    //-----------------------------------------------------------------------
    546    /**
    547     * KeySet implementation.
    548     */
    549    static class ReferenceKeySet<K> extends KeySet<K> {
    550
    551        protected ReferenceKeySet(final AbstractHashedMap<K, ?> parent) {
    552            super(parent);
    553        }
    554
    555        @Override
    556        public Object[] toArray() {
    557            return toArray(new Object[size()]);
    558        }
    559
    560        @Override
    561        public <T> T[] toArray(final T[] arr) {
    562            // special implementation to handle disappearing keys
    563            final List<K> list = new ArrayList<>(size());
    564            for (final K key : this) {
    565                list.add(key);
    566            }
    567            return list.toArray(arr);
    568        }
    569    }
    570
    571    //-----------------------------------------------------------------------
    572    /**
    573     * Values implementation.
    574     */
    575    static class ReferenceValues<V> extends Values<V> {
    576
    577        protected ReferenceValues(final AbstractHashedMap<?, V> parent) {
    578            super(parent);
    579        }
    580
    581        @Override
    582        public Object[] toArray() {
    583            return toArray(new Object[size()]);
    584        }
    585
    586        @Override
    587        public <T> T[] toArray(final T[] arr) {
    588            // special implementation to handle disappearing values
    589            final List<V> list = new ArrayList<>(size());
    590            for (final V value : this) {
    591                list.add(value);
    592            }
    593            return list.toArray(arr);
    594        }
    595    }
    596
    597    //-----------------------------------------------------------------------
    598    /**
    599     * A MapEntry implementation for the map.
    600     * <p>
    601     * If getKey() or getValue() returns null, it means
    602     * the mapping is stale and should be removed.
    603     *
    604     * @since 3.1
    605     */
    606    protected static class ReferenceEntry<K, V> extends HashEntry<K, V> {
    607        /** The parent map */
    608        private final AbstractReferenceMap<K, V> parent;
    609
    610        /**
    611         * Creates a new entry object for the ReferenceMap.
    612         *
    613         * @param parent  the parent map
    614         * @param next  the next entry in the hash bucket
    615         * @param hashCode  the hash code of the key
    616         * @param key  the key
    617         * @param value  the value
    618         */
    619        public ReferenceEntry(final AbstractReferenceMap<K, V> parent, final HashEntry<K, V> next,
    620                              final int hashCode, final K key, final V value) {
    621            super(next, hashCode, null, null);
    622            this.parent = parent;
    623            this.key = toReference(parent.keyType, key, hashCode);
    624            this.value = toReference(parent.valueType, value, hashCode); // the key hashCode is passed in deliberately
    625        }
    626
    627        /**
    628         * Gets the key from the entry.
    629         * This method dereferences weak and soft keys and thus may return null.
    630         *
    631         * @return the key, which may be null if it was garbage collected
    632         */
    633        @Override
    634        @SuppressWarnings("unchecked")
    635        public K getKey() {
    636            return (K) (parent.keyType == ReferenceStrength.HARD ? key : ((Reference<K>) key).get());
    637        }
    638
    639        /**
    640         * Gets the value from the entry.
    641         * This method dereferences weak and soft value and thus may return null.
    642         *
    643         * @return the value, which may be null if it was garbage collected
    644         */
    645        @Override
    646        @SuppressWarnings("unchecked")
    647        public V getValue() {
    648            return (V) (parent.valueType == ReferenceStrength.HARD ? value : ((Reference<V>) value).get());
    649        }
    650
    651        /**
    652         * Sets the value of the entry.
    653         *
    654         * @param obj  the object to store
    655         * @return the previous value
    656         */
    657        @Override
    658        @SuppressWarnings("unchecked")
    659        public V setValue(final V obj) {
    660            final V old = getValue();
    661            if (parent.valueType != ReferenceStrength.HARD) {
    662                ((Reference<V>) value).clear();
    663            }
    664            value = toReference(parent.valueType, obj, hashCode);
    665            return old;
    666        }
    667
    668        /**
    669         * Compares this map entry to another.
    670         * <p>
    671         * This implementation uses <code>isEqualKey</code> and
    672         * <code>isEqualValue</code> on the main map for comparison.
    673         *
    674         * @param obj  the other map entry to compare to
    675         * @return true if equal, false if not
    676         */
    677        @Override
    678        public boolean equals(final Object obj) {
    679            if (obj == this) {
    680                return true;
    681            }
    682            if (obj instanceof Map.Entry == false) {
    683                return false;
    684            }
    685
    686            final Map.Entry<?, ?> entry = (Map.Entry<?, ?>)obj;
    687            final Object entryKey = entry.getKey();  // convert to hard reference
    688            final Object entryValue = entry.getValue();  // convert to hard reference
    689            if (entryKey == null || entryValue == null) {
    690                return false;
    691            }
    692            // compare using map methods, aiding identity subclass
    693            // note that key is direct access and value is via method
    694            return parent.isEqualKey(entryKey, key) &&
    695                   parent.isEqualValue(entryValue, getValue());
    696        }
    697
    698        /**
    699         * Gets the hashcode of the entry using temporary hard references.
    700         * <p>
    701         * This implementation uses <code>hashEntry</code> on the main map.
    702         *
    703         * @return the hashcode of the entry
    704         */
    705        @Override
    706        public int hashCode() {
    707            return parent.hashEntry(getKey(), getValue());
    708        }
    709
    710        /**
    711         * Constructs a reference of the given type to the given referent.
    712         * The reference is registered with the queue for later purging.
    713         *
    714         * @param <T> the type of the referenced object
    715         * @param type  HARD, SOFT or WEAK
    716         * @param referent  the object to refer to
    717         * @param hash  the hash code of the <i>key</i> of the mapping;
    718         *    this number might be different from referent.hashCode() if
    719         *    the referent represents a value and not a key
    720         * @return the reference to the object
    721         */
    722        protected <T> Object toReference(final ReferenceStrength type, final T referent, final int hash) {
    723            if (type == ReferenceStrength.HARD) {
    724                return referent;
    725            }
    726            if (type == ReferenceStrength.SOFT) {
    727                return new SoftRef<>(hash, referent, parent.queue);
    728            }
    729            if (type == ReferenceStrength.WEAK) {
    730                return new WeakRef<>(hash, referent, parent.queue);
    731            }
    732            throw new Error();
    733        }
    734
    735        /**
    736         * This is the callback for custom "after purge" logic
    737         */
    738        protected void onPurge() {
    739            // empty
    740        }
    741
    742        /**
    743         * Purges the specified reference
    744         * @param ref  the reference to purge
    745         * @return true or false
    746         */
    747        protected boolean purge(final Reference<?> ref) {
    748            boolean r = parent.keyType != ReferenceStrength.HARD && key == ref;
    749            r = r || parent.valueType != ReferenceStrength.HARD && value == ref;
    750            if (r) {
    751                if (parent.keyType != ReferenceStrength.HARD) {
    752                    ((Reference<?>) key).clear();
    753                }
    754                if (parent.valueType != ReferenceStrength.HARD) {
    755                    ((Reference<?>) value).clear();
    756                } else if (parent.purgeValues) {
    757                    nullValue();
    758                }
    759            }
    760            return r;
    761        }
    762
    763        /**
    764         * Gets the next entry in the bucket.
    765         *
    766         * @return the next entry in the bucket
    767         */
    768        protected ReferenceEntry<K, V> next() {
    769            return (ReferenceEntry<K, V>) next;
    770        }
    771
    772        /**
    773         * This method can be overriden to provide custom logic to purge value
    774         */
    775        protected void nullValue() {
    776            value = null;
    777        }
    778    }
    779
    780    //-----------------------------------------------------------------------
    781    /**
    782     * Base iterator class.
    783     */
    784    static class ReferenceBaseIterator<K, V> {
    785        /** The parent map */
    786        final AbstractReferenceMap<K, V> parent;
    787
    788        // These fields keep track of where we are in the table.
    789        int index;
    790        ReferenceEntry<K, V> entry;
    791        ReferenceEntry<K, V> previous;
    792
    793        // These Object fields provide hard references to the
    794        // current and next entry; this assures that if hasNext()
    795        // returns true, next() will actually return a valid element.
    796        K currentKey, nextKey;
    797        V currentValue, nextValue;
    798
    799        int expectedModCount;
    800
    801        public ReferenceBaseIterator(final AbstractReferenceMap<K, V> parent) {
    802            super();
    803            this.parent = parent;
    804            index = parent.size() != 0 ? parent.data.length : 0;
    805            // have to do this here!  size() invocation above
    806            // may have altered the modCount.
    807            expectedModCount = parent.modCount;
    808        }
    809
    810        public boolean hasNext() {
    811            checkMod();
    812            while (nextNull()) {
    813                ReferenceEntry<K, V> e = entry;
    814                int i = index;
    815                while (e == null && i > 0) {
    816                    i--;
    817                    e = (ReferenceEntry<K, V>) parent.data[i];
    818                }
    819                entry = e;
    820                index = i;
    821                if (e == null) {
    822                    currentKey = null;
    823                    currentValue = null;
    824                    return false;
    825                }
    826                nextKey = e.getKey();
    827                nextValue = e.getValue();
    828                if (nextNull()) {
    829                    entry = entry.next();
    830                }
    831            }
    832            return true;
    833        }
    834
    835        private void checkMod() {
    836            if (parent.modCount != expectedModCount) {
    837                throw new ConcurrentModificationException();
    838            }
    839        }
    840
    841        private boolean nextNull() {
    842            return nextKey == null || nextValue == null;
    843        }
    844
    845        protected ReferenceEntry<K, V> nextEntry() {
    846            checkMod();
    847            if (nextNull() && !hasNext()) {
    848                throw new NoSuchElementException();
    849            }
    850            previous = entry;
    851            entry = entry.next();
    852            currentKey = nextKey;
    853            currentValue = nextValue;
    854            nextKey = null;
    855            nextValue = null;
    856            return previous;
    857        }
    858
    859        protected ReferenceEntry<K, V> currentEntry() {
    860            checkMod();
    861            return previous;
    862        }
    863
    864        public void remove() {
    865            checkMod();
    866            if (previous == null) {
    867                throw new IllegalStateException();
    868            }
    869            parent.remove(currentKey);
    870            previous = null;
    871            currentKey = null;
    872            currentValue = null;
    873            expectedModCount = parent.modCount;
    874        }
    875    }
    876
    877    /**
    878     * The EntrySet iterator.
    879     */
    880    static class ReferenceEntrySetIterator<K, V>
    881            extends ReferenceBaseIterator<K, V> implements Iterator<Map.Entry<K, V>> {
    882
    883        public ReferenceEntrySetIterator(final AbstractReferenceMap<K, V> parent) {
    884            super(parent);
    885        }
    886
    887        @Override
    888        public Map.Entry<K, V> next() {
    889            return nextEntry();
    890        }
    891
    892    }
    893
    894    /**
    895     * The keySet iterator.
    896     */
    897    static class ReferenceKeySetIterator<K> extends ReferenceBaseIterator<K, Object> implements Iterator<K> {
    898
    899        @SuppressWarnings("unchecked")
    900        ReferenceKeySetIterator(final AbstractReferenceMap<K, ?> parent) {
    901            super((AbstractReferenceMap<K, Object>) parent);
    902        }
    903
    904        @Override
    905        public K next() {
    906            return nextEntry().getKey();
    907        }
    908    }
    909
    910    /**
    911     * The values iterator.
    912     */
    913    static class ReferenceValuesIterator<V> extends ReferenceBaseIterator<Object, V> implements Iterator<V> {
    914
    915        @SuppressWarnings("unchecked")
    916        ReferenceValuesIterator(final AbstractReferenceMap<?, V> parent) {
    917            super((AbstractReferenceMap<Object, V>) parent);
    918        }
    919
    920        @Override
    921        public V next() {
    922            return nextEntry().getValue();
    923        }
    924    }
    925
    926    /**
    927     * The MapIterator implementation.
    928     */
    929    static class ReferenceMapIterator<K, V> extends ReferenceBaseIterator<K, V> implements MapIterator<K, V> {
    930
    931        protected ReferenceMapIterator(final AbstractReferenceMap<K, V> parent) {
    932            super(parent);
    933        }
    934
    935        @Override
    936        public K next() {
    937            return nextEntry().getKey();
    938        }
    939
    940        @Override
    941        public K getKey() {
    942            final HashEntry<K, V> current = currentEntry();
    943            if (current == null) {
    944                throw new IllegalStateException(AbstractHashedMap.GETKEY_INVALID);
    945            }
    946            return current.getKey();
    947        }
    948
    949        @Override
    950        public V getValue() {
    951            final HashEntry<K, V> current = currentEntry();
    952            if (current == null) {
    953                throw new IllegalStateException(AbstractHashedMap.GETVALUE_INVALID);
    954            }
    955            return current.getValue();
    956        }
    957
    958        @Override
    959        public V setValue(final V value) {
    960            final HashEntry<K, V> current = currentEntry();
    961            if (current == null) {
    962                throw new IllegalStateException(AbstractHashedMap.SETVALUE_INVALID);
    963            }
    964            return current.setValue(value);
    965        }
    966    }
    967
    968    //-----------------------------------------------------------------------
    969    // These two classes store the hashCode of the key of
    970    // of the mapping, so that after they're dequeued a quick
    971    // lookup of the bucket in the table can occur.
    972
    973    /**
    974     * A soft reference holder.
    975     */
    976    static class SoftRef<T> extends SoftReference<T> {
    977        /** the hashCode of the key (even if the reference points to a value) */
    978        private final int hash;
    979
    980        public SoftRef(final int hash, final T r, final ReferenceQueue<? super T> q) {
    981            super(r, q);
    982            this.hash = hash;
    983        }
    984
    985        @Override
    986        public int hashCode() {
    987            return hash;
    988        }
    989    }
    990
    991    /**
    992     * A weak reference holder.
    993     */
    994    static class WeakRef<T> extends WeakReference<T> {
    995        /** the hashCode of the key (even if the reference points to a value) */
    996        private final int hash;
    997
    998        public WeakRef(final int hash, final T r, final ReferenceQueue<? super T> q) {
    999            super(r, q);
    1000            this.hash = hash;
    1001        }
    1002
    1003        @Override
    1004        public int hashCode() {
    1005            return hash;
    1006        }
    1007    }
    1008
    1009    //-----------------------------------------------------------------------
    1010    /**
    1011     * Replaces the superclass method to store the state of this class.
    1012     * <p>
    1013     * Serialization is not one of the JDK's nicest topics. Normal serialization will
    1014     * initialise the superclass before the subclass. Sometimes however, this isn't
    1015     * what you want, as in this case the <code>put()</code> method on read can be
    1016     * affected by subclass state.
    1017     * <p>
    1018     * The solution adopted here is to serialize the state data of this class in
    1019     * this protected method. This method must be called by the
    1020     * <code>writeObject()</code> of the first serializable subclass.
    1021     * <p>
    1022     * Subclasses may override if they have a specific field that must be present
    1023     * on read before this implementation will work. Generally, the read determines
    1024     * what must be serialized here, if anything.
    1025     *
    1026     * @param out  the output stream
    1027     * @throws IOException if an error occurs while writing to the stream
    1028     */
    1029    @Override
    1030    protected void doWriteObject(final ObjectOutputStream out) throws IOException {
    1031        out.writeInt(keyType.value);
    1032        out.writeInt(valueType.value);
    1033        out.writeBoolean(purgeValues);
    1034        out.writeFloat(loadFactor);
    1035        out.writeInt(data.length);
    1036        for (final MapIterator<K, V> it = mapIterator(); it.hasNext();) {
    1037            out.writeObject(it.next());
    1038            out.writeObject(it.getValue());
    1039        }
    1040        out.writeObject(null);  // null terminate map
    1041        // do not call super.doWriteObject() as code there doesn't work for reference map
    1042    }
    1043
    1044    /**
    1045     * Replaces the superclass method to read the state of this class.
    1046     * <p>
    1047     * Serialization is not one of the JDK's nicest topics. Normal serialization will
    1048     * initialise the superclass before the subclass. Sometimes however, this isn't
    1049     * what you want, as in this case the <code>put()</code> method on read can be
    1050     * affected by subclass state.
    1051     * <p>
    1052     * The solution adopted here is to deserialize the state data of this class in
    1053     * this protected method. This method must be called by the
    1054     * <code>readObject()</code> of the first serializable subclass.
    1055     * <p>
    1056     * Subclasses may override if the subclass has a specific field that must be present
    1057     * before <code>put()</code> or <code>calculateThreshold()</code> will work correctly.
    1058     *
    1059     * @param in  the input stream
    1060     * @throws IOException if an error occurs while reading from the stream
    1061     * @throws ClassNotFoundException if an object read from the stream can not be loaded
    1062     */
    1063    @Override
    1064    @SuppressWarnings("unchecked")
    1065    protected void doReadObject(final ObjectInputStream in) throws IOException, ClassNotFoundException {
    1066        this.keyType = ReferenceStrength.resolve(in.readInt());
    1067        this.valueType = ReferenceStrength.resolve(in.readInt());
    1068        this.purgeValues = in.readBoolean();
    1069        this.loadFactor = in.readFloat();
    1070        final int capacity = in.readInt();
    1071        init();
    1072        data = new HashEntry[capacity];
    1073
    1074        // COLLECTIONS-599: Calculate threshold before populating, otherwise it will be 0
    1075        // when it hits AbstractHashedMap.checkCapacity() and so will unnecessarily
    1076        // double up the size of the "data" array during population.
    1077        //
    1078        // NB: AbstractHashedMap.doReadObject() DOES calculate the threshold before populating.
    1079        //
    1080        threshold = calculateThreshold(data.length, loadFactor);
    1081
    1082        while (true) {
    1083            final K key = (K) in.readObject();
    1084            if (key == null) {
    1085                break;
    1086            }
    1087            final V value = (V) in.readObject();
    1088            put(key, value);
    1089        }
    1090        // do not call super.doReadObject() as code there doesn't work for reference map
    1091    }
    1092
    1093    /**
    1094     * Provided protected read-only access to the key type.
    1095     * @param type the type to check against.
    1096     * @return true if keyType has the specified type
    1097     */
    1098    protected boolean isKeyType(final ReferenceStrength type) {
    1099        return this.keyType == type;
    1100    }
    1101
    1102    /**
    1103     * Provided protected read-only access to the value type.
    1104     * @param type the type to check against.
    1105     * @return true if valueType has the specified type
    1106     */
    1107    protected boolean isValueType(final ReferenceStrength type) {
    1108        return this.valueType == type;
    1109    }
    1110}