net.sourceforge.stripes.util.ConcurrentHashSet Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of stripes Show documentation
Stripes web framework jar, including tag library.
There is a newer version: 1.7.0-async-beta
/* Copyright 2009 Ben Gunter
 *
 * 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 net.sourceforge.stripes.util;

import java.util.Collection;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

/**
 * A set based on {@link ConcurrentHashMap}. The Javadoc for the constructors in this class were
 * copied from the Java 1.5 Javadoc for {@link ConcurrentHashMap} and changed to reflect that this
 * is a Set and not a Map. See the Javadoc for {@link ConcurrentHashMap} for information on
 * performance characteristics, etc.
 * 
 * @author Ben Gunter
 */
public class ConcurrentHashSet implements Set {
    /** The value object that will be put in the map since it does not accept null values. */
    private static final Object VALUE = new Object();

    /** The map that backs this set. */
    private ConcurrentMap map;

    /**
     * Creates a new, empty map with a default initial capacity, load factor, and concurrencyLevel.
     */
    public ConcurrentHashSet() {
        map = new ConcurrentHashMap();
    }

    /**
     * Creates a new, empty map with the specified initial capacity, and with default load factor
     * and concurrencyLevel.
     * 
     * @param initialCapacity the initial capacity. The implementation performs internal sizing to
     *            accommodate this many elements.
     * @throws IllegalArgumentException if the initial capacity of elements is negative.
     */
    public ConcurrentHashSet(int initialCapacity) {
        map = new ConcurrentHashMap(initialCapacity);
    }

    /**
     * Creates a new, empty map with the specified initial capacity, load factor, and concurrency
     * level.
     * 
     * @param initialCapacity the initial capacity. The implementation performs internal sizing to
     *            accommodate this many elements.
     * @param loadFactor the load factor threshold, used to control resizing. Resizing may be
     *            performed when the average number of elements per bin exceeds this threshold.
     * @param concurrencyLevel - the estimated number of concurrently updating threads. The
     *            implementation performs internal sizing to try to accommodate this many threads.
     * @throws IllegalArgumentException if the initial capacity is negative or the load factor or
     *             concurrencyLevel are nonpositive.
     */
    public ConcurrentHashSet(int initialCapacity, float loadFactor, int concurrencyLevel) {
        map = new ConcurrentHashMap(initialCapacity, loadFactor, concurrencyLevel);
    }

    /**
     * Creates a new set with the same elements as the given set. The set is created with a capacity
     * of twice the number of elements in the given set or 11 (whichever is greater), and a default
     * load factor and concurrencyLevel.
     * 
     * @param set The set
     */
    public ConcurrentHashSet(Set set) {
        this(Math.max(set.size() * 2, 11));
        addAll(set);
    }

    public boolean add(T e) {
        return map.putIfAbsent(e, VALUE) == null;
    }

    public boolean addAll(Collection c) {
        boolean b = false;
        for (T t : c) {
            b = b || map.putIfAbsent(t, VALUE) == null;
        }
        return b;
    }

    public void clear() {
        map.clear();
    }

    public boolean contains(Object o) {
        return map.keySet().contains(o);
    }

    public boolean containsAll(Collection c) {
        return map.keySet().containsAll(c);
    }

    public boolean isEmpty() {
        return map.isEmpty();
    }

    public Iterator iterator() {
        return map.keySet().iterator();
    }

    public boolean remove(Object o) {
        return map.remove(o) != null;
    }

    public boolean removeAll(Collection c) {
        return map.keySet().removeAll(c);
    }

    public boolean retainAll(Collection c) {
        return map.keySet().retainAll(c);
    }

    public int size() {
        return map.size();
    }

    public Object[] toArray() {
        return map.keySet().toArray();
    }

    public  E[] toArray(E[] a) {
        return map.keySet().toArray(a);
    }
}