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

*/

* This file was automatically generated from template file primitiveBooleanHashMap.stg.

*

* @since 3.0.

*/

    static final boolean EMPTY_VALUE = false;

    private static final long serialVersionUID = 1L;

    private static final int EMPTY_KEY = 0;

    private static final int REMOVED_KEY = 1;

    private static final float DEFAULT_LOAD_FACTOR = 0.5f;

    private static final int DEFAULT_INITIAL_CAPACITY = 8;

    private int occupied;

    private int maxSize;

    private int[] keys;

    private BitSet values;

    private float loadFactor = DEFAULT_LOAD_FACTOR;

    private SentinelValues sentinelValues;

    public IntBooleanHashMap()

    {

        this.allocate(DEFAULT_INITIAL_CAPACITY << 1);

    }

    public IntBooleanHashMap(int initialCapacity)

    {

        this(initialCapacity, DEFAULT_LOAD_FACTOR);

    }

    public IntBooleanHashMap(IntBooleanMap map)

    {

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

        this.putAll(map);

    }

    public IntBooleanHashMap(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 MutableIntBooleanMap asUnmodifiable()

    {

        return new UnmodifiableIntBooleanMap(this);

    }

    public MutableIntBooleanMap asSynchronized()

    {

        return new SynchronizedIntBooleanMap(this);

    }

    public ImmutableIntBooleanMap toImmutable()

    {

        return IntBooleanMaps.immutable.withAll(this);

    }

    public static IntBooleanHashMap newWithKeysValues(int key1, boolean value1)

    {

        return new IntBooleanHashMap(1).withKeyValue(key1, value1);

    }

    public static IntBooleanHashMap newWithKeysValues(int key1, boolean value1, int key2, boolean value2)

    {

        return new IntBooleanHashMap(2).withKeysValues(key1, value1, key2, value2);

    }

    public static IntBooleanHashMap newWithKeysValues(int key1, boolean value1, int key2, boolean value2, int key3, boolean value3)

    {

        return new IntBooleanHashMap(3).withKeysValues(key1, value1, key2, value2, key3, value3);

    }

    public static IntBooleanHashMap newWithKeysValues(int key1, boolean value1, int key2, boolean value2, int key3, boolean value3, int key4, boolean value4)

    {

        return new IntBooleanHashMap(4).withKeysValues(key1, value1, key2, value2, key3, value3, key4, value4);

    }

    public IntBooleanHashMap withKeyValue(int key1, boolean value1)

    {

        this.put(key1, value1);

        return this;

    }

    public IntBooleanHashMap withKeysValues(int key1, boolean value1, int key2, boolean value2)

    {

        this.put(key1, value1);

        this.put(key2, value2);

        return this;

    }

    public IntBooleanHashMap withKeysValues(int key1, boolean value1, int key2, boolean value2, int key3, boolean value3)

    {

        this.put(key1, value1);

        this.put(key2, value2);

        this.put(key3, value3);

        return this;

    }

    public IntBooleanHashMap withKeysValues(int key1, boolean value1, int key2, boolean value2, int key3, boolean value3, int key4, boolean value4)

    {

        this.put(key1, value1);

        this.put(key2, value2);

        this.put(key3, value3);

        this.put(key4, value4);

        return this;

    }

    public IntBooleanHashMap withoutKey(int key)

    {

        this.removeKey(key);

        return this;

    }

    public IntBooleanHashMap withoutAllKeys(IntIterable keys)

    {

        keys.forEach(new IntProcedure()

        {

            public void value(int key)

            {

                IntBooleanHashMap.this.removeKey(key);

            }

        });

        return this;

    }

    private int init(int initialCapacity)

    {

        int capacity = 1;

        while (capacity < initialCapacity)

        {

            capacity <<= 1;

        }

        return this.allocate(capacity);

    }

    private int fastCeil(float v)

    {

        int possibleResult = (int) v;

        if (v - possibleResult > 0.0F)

        {

            possibleResult++;

        }

        return possibleResult;

    }

    private static boolean isEmptyKey(int key)

    {

        return key == EMPTY_KEY;

    }

    private static boolean isRemovedKey(int key)

    {

        return key == REMOVED_KEY;

    }

    private static boolean isNonSentinel(int key)

    {

        return !isEmptyKey(key) && !isRemovedKey(key);

    }

    private int allocate(int capacity)

    {

        this.allocateTable(capacity);

        this.computeMaxSize(capacity);

        return capacity;

    }

    private void allocateTable(int sizeToAllocate)

    {

        this.keys = new int[sizeToAllocate];

        this.values = new BitSet(sizeToAllocate);

    }

    private void computeMaxSize(int capacity)

    {

        // need at least one free slot for open addressing

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

    }

    public int size()

    {

        return this.occupied + (this.sentinelValues == null ? 0 : this.sentinelValues.size());

    }

    public boolean isEmpty()

    {

        return this.occupied == 0 && (this.sentinelValues == null || this.sentinelValues.size() == 0);

    }

    public boolean notEmpty()

    {

        return this.occupied != 0 || (this.sentinelValues != null && this.sentinelValues.size() != 0);

    }

    private void rehash()

    {

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

    }

    private void rehash(int newCapacity)

    {

        int oldLength = this.keys.length;

        int[] old = this.keys;

        BitSet oldValues = this.values;

        this.allocate(newCapacity);

        this.occupied = 0;

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

        {

            if (isNonSentinel(old[i]))

            {

                this.put(old[i], oldValues.get(i));

            }

        }

    }

    // exposed for testing

    int probe(int element)

    {

        int index = this.spread(element);

        int keyAtIndex = this.keys[index];

        if (keyAtIndex == element || keyAtIndex == EMPTY_KEY)

        {

            return index;

        }

        int removedIndex = keyAtIndex == REMOVED_KEY ? index : -1;

        int nextIndex = index;

        int probe = 17;

        // loop until an empty slot is reached

        while (true)

        {

            // Probe algorithm: 17*n*(n+1)/2 where n = number of collisions

            nextIndex += probe;

            probe += 17;

            nextIndex &= this.keys.length - 1;

            if (this.keys[nextIndex] == element)

            {

                return nextIndex;

            }

            if (this.keys[nextIndex] == REMOVED_KEY)

            {

                if (removedIndex == -1)

                {

                    removedIndex = nextIndex;

                }

            }

            else if (this.keys[nextIndex] == EMPTY_KEY)

            {

                return removedIndex == -1 ? nextIndex : removedIndex;

            }

        }

    }

    // exposed for testing

    int spread(int element)

    {

        int code = element;

        code ^= 61 ^ (code >> 16);

        code += code << 3;

        code ^= code >> 4;

        code *= 0x27d4eb2d;

        code ^= code >> 15;

        return code & (this.keys.length - 1);

    }

    public void clear()

    {

        this.sentinelValues = null;

        this.occupied = 0;

        Arrays.fill(this.keys, EMPTY_KEY);

        this.values.clear();

    }

    public void put(int key, boolean value)

    {

        if (isEmptyKey(key))

        {

            if (this.sentinelValues == null)

            {

                this.sentinelValues = new SentinelValues();

            }

            this.sentinelValues.containsZeroKey = true;

            this.sentinelValues.zeroValue = value;

            return;

        }

        if (isRemovedKey(key))

        {

            if (this.sentinelValues == null)

            {

                this.sentinelValues = new SentinelValues();

            }

            this.sentinelValues.containsOneKey = true;

            this.sentinelValues.oneValue = value;

            return;

        }

        int index = this.probe(key);