weakidentitycollection.java

jsr170接口的java实现。是个apache的开源项目。

/*
 * 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.jackrabbit.util;

import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.BitSet;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.lang.ref.ReferenceQueue;

/**
 * <code>WeakIdentityCollection</code> implements a Collection with weak values.
 * Equality of elements is tested using the == operator.
 * <p/>
 * This collection does not hide the fact that the garbage collector will remove
 * a mapping at some point in time. Thus, the {@link java.util.Iterator} returned
 * by this collection might return <code>null</code> values. The same applies
 * to the method {@link #toArray()} in both its variants.
 */
public class WeakIdentityCollection implements Collection {

    /**
     * The weak references.
     */
    private transient WeakRef[] elementData;

    /**
     * The current number of elements in {@link #elementData}.
     */
    private int size;

    /**
     * The reference queue to poll for references that point to unreachable
     * objects.
     */
    private final ReferenceQueue refQueue = new ReferenceQueue();

    /**
     * BitSet where a set bit indicates that the slot at this position in
     * {@link #elementData} is empty and can be reused.
     */
    private final BitSet emptySlots = new BitSet();

    /**
     * Creates a new WeakIdentityCollection.
     *
     * @param initialCapacity the initial capacity.
     */
    public WeakIdentityCollection(int initialCapacity) {
        if (initialCapacity < 0) {
            throw new IllegalArgumentException("Illegal Capacity: " +
                    initialCapacity);
        }
        this.elementData = new WeakRef[initialCapacity];
    }

    /**
     * Returns the current size of this collection.
     *
     * @return the current size of this collection.
     */
    public int size() {
        return size;
    }

    /**
     * Returns <code>true</code> if this collection is empty.
     *
     * @return <code>true</code> if this collection is empty.
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * Releases all references held by this collection.
     */
    public void clear() {
        for (int i = 0; i < size; i++) {
            elementData[i] = null;
        }
        size = 0;
        emptySlots.clear();
    }

    /**
     * Adds object <code>o</code> to this collection.
     *
     * @param o the object to add.
     * @return always <code>true</code> as this collection allows duplicates.
     * @throws NullPointerException if <code>o</code> is <code>null</code>.
     */
    public boolean add(Object o) {
        if (o == null) {
            throw new NullPointerException("Object must not be null");
        }
        // poll refQueue for a slot we can reuse
        WeakRef ref = (WeakRef) refQueue.poll();
        if (ref != null) {
            elementData[ref.index] = new WeakRef(o, ref.index);
            cleanQueue();
        } else if (!emptySlots.isEmpty()) {
            int idx = emptySlots.nextSetBit(0);
            elementData[idx] = new WeakRef(o, idx);
            emptySlots.clear(idx);
        } else {
            ensureCapacity(size + 1);
            elementData[size++] = new WeakRef(o, size - 1);
        }
        return true;
    }

    /**
     * Returns <code>true</code> if this collection contains <code>o</code>.
     *
     * @param o element whose presence in this collection is to be tested.
     * @return <code>true</code> if this collection contains the specified
     *         element
     */
    public boolean contains(Object o) {
        for (int i = 0; i < size; i++) {
            if (elementData[i].get() == o) {
                return true;
            }
        }
        return false;
    }

    /**
     * Removes the object <code>o</code> from this collection if it is present.
     *
     * @param o the object to remove.
     * @return <code>true</code> if this collection changed as a result of the
     *         call.
     */
    public boolean remove(Object o) {
        for (int i = 0; i < size; i++) {
            if (elementData[i].get() == o) {
                emptySlots.set(i);
                // overwrite entry with dummy ref
                elementData[i] = new WeakRef(null, i);
                return true;
            }
        }
        return false;
    }

    /**
     * @throws UnsupportedOperationException always.
     */
    public boolean addAll(Collection c) {
        throw new UnsupportedOperationException("addAll");
    }

    /**
     * @throws UnsupportedOperationException always.
     */
    public boolean containsAll(Collection c) {
        throw new UnsupportedOperationException("containsAll");
    }

    /**
     * @throws UnsupportedOperationException always.
     */
    public boolean removeAll(Collection c) {
        throw new UnsupportedOperationException("removeAll");
    }

    /**
     * @throws UnsupportedOperationException always.
     */
    public boolean retainAll(Collection c) {
        throw new UnsupportedOperationException("retainAll");
    }

    /**
     * Returns an {@link java.util.Iterator} over the elements of this
     * collection. The returned iterator is not fail-fast. That is, it does
     * not throw a {@link java.util.ConcurrentModificationException} if this
     * collection is modified while iterating over the collection.
     *
     * @return an {@link java.util.Iterator} over the elements of this
     *         collection.
     */
    public Iterator iterator() {
        return new Iter();
    }

    /**
     * Returns an array containing all of the elements in this collection. The
     * returned array may contain <code>null</code> elements!
     *
     * @return an array containing all of the elements in this collection.
     */
    public Object[] toArray() {
        Object[] result = new Object[size];
        for (int i = 0; i < result.length; i++) {
            result[i] = elementData[i].get();
        }
        return result;
    }

    /**
     * The returned array may contain <code>null</code> elements!
     * @inheritDoc
     */
    public Object[] toArray(Object a[]) {
        if (a.length < size) {
            a = (Object[]) java.lang.reflect.Array.newInstance(a.getClass().getComponentType(), size);
        }

        for (int i = 0; i < size; i++) {
            a[i] = elementData[i].get();
        }

        if (a.length > size) {
            a[size] = null;
        }

        return a;
    }

    /**
     * Ensures that the internal {@link #elementData} has
     * <code>minCapacity</code>.
     *
     * @param minCapacity the minimal capacity to ensure.
     */
    private void ensureCapacity(int minCapacity) {
        int oldCapacity = elementData.length;
        if (minCapacity > oldCapacity) {
            Object oldData[] = elementData;
            int newCapacity = (oldCapacity * 3)/2 + 1;
                if (newCapacity < minCapacity)
            newCapacity = minCapacity;
            elementData = new WeakRef[newCapacity];
            System.arraycopy(oldData, 0, elementData, 0, size);
        }
    }

    /**
     * Polls the reference queue until no reference is available anymore.
     */
    private void cleanQueue() {
        WeakRef ref;
        while ((ref = (WeakRef) refQueue.poll()) != null) {
            emptySlots.set(ref.index);
        }
    }

    /**
     * Iterator implementation for this collecation.
     */
    private final class Iter implements Iterator {

        /**
         * current index.
         */
        private int index;

        /**
         * The current element data.
         */
        private Reference[] elements = elementData;

        /**
         * The current size of this collection.
         */
        private int size = WeakIdentityCollection.this.size;

        /**
         * @throws UnsupportedOperationException always.
         */
        public void remove() {
            throw new UnsupportedOperationException("remove");
        }

        /**
         * @inheritDoc
         */
        public boolean hasNext() {
            return index < size;
        }

        /**
         * @inheritDoc
         */
        public Object next() {
            if (index >= size) {
                throw new NoSuchElementException();
            }
            return elements[index++].get();
        }
    }

    /**
     * Weak reference with index value that points to the slot in {@link
     * WeakIdentityCollection#elementData}.
     */
    private final class WeakRef extends WeakReference {

        /**
         * The index of this weak reference.
         */
        private final int index;

        /**
         * Creates a new WeakRef.
         *
         * @param referent object the new weak reference will refer to.
         * @param index    the index of this weak reference.
         */
        public WeakRef(Object referent, int index) {
            super(referent, refQueue);
            this.index = index;
        }
    }
}