* Copyright 2014 Goldman Sachs.

*

* 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.

*/

        implements MutableSet<T>, Externalizable, Pool<T>, BatchIterable<T>

    protected static final Object NULL_KEY = new Object()

    {

        @Override

        public boolean equals(Object obj)

        {

            throw new RuntimeException("Possible corruption through unsynchronized concurrent modification.");

        }

        @Override

        public int hashCode()

        {

            throw new RuntimeException("Possible corruption through unsynchronized concurrent modification.");

        }

        @Override

        public String toString()

        {

            return "UnifiedSet.NULL_KEY";

        }

    };

    protected static final float DEFAULT_LOAD_FACTOR = 0.75f;

    protected static final int DEFAULT_INITIAL_CAPACITY = 8;

    private static final long serialVersionUID = 1L;

    protected transient Object[] table;

    protected transient int occupied;

    protected float loadFactor = DEFAULT_LOAD_FACTOR;

    protected int maxSize;

    public UnifiedSet()

    {

        this.allocate(DEFAULT_INITIAL_CAPACITY << 1);

    }

    public UnifiedSet(int initialCapacity)

    {

        this(initialCapacity, DEFAULT_LOAD_FACTOR);

    }

    public UnifiedSet(int initialCapacity, float loadFactor)

    {

        if (initialCapacity < 0)

        {

            throw new IllegalArgumentException("initial capacity cannot be less than 0");

        }

        this.loadFactor = loadFactor;

        this.init(this.fastCeil(initialCapacity / loadFactor));

    }

    public UnifiedSet(Collection<? extends T> collection)

    {

        this(Math.max(collection.size(), DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);

        this.addAll(collection);

    }

    public UnifiedSet(UnifiedSet<T> set)

    {

        this.maxSize = set.maxSize;

        this.loadFactor = set.loadFactor;

        this.occupied = set.occupied;

        this.allocateTable(set.table.length);

        for (int i = 0; i < set.table.length; i++)

        {

            Object key = set.table[i];

            if (key instanceof ChainedBucket)

            {

                this.table[i] = ((ChainedBucket) key).copy();

            }

            else if (key != null)

            {

                this.table[i] = key;

            }

        }

    }

    public static <K> UnifiedSet<K> newSet()

    {

        return new UnifiedSet<K>();

    }

    public static <K> UnifiedSet<K> newSet(int size)

    {

        return new UnifiedSet<K>(size);

    }

    public static <K> UnifiedSet<K> newSet(Iterable<? extends K> source)

    {

        if (source instanceof UnifiedSet)

        {

            return new UnifiedSet<K>((UnifiedSet<K>) source);

        }

        if (source instanceof Collection)

        {

            return new UnifiedSet<K>((Collection<K>) source);

        }

        if (source == null)

        {

            throw new NullPointerException();

        }

        UnifiedSet<K> result = source instanceof RichIterable

                ? UnifiedSet.<K>newSet(((RichIterable<?>) source).size())

                : UnifiedSet.<K>newSet();

        Iterate.forEachWith(source, Procedures2.<K>addToCollection(), result);

        return result;

    }

    public static <K> UnifiedSet<K> newSet(int size, float loadFactor)

    {

        return new UnifiedSet<K>(size, loadFactor);

    }

    public static <K> UnifiedSet<K> newSetWith(K... elements)

    {

        return UnifiedSet.<K>newSet(elements.length).with(elements);

    }

    private int fastCeil(float v)

    {

        int possibleResult = (int) v;

        if (v - possibleResult > 0.0F)

        {

            possibleResult++;

        }

        return possibleResult;

    }

    protected int init(int initialCapacity)

    {

        int capacity = 1;

        while (capacity < initialCapacity)

        {

            capacity <<= 1;

        }

        return this.allocate(capacity);

    }

    protected int allocate(int capacity)

    {

        this.allocateTable(capacity);

        this.computeMaxSize(capacity);

        return capacity;

    }

    protected void allocateTable(int sizeToAllocate)

    {

        this.table = new Object[sizeToAllocate];

    }

    protected void computeMaxSize(int capacity)

    {

        // need at least one free slot for open addressing

        this.maxSize = Math.min(capacity - 1, (int) (capacity * this.loadFactor));

    }

    protected final int index(Object key)

    {

        // This function ensures that hashCodes that differ only by

        // constant multiples at each bit position have a bounded

        // number of collisions (approximately 8 at default load factor).

        int h = key == null ? 0 : key.hashCode();

        h ^= h >>> 20 ^ h >>> 12;

        h ^= h >>> 7 ^ h >>> 4;

        return h & this.table.length - 1;

    }

    public void clear()

    {

        if (this.occupied == 0)

        {

            return;

        }

        this.occupied = 0;

        Object[] set = this.table;

        for (int i = set.length; i-- > 0; )

        {

            set[i] = null;

        }

    }

    public boolean add(T key)

    {

        int index = this.index(key);

        Object cur = this.table[index];

        if (cur == null)

        {

            this.table[index] = toSentinelIfNull(key);

            if (++this.occupied > this.maxSize)

            {

                this.rehash();

            }

            return true;

        }

        if (cur instanceof ChainedBucket || !this.nonNullTableObjectEquals(cur, key))

        {

            return this.chainedAdd(key, index);

        }

        return false;

    }

    private boolean chainedAdd(T key, int index)

    {

        Object realKey = toSentinelIfNull(key);

        if (this.table[index] instanceof ChainedBucket)

        {

            ChainedBucket bucket = (ChainedBucket) this.table[index];

            do

            {

                if (this.nonNullTableObjectEquals(bucket.zero, key))

                {

                    return false;

                }

                if (bucket.one == null)

                {

                    bucket.one = realKey;

                    if (++this.occupied > this.maxSize)

                    {

                        this.rehash();

                    }

                    return true;

                }

                if (this.nonNullTableObjectEquals(bucket.one, key))

                {

                    return false;

                }

                if (bucket.two == null)

                {

                    bucket.two = realKey;

                    if (++this.occupied > this.maxSize)

                    {

                        this.rehash();

                    }

                    return true;

                }

                if (this.nonNullTableObjectEquals(bucket.two, key))

                {

                    return false;

                }

                if (bucket.three instanceof ChainedBucket)

                {

                    bucket = (ChainedBucket) bucket.three;

                    continue;

                }

                if (bucket.three == null)

                {

                    bucket.three = realKey;

                    if (++this.occupied > this.maxSize)

                    {

                        this.rehash();

                    }

                    return true;

                }

                if (this.nonNullTableObjectEquals(bucket.three, key))

                {

                    return false;

                }

                bucket.three = new ChainedBucket(bucket.three, realKey);

                if (++this.occupied > this.maxSize)

                {

                    this.rehash();

                }

                return true;

            }

            while (true);

        }

        ChainedBucket newBucket = new ChainedBucket(this.table[index], realKey);

        this.table[index] = newBucket;

        if (++this.occupied > this.maxSize)

        {

            this.rehash();

        }

        return true;

    }

    protected void rehash()

    {

        this.rehash(this.table.length << 1);

    }

    protected void rehash(int newCapacity)

    {

        int oldLength = this.table.length;

        Object[] old = this.table;

        this.allocate(newCapacity);

        this.occupied = 0;

        for (int i = 0; i < oldLength; i++)

        {

            Object oldKey = old[i];

            if (oldKey instanceof ChainedBucket)

            {

                ChainedBucket bucket = (ChainedBucket) oldKey;

                do

                {

                    if (bucket.zero != null)

                    {

                        this.add(this.nonSentinel(bucket.zero));

                    }

                    if (bucket.one == null)

                    {

                        break;

                    }

                    this.add(this.nonSentinel(bucket.one));

                    if (bucket.two == null)

                    {

                        break;

                    }

                    this.add(this.nonSentinel(bucket.two));

                    if (bucket.three != null)

                    {

                        if (bucket.three instanceof ChainedBucket)

                        {

                            bucket = (ChainedBucket) bucket.three;

                            continue;

                        }

                        this.add(this.nonSentinel(bucket.three));

                    }

                    break;

                }

                while (true);

            }

            else if (oldKey != null)

            {

                this.add(this.nonSentinel(oldKey));

            }

        }

    }

    public boolean contains(Object key)

    {

        int index = this.index(key);

        Object cur = this.table[index];

        if (cur == null)

        {

            return false;

        }

        if (cur instanceof ChainedBucket)

        {

            return this.chainContains((ChainedBucket) cur, (T) key);

        }

        return this.nonNullTableObjectEquals(cur, (T) key);

    }

    private boolean chainContains(ChainedBucket bucket, T key)

    {

        do

        {

            if (this.nonNullTableObjectEquals(bucket.zero, key))

            {

                return true;

            }

            if (bucket.one == null)

            {

                return false;

            }

            if (this.nonNullTableObjectEquals(bucket.one, key))

            {

                return true;

            }

            if (bucket.two == null)