/*
 * Copyright (c) 2020 Goldman Sachs and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * and Eclipse Distribution License v. 1.0 which accompany this distribution.
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 */

package org.eclipse.collections.impl.map.mutable.primitive;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Iterator;
import java.util.NoSuchElementException;

import org.eclipse.collections.api.BooleanIterable;
import org.eclipse.collections.api.DoubleIterable;
import org.eclipse.collections.api.LazyDoubleIterable;
import org.eclipse.collections.api.RichIterable;
import org.eclipse.collections.api.bag.primitive.MutableDoubleBag;
import org.eclipse.collections.api.block.function.primitive.BooleanFunction;
import org.eclipse.collections.api.block.function.primitive.BooleanFunction0;
import org.eclipse.collections.api.block.function.primitive.BooleanToBooleanFunction;
import org.eclipse.collections.api.block.function.primitive.DoubleBooleanToBooleanFunction;
import org.eclipse.collections.api.block.function.primitive.DoubleToBooleanFunction;
import org.eclipse.collections.api.block.function.primitive.ObjectDoubleToObjectFunction;
import org.eclipse.collections.api.block.predicate.primitive.DoubleBooleanPredicate;
import org.eclipse.collections.api.block.predicate.primitive.DoublePredicate;
import org.eclipse.collections.api.block.procedure.Procedure;
import org.eclipse.collections.api.block.procedure.Procedure2;
import org.eclipse.collections.api.block.procedure.primitive.DoubleBooleanProcedure;
import org.eclipse.collections.api.block.procedure.primitive.DoubleProcedure;
import org.eclipse.collections.api.block.procedure.primitive.ObjectIntProcedure;
import org.eclipse.collections.api.collection.primitive.MutableBooleanCollection;
import org.eclipse.collections.api.iterator.DoubleIterator;
import org.eclipse.collections.api.iterator.MutableBooleanIterator;
import org.eclipse.collections.api.iterator.MutableDoubleIterator;
import org.eclipse.collections.api.list.primitive.MutableDoubleList;
import org.eclipse.collections.api.map.primitive.DoubleBooleanMap;
import org.eclipse.collections.api.map.primitive.ImmutableDoubleBooleanMap;
import org.eclipse.collections.api.map.primitive.MutableDoubleBooleanMap;
import org.eclipse.collections.api.set.primitive.BooleanSet;
import org.eclipse.collections.api.set.primitive.DoubleSet;
import org.eclipse.collections.api.set.primitive.MutableDoubleSet;
import org.eclipse.collections.api.tuple.primitive.DoubleBooleanPair;
import org.eclipse.collections.impl.SpreadFunctions;
import org.eclipse.collections.impl.bag.mutable.primitive.DoubleHashBag;
import org.eclipse.collections.impl.factory.primitive.DoubleBooleanMaps;
import org.eclipse.collections.impl.iterator.UnmodifiableDoubleIterator;
import org.eclipse.collections.impl.lazy.AbstractLazyIterable;
import org.eclipse.collections.impl.lazy.primitive.AbstractLazyDoubleIterable;
import org.eclipse.collections.impl.list.mutable.primitive.DoubleArrayList;
import org.eclipse.collections.impl.set.mutable.primitive.DoubleHashSet;
import org.eclipse.collections.impl.tuple.primitive.PrimitiveTuples;

This file was automatically generated from template file primitiveBooleanHashMap.stg.
Since:3.0.
/** * This file was automatically generated from template file primitiveBooleanHashMap.stg. * * @since 3.0. */
public class DoubleBooleanHashMap extends AbstractMutableBooleanValuesMap implements MutableDoubleBooleanMap, MutableDoubleKeysMap, Externalizable { static final boolean EMPTY_VALUE = false; private static final long serialVersionUID = 1L; private static final double EMPTY_KEY = 0.0; private static final double REMOVED_KEY = 1.0;
Deprecated:in 5.1.0.
/** * @deprecated in 5.1.0. */
@Deprecated private static final float DEFAULT_LOAD_FACTOR = 0.5f; private static final int OCCUPIED_DATA_RATIO = 2; private static final int OCCUPIED_SENTINEL_RATIO = 4; private static final int DEFAULT_INITIAL_CAPACITY = 8; private static final int CACHE_LINE_SIZE = 64; private static final int KEY_SIZE = 8; private static final int INITIAL_LINEAR_PROBE = CACHE_LINE_SIZE / KEY_SIZE / 2; /* half a cache line */ private double[] keys; private BitSet values; private int occupiedWithData; private int occupiedWithSentinels; private SentinelValues sentinelValues; public DoubleBooleanHashMap() { this.allocateTable(DEFAULT_INITIAL_CAPACITY << 1); } public DoubleBooleanHashMap(int initialCapacity) { if (initialCapacity < 0) { throw new IllegalArgumentException("initial capacity cannot be less than 0"); } int capacity = this.smallestPowerOfTwoGreaterThan(this.fastCeil(initialCapacity * OCCUPIED_DATA_RATIO)); this.allocateTable(capacity); } public DoubleBooleanHashMap(DoubleBooleanMap map) { this(Math.max(map.size(), DEFAULT_INITIAL_CAPACITY)); this.putAll(map); }
Deprecated:in 5.1.0.
/** * @deprecated in 5.1.0. */
@Deprecated public DoubleBooleanHashMap(int initialCapacity, float loadFactor) { this(initialCapacity); } @Override protected int getOccupiedWithData() { return this.occupiedWithData; } @Override protected SentinelValues getSentinelValues() { return this.sentinelValues; } @Override protected void setSentinelValuesNull() { this.sentinelValues = null; } @Override protected boolean getEmptyValue() { return EMPTY_VALUE; } @Override protected int getTableSize() { return this.keys.length; } @Override protected boolean getValueAtIndex(int index) { return this.values.get(index); } @Override protected boolean isNonSentinelAtIndex(int index) { return !isEmptyKey(this.keys[index]) && !isRemovedKey(this.keys[index]); } private int smallestPowerOfTwoGreaterThan(int n) { return n > 1 ? Integer.highestOneBit(n - 1) << 1 : 1; } @Override public MutableDoubleBooleanMap asUnmodifiable() { return new UnmodifiableDoubleBooleanMap(this); } @Override public MutableDoubleBooleanMap asSynchronized() { return new SynchronizedDoubleBooleanMap(this); } @Override public ImmutableDoubleBooleanMap toImmutable() { return DoubleBooleanMaps.immutable.withAll(this); } public static DoubleBooleanHashMap newWithKeysValues(double key1, boolean value1) { return new DoubleBooleanHashMap(1).withKeyValue(key1, value1); } public static DoubleBooleanHashMap newWithKeysValues(double key1, boolean value1, double key2, boolean value2) { return new DoubleBooleanHashMap(2).withKeysValues(key1, value1, key2, value2); } public static DoubleBooleanHashMap newWithKeysValues(double key1, boolean value1, double key2, boolean value2, double key3, boolean value3) { return new DoubleBooleanHashMap(3).withKeysValues(key1, value1, key2, value2, key3, value3); } public static DoubleBooleanHashMap newWithKeysValues(double key1, boolean value1, double key2, boolean value2, double key3, boolean value3, double key4, boolean value4) { return new DoubleBooleanHashMap(4).withKeysValues(key1, value1, key2, value2, key3, value3, key4, value4); } @Override public DoubleBooleanHashMap withKeyValue(double key1, boolean value1) { this.put(key1, value1); return this; } public DoubleBooleanHashMap withKeysValues(double key1, boolean value1, double key2, boolean value2) { this.put(key1, value1); this.put(key2, value2); return this; } public DoubleBooleanHashMap withKeysValues(double key1, boolean value1, double key2, boolean value2, double key3, boolean value3) { this.put(key1, value1); this.put(key2, value2); this.put(key3, value3); return this; } public DoubleBooleanHashMap withKeysValues(double key1, boolean value1, double key2, boolean value2, double key3, boolean value3, double key4, boolean value4) { this.put(key1, value1); this.put(key2, value2); this.put(key3, value3); this.put(key4, value4); return this; } @Override public DoubleBooleanHashMap withoutKey(double key) { this.removeKey(key); return this; } @Override public DoubleBooleanHashMap withoutAllKeys(DoubleIterable keys) { keys.forEach(this::removeKey); return this; } private int fastCeil(float v) { int possibleResult = (int) v; if (v - possibleResult > 0.0F) { possibleResult++; } return possibleResult; } private static boolean isEmptyKey(double key) { return Double.compare(key, EMPTY_KEY) == 0; } private static boolean isRemovedKey(double key) { return Double.compare(key, REMOVED_KEY) == 0; } private static boolean isNonSentinel(double key) { return !isEmptyKey(key) && !isRemovedKey(key); } protected void allocateTable(int sizeToAllocate) { this.keys = new double[sizeToAllocate]; this.values = new BitSet(sizeToAllocate); }
Rehashes every element in the set into a new backing table of the smallest possible size and eliminating removed sentinels.
/** * Rehashes every element in the set into a new backing table of the smallest possible size and eliminating removed sentinels. */
public void compact() { this.rehash(this.smallestPowerOfTwoGreaterThan(this.size())); } private void rehash() { this.rehash(this.keys.length); } private void rehashAndGrow() { this.rehash(this.keys.length << 1); } private void rehash(int newCapacity) { int oldLength = this.keys.length; double[] old = this.keys; BitSet oldValues = this.values; this.allocateTable(newCapacity); this.occupiedWithData = 0; this.occupiedWithSentinels = 0; for (int i = 0; i < oldLength; i++) { if (isNonSentinel(old[i])) { this.put(old[i], oldValues.get(i)); } } } // exposed for testing int probe(double element) { int index = this.spreadAndMask(element); double keyAtIndex = this.keys[index]; if (Double.compare(keyAtIndex, element) == 0 || Double.compare(keyAtIndex, EMPTY_KEY) == 0) { return index; } int removedIndex = Double.compare(keyAtIndex, REMOVED_KEY) == 0 ? index : -1; for (int i = 1; i < INITIAL_LINEAR_PROBE; i++) { int nextIndex = (index + i) & (this.keys.length - 1); keyAtIndex = this.keys[nextIndex]; if (Double.compare(keyAtIndex, element) == 0) { return nextIndex; } if (Double.compare(keyAtIndex, EMPTY_KEY) == 0) { return removedIndex == -1 ? nextIndex : removedIndex; } if (Double.compare(keyAtIndex, REMOVED_KEY) == 0 && removedIndex == -1) { removedIndex = nextIndex; } } return this.probeTwo(element, removedIndex); } int probeTwo(double element, int removedIndex) { int index = this.spreadTwoAndMask(element); for (int i = 0; i < INITIAL_LINEAR_PROBE; i++) { int nextIndex = (index + i) & (this.keys.length - 1); double keyAtIndex = this.keys[nextIndex]; if (Double.compare(keyAtIndex, element) == 0) { return nextIndex; } if (Double.compare(keyAtIndex, EMPTY_KEY) == 0) { return removedIndex == -1 ? nextIndex : removedIndex; } if (Double.compare(keyAtIndex, REMOVED_KEY) == 0 && removedIndex == -1) { removedIndex = nextIndex; } } return this.probeThree(element, removedIndex); } int probeThree(double element, int removedIndex) { int nextIndex = (int) Long.reverse(SpreadFunctions.doubleSpreadOne(element)); int spreadTwo = (int) Long.reverse(SpreadFunctions.doubleSpreadTwo(element)) | 1; while (true) { nextIndex = this.mask(nextIndex + spreadTwo); double keyAtIndex = this.keys[nextIndex]; if (Double.compare(keyAtIndex, element) == 0) { return nextIndex; } if (Double.compare(keyAtIndex, EMPTY_KEY) == 0) { return removedIndex == -1 ? nextIndex : removedIndex; } if (Double.compare(keyAtIndex, REMOVED_KEY) == 0 && removedIndex == -1) { removedIndex = nextIndex; } } } // exposed for testing int spreadAndMask(double element) { long code = SpreadFunctions.doubleSpreadOne(element); return this.mask((int) code); } int spreadTwoAndMask(double element) { long code = SpreadFunctions.doubleSpreadTwo(element); return this.mask((int) code); } private int mask(int spread) { return spread & (this.keys.length - 1); } @Override public void clear() { this.sentinelValues = null; this.occupiedWithData = 0; this.occupiedWithSentinels = 0; Arrays.fill(this.keys, EMPTY_KEY); this.values.clear(); } @Override public void put(double key, boolean value) { if (isEmptyKey(key)) { if (this.getSentinelValues() == null) { this.sentinelValues = new SentinelValues(); } this.getSentinelValues().containsZeroKey = true; this.getSentinelValues().zeroValue = value; return; } if (isRemovedKey(key)) { if (this.sentinelValues == null) { this.sentinelValues = new SentinelValues(); } this.getSentinelValues().containsOneKey = true; this.getSentinelValues().oneValue = value; return; } int index = this.probe(key); if (Double.compare(this.keys[index], key) == 0) { // key already present in map this.values.set(index, value); return; } this.addKeyValueAtIndex(key, value, index); } @Override public void putAll(DoubleBooleanMap map) { map.forEachKeyValue(this::put); } @Override public void updateValues(DoubleBooleanToBooleanFunction function) { if (this.sentinelValues != null) { if (this.getSentinelValues().containsZeroKey) { this.getSentinelValues().zeroValue = function.valueOf(EMPTY_KEY, this.getSentinelValues().zeroValue); } if (this.getSentinelValues().containsOneKey) { this.getSentinelValues().oneValue = function.valueOf(REMOVED_KEY, this.getSentinelValues().oneValue); } } for (int i = 0; i < this.keys.length; i++) { if (isNonSentinel(this.keys[i])) { this.values.set(i, function.valueOf(this.keys[i], this.getValueAtIndex(i))); } } } @Override public boolean containsKey(double key) { if (isEmptyKey(key)) { return this.getSentinelValues() != null && this.getSentinelValues().containsZeroKey; } if (isRemovedKey(key)) { return this.getSentinelValues() != null && this.getSentinelValues().containsOneKey; } return Double.compare(this.keys[this.probe(key)], key) == 0; } @Override public boolean containsValue(boolean value) { if (this.getSentinelValues() != null && this.getSentinelValues().containsValue(value)) { return true; } for (int i = 0; i < this.keys.length; i++) { if (isNonSentinel(this.keys[i]) && this.getValueAtIndex(i) == value) { return true; } } return false; } @Override public boolean get(double key) { return this.getIfAbsent(key, this.getEmptyValue()); } @Override public boolean getIfAbsent(double key, boolean ifAbsent) { if (isEmptyKey(key)) { if (this.sentinelValues == null || !this.getSentinelValues().containsZeroKey) { return ifAbsent; } return this.getSentinelValues().zeroValue; } if (isRemovedKey(key)) { if (this.sentinelValues == null || !this.getSentinelValues().containsOneKey) { return ifAbsent; } return this.getSentinelValues().oneValue; } int index = this.probe(key); if (this.isNonSentinelAtIndex(index)) { return this.values.get(index); } return ifAbsent; } @Override public boolean getOrThrow(double key) { if (isEmptyKey(key)) { if (this.sentinelValues == null || !this.getSentinelValues().containsZeroKey) { throw new IllegalStateException("Key " + key + " not present."); } return this.getSentinelValues().zeroValue; } if (isRemovedKey(key)) { if (this.sentinelValues == null || !this.getSentinelValues().containsOneKey) { throw new IllegalStateException("Key " + key + " not present."); } return this.getSentinelValues().oneValue; } int index = this.probe(key); if (this.isNonSentinelAtIndex(index)) { return this.values.get(index); } throw new IllegalStateException("Key " + key + " not present."); } @Override public boolean getIfAbsentPut(double key, boolean value) { if (isEmptyKey(key)) { if (this.sentinelValues == null) { this.sentinelValues = new SentinelValues(); this.addEmptyKeyValue(value); return value; } if (this.getSentinelValues().containsZeroKey) { return this.getSentinelValues().zeroValue; } this.addEmptyKeyValue(value); return value; } if (isRemovedKey(key)) { if (this.sentinelValues == null) { this.sentinelValues = new SentinelValues(); this.addRemovedKeyValue(value); return value; } if (this.getSentinelValues().containsOneKey) { return this.getSentinelValues().oneValue; } this.addRemovedKeyValue(value); return value; } int index = this.probe(key); if (Double.compare(this.keys[index], key) == 0) { return this.values.get(index); } this.addKeyValueAtIndex(key, value, index); return value; } @Override public boolean getIfAbsentPut(double key, BooleanFunction0 function) { if (isEmptyKey(key)) { if (this.sentinelValues == null) { boolean value = function.value(); this.sentinelValues = new SentinelValues(); this.addEmptyKeyValue(value); return value; } if (this.getSentinelValues().containsZeroKey) { return this.getSentinelValues().zeroValue; } boolean value = function.value(); this.addEmptyKeyValue(value); return value; } if (isRemovedKey(key)) { if (this.sentinelValues == null) { boolean value = function.value(); this.sentinelValues = new SentinelValues(); this.addRemovedKeyValue(value); return value; } if (this.getSentinelValues().containsOneKey) { return this.getSentinelValues().oneValue; } boolean value = function.value(); this.addRemovedKeyValue(value); return value; } int index = this.probe(key); if (Double.compare(this.keys[index], key) == 0) { return this.values.get(index); } boolean value = function.value(); this.addKeyValueAtIndex(key, value, index); return value; } @Override public <P> boolean getIfAbsentPutWith(double key, BooleanFunction<? super P> function, P parameter) { if (isEmptyKey(key)) { if (this.sentinelValues == null) { boolean value = function.booleanValueOf(parameter); this.sentinelValues = new SentinelValues(); this.addEmptyKeyValue(value); return value; } if (this.getSentinelValues().containsZeroKey) { return this.getSentinelValues().zeroValue; } boolean value = function.booleanValueOf(parameter); this.addEmptyKeyValue(value); return value; } if (isRemovedKey(key)) { if (this.sentinelValues == null) { boolean value = function.booleanValueOf(parameter); this.sentinelValues = new SentinelValues(); this.addRemovedKeyValue(value); return value; } if (this.getSentinelValues().containsOneKey) { return this.getSentinelValues().oneValue; } boolean value = function.booleanValueOf(parameter); this.addRemovedKeyValue(value); return value; } int index = this.probe(key); if (Double.compare(this.keys[index], key) == 0) { return this.values.get(index); } boolean value = function.booleanValueOf(parameter); this.addKeyValueAtIndex(key, value, index); return value; } @Override public boolean getIfAbsentPutWithKey(double key, DoubleToBooleanFunction function) { if (isEmptyKey(key)) { if (this.sentinelValues == null) { boolean value = function.valueOf(key); this.sentinelValues = new SentinelValues(); this.addEmptyKeyValue(value); return value; } if (this.getSentinelValues().containsZeroKey) { return this.getSentinelValues().zeroValue; } boolean value = function.valueOf(key); this.addEmptyKeyValue(value); return value; } if (isRemovedKey(key)) { if (this.sentinelValues == null) { boolean value = function.valueOf(key); this.sentinelValues = new SentinelValues(); this.addRemovedKeyValue(value); return value; } if (this.getSentinelValues().containsOneKey) { return this.getSentinelValues().oneValue; } boolean value = function.valueOf(key); this.addRemovedKeyValue(value); return value; } int index = this.probe(key); if (Double.compare(this.keys[index], key) == 0) { return this.values.get(index); } boolean value = function.valueOf(key); this.addKeyValueAtIndex(key, value, index); return value; } @Override public boolean updateValue(double key, boolean initialValueIfAbsent, BooleanToBooleanFunction function) { if (isEmptyKey(key)) { if (this.sentinelValues == null) { this.sentinelValues = new SentinelValues(); this.addEmptyKeyValue(function.valueOf(initialValueIfAbsent)); } else if (this.getSentinelValues().containsZeroKey) { this.getSentinelValues().zeroValue = function.valueOf(this.getSentinelValues().zeroValue); } else { this.addEmptyKeyValue(function.valueOf(initialValueIfAbsent)); } return this.getSentinelValues().zeroValue; } if (isRemovedKey(key)) { if (this.sentinelValues == null) { this.sentinelValues = new SentinelValues(); this.addRemovedKeyValue(function.valueOf(initialValueIfAbsent)); } else if (this.getSentinelValues().containsOneKey) { this.getSentinelValues().oneValue = function.valueOf(this.getSentinelValues().oneValue); } else { this.addRemovedKeyValue(function.valueOf(initialValueIfAbsent)); } return this.getSentinelValues().oneValue; } int index = this.probe(key); if (Double.compare(this.keys[index], key) == 0) { this.values.set(index, function.valueOf(this.values.get(index))); return this.values.get(index); } boolean value = function.valueOf(initialValueIfAbsent); this.addKeyValueAtIndex(key, value, index); return value; } private void addKeyValueAtIndex(double key, boolean value, int index) { if (Double.compare(this.keys[index], REMOVED_KEY) == 0) { this.occupiedWithSentinels--; } this.keys[index] = key; this.values.set(index, value); this.occupiedWithData++; if (this.occupiedWithData > this.maxOccupiedWithData()) { this.rehashAndGrow(); } } @Override public void removeKey(double key) { if (isEmptyKey(key)) { if (this.sentinelValues == null || !this.getSentinelValues().containsZeroKey) { return; } this.removeEmptyKey(); return; } if (isRemovedKey(key)) { if (this.sentinelValues == null || !this.getSentinelValues().containsOneKey) { return; } this.removeRemovedKey(); return; } int index = this.probe(key); if (Double.compare(this.keys[index], key) == 0) { this.keys[index] = REMOVED_KEY; this.values.set(index, this.getEmptyValue()); this.occupiedWithData--; this.occupiedWithSentinels++; if (this.occupiedWithSentinels > this.maxOccupiedWithSentinels()) { this.rehash(); } } } @Override public void remove(double key) { this.removeKey(key); } @Override public boolean removeKeyIfAbsent(double key, boolean value) { if (isEmptyKey(key)) { if (this.sentinelValues == null || !this.getSentinelValues().containsZeroKey) { return value; } boolean oldValue = this.getSentinelValues().zeroValue; this.removeEmptyKey(); return oldValue; } if (isRemovedKey(key)) { if (this.sentinelValues == null || !this.getSentinelValues().containsOneKey) { return value; } boolean oldValue = this.getSentinelValues().oneValue; this.removeRemovedKey(); return oldValue; } int index = this.probe(key); if (Double.compare(this.keys[index], key) == 0) { this.keys[index] = REMOVED_KEY; boolean oldValue = this.values.get(index); this.values.set(index, this.getEmptyValue()); this.occupiedWithData--; this.occupiedWithSentinels++; if (this.occupiedWithSentinels > this.maxOccupiedWithSentinels()) { this.rehash(); } return oldValue; } return value; } @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (!(obj instanceof DoubleBooleanMap)) { return false; } DoubleBooleanMap other = (DoubleBooleanMap) obj; if (this.size() != other.size()) { return false; } if (this.sentinelValues == null) { if (other.containsKey(EMPTY_KEY) || other.containsKey(REMOVED_KEY)) { return false; } } else { if (this.getSentinelValues().containsZeroKey && (!other.containsKey(EMPTY_KEY) || this.getSentinelValues().zeroValue != other.getOrThrow(EMPTY_KEY))) { return false; } if (this.getSentinelValues().containsOneKey && (!other.containsKey(REMOVED_KEY) || this.getSentinelValues().oneValue != other.getOrThrow(REMOVED_KEY))) { return false; } } for (int i = 0; i < this.keys.length; i++) { if (this.isNonSentinelAtIndex(i) && (!other.containsKey(this.keys[i]) || this.getValueAtIndex(i) != other.getOrThrow(this.keys[i]))) { return false; } } return true; } @Override public int hashCode() { int result = 0; if (this.sentinelValues != null) { if (this.getSentinelValues().containsZeroKey) { result += (int) (Double.doubleToLongBits(EMPTY_KEY) ^ Double.doubleToLongBits(EMPTY_KEY) >>> 32) ^ (this.getSentinelValues().zeroValue ? 1231 : 1237); } if (this.getSentinelValues().containsOneKey) { result += (int) (Double.doubleToLongBits(REMOVED_KEY) ^ Double.doubleToLongBits(REMOVED_KEY) >>> 32) ^ (this.getSentinelValues().oneValue ? 1231 : 1237); } } for (int i = 0; i < this.keys.length; i++) { if (isNonSentinel(this.keys[i])) { result += (int) (Double.doubleToLongBits(this.keys[i]) ^ Double.doubleToLongBits(this.keys[i]) >>> 32) ^ (this.getValueAtIndex(i) ? 1231 : 1237); } } return result; } @Override public String toString() { StringBuilder appendable = new StringBuilder(); appendable.append("{"); boolean first = true; if (this.sentinelValues != null) { if (this.getSentinelValues().containsZeroKey) { appendable.append(EMPTY_KEY).append("=").append(this.getSentinelValues().zeroValue); first = false; } if (this.getSentinelValues().containsOneKey) { if (!first) { appendable.append(", "); } appendable.append(REMOVED_KEY).append("=").append(this.getSentinelValues().oneValue); first = false; } } for (int i = 0; i < this.keys.length; i++) { if (this.isNonSentinelAtIndex(i)) { if (!first) { appendable.append(", "); } appendable.append(this.keys[i]).append("=").append(this.getValueAtIndex(i)); first = false; } } appendable.append("}"); return appendable.toString(); } @Override public MutableBooleanIterator booleanIterator() { return new InternalBooleanIterator(); } @Override public void forEachKey(DoubleProcedure procedure) { if (this.sentinelValues != null) { if (this.getSentinelValues().containsZeroKey) { procedure.value(EMPTY_KEY); } if (this.getSentinelValues().containsOneKey) { procedure.value(REMOVED_KEY); } } for (double key : this.keys) { if (isNonSentinel(key)) { procedure.value(key); } } } @Override public void forEachKeyValue(DoubleBooleanProcedure procedure) { if (this.sentinelValues != null) { if (this.getSentinelValues().containsZeroKey) { procedure.value(EMPTY_KEY, this.getSentinelValues().zeroValue); } if (this.getSentinelValues().containsOneKey) { procedure.value(REMOVED_KEY, this.getSentinelValues().oneValue); } } for (int i = 0; i < this.keys.length; i++) { if (isNonSentinel(this.keys[i])) { procedure.value(this.keys[i], this.getValueAtIndex(i)); } } } @Override public DoubleBooleanHashMap select(DoubleBooleanPredicate predicate) { DoubleBooleanHashMap result = new DoubleBooleanHashMap(); if (this.sentinelValues != null) { if (this.getSentinelValues().containsZeroKey && predicate.accept(EMPTY_KEY, this.getSentinelValues().zeroValue)) { result.put(EMPTY_KEY, this.getSentinelValues().zeroValue); } if (this.getSentinelValues().containsOneKey && predicate.accept(REMOVED_KEY, this.getSentinelValues().oneValue)) { result.put(REMOVED_KEY, this.getSentinelValues().oneValue); } } for (int i = 0; i < this.keys.length; i++) { if (isNonSentinel(this.keys[i]) && predicate.accept(this.keys[i], this.getValueAtIndex(i))) { result.put(this.keys[i], this.getValueAtIndex(i)); } } return result; } @Override public DoubleBooleanHashMap reject(DoubleBooleanPredicate predicate) { DoubleBooleanHashMap result = new DoubleBooleanHashMap(); if (this.sentinelValues != null) { if (this.getSentinelValues().containsZeroKey && !predicate.accept(EMPTY_KEY, this.getSentinelValues().zeroValue)) { result.put(EMPTY_KEY, this.getSentinelValues().zeroValue); } if (this.getSentinelValues().containsOneKey && !predicate.accept(REMOVED_KEY, this.getSentinelValues().oneValue)) { result.put(REMOVED_KEY, this.getSentinelValues().oneValue); } } for (int i = 0; i < this.keys.length; i++) { if (isNonSentinel(this.keys[i]) && !predicate.accept(this.keys[i], this.getValueAtIndex(i))) { result.put(this.keys[i], this.getValueAtIndex(i)); } } return result; } @Override public LazyDoubleIterable keysView() { return new KeysView(); } @Override public RichIterable<DoubleBooleanPair> keyValuesView() { return new KeyValuesView(); } @Override public void writeExternal(ObjectOutput out) throws IOException { out.writeInt(this.size()); /** * @deprecated in 5.1.0. */ out.writeFloat(DEFAULT_LOAD_FACTOR); if (this.sentinelValues != null) { if (this.getSentinelValues().containsZeroKey) { out.writeDouble(EMPTY_KEY); out.writeBoolean(this.getSentinelValues().zeroValue); } if (this.getSentinelValues().containsOneKey) { out.writeDouble(REMOVED_KEY); out.writeBoolean(this.getSentinelValues().oneValue); } } for (int i = 0; i < this.keys.length; i++) { if (isNonSentinel(this.keys[i])) { out.writeDouble(this.keys[i]); out.writeBoolean(this.getValueAtIndex(i)); } } } @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { int size = in.readInt(); /** * @deprecated in 5.1.0. */ in.readFloat(); for (int i = 0; i < size; i++) { this.put(in.readDouble(), in.readBoolean()); } } private int maxOccupiedWithData() { int capacity = this.keys.length; // need at least one free slot for open addressing return Math.min(capacity - 1, capacity / OCCUPIED_DATA_RATIO); } private int maxOccupiedWithSentinels() { return this.keys.length / OCCUPIED_SENTINEL_RATIO; } private class InternalBooleanIterator implements MutableBooleanIterator { private int count; private int position; private double lastKey; private boolean handledZero; private boolean handledOne; private boolean canRemove; @Override public boolean hasNext() { return this.count < DoubleBooleanHashMap.this.size(); } @Override public boolean next() { if (!this.hasNext()) { throw new NoSuchElementException("next() called, but the iterator is exhausted"); } this.count++; this.canRemove = true; if (!this.handledZero) { this.handledZero = true; if (DoubleBooleanHashMap.this.containsKey(EMPTY_KEY)) { this.lastKey = EMPTY_KEY; return DoubleBooleanHashMap.this.getSentinelValues().zeroValue; } } if (!this.handledOne) { this.handledOne = true; if (DoubleBooleanHashMap.this.containsKey(REMOVED_KEY)) { this.lastKey = REMOVED_KEY; return DoubleBooleanHashMap.this.getSentinelValues().oneValue; } } double[] keys = DoubleBooleanHashMap.this.keys; while (!isNonSentinel(keys[this.position])) { this.position++; } this.lastKey = keys[this.position]; boolean result = DoubleBooleanHashMap.this.values.get(this.position); this.position++; return result; } @Override public void remove() { if (!this.canRemove) { throw new IllegalStateException(); } DoubleBooleanHashMap.this.removeKey(this.lastKey); this.count--; this.canRemove = false; } } private class KeysView extends AbstractLazyDoubleIterable { @Override public boolean isEmpty() { return DoubleBooleanHashMap.this.isEmpty(); } @Override public boolean notEmpty() { return DoubleBooleanHashMap.this.notEmpty(); } @Override public int size() { return DoubleBooleanHashMap.this.size(); } @Override public boolean contains(double key) { return DoubleBooleanHashMap.this.containsKey(key); } @Override public boolean containsAll(double... keys) { for (double key : keys) { if (!DoubleBooleanHashMap.this.containsKey(key)) { return false; } } return true; } @Override public boolean containsAll(DoubleIterable source) { return source.allSatisfy(DoubleBooleanHashMap.this::containsKey); } @Override public DoubleIterator doubleIterator() { return new UnmodifiableDoubleIterator(new KeySetIterator()); }
Since:7.0.
/** * @since 7.0. */
@Override public void each(DoubleProcedure procedure) { DoubleBooleanHashMap.this.forEachKey(procedure); } @Override public void appendString(Appendable appendable, String start, String separator, String end) { try { appendable.append(start); boolean first = true; if (DoubleBooleanHashMap.this.sentinelValues != null) { if (DoubleBooleanHashMap.this.getSentinelValues().containsZeroKey) { appendable.append(String.valueOf(EMPTY_KEY)); first = false; } if (DoubleBooleanHashMap.this.getSentinelValues().containsOneKey) { if (!first) { appendable.append(separator); } appendable.append(String.valueOf(REMOVED_KEY)); first = false; } } for (double key : DoubleBooleanHashMap.this.keys) { if (isNonSentinel(key)) { if (!first) { appendable.append(separator); } appendable.append(String.valueOf(key)); first = false; } } appendable.append(end); } catch (IOException e) { throw new RuntimeException(e); } } @Override public int count(DoublePredicate predicate) { int count = 0; if (DoubleBooleanHashMap.this.sentinelValues != null) { if (DoubleBooleanHashMap.this.getSentinelValues().containsZeroKey && predicate.accept(EMPTY_KEY)) { count++; } if (DoubleBooleanHashMap.this.getSentinelValues().containsOneKey && predicate.accept(REMOVED_KEY)) { count++; } } for (double key : DoubleBooleanHashMap.this.keys) { if (isNonSentinel(key) && predicate.accept(key)) { count++; } } return count; } @Override public boolean anySatisfy(DoublePredicate predicate) { if (DoubleBooleanHashMap.this.sentinelValues != null) { if (DoubleBooleanHashMap.this.getSentinelValues().containsZeroKey && predicate.accept(EMPTY_KEY)) { return true; } if (DoubleBooleanHashMap.this.getSentinelValues().containsOneKey && predicate.accept(REMOVED_KEY)) { return true; } } for (double key : DoubleBooleanHashMap.this.keys) { if (isNonSentinel(key) && predicate.accept(key)) { return true; } } return false; } @Override public boolean allSatisfy(DoublePredicate predicate) { if (DoubleBooleanHashMap.this.sentinelValues != null) { if (DoubleBooleanHashMap.this.getSentinelValues().containsZeroKey && !predicate.accept(EMPTY_KEY)) { return false; } if (DoubleBooleanHashMap.this.getSentinelValues().containsOneKey && !predicate.accept(REMOVED_KEY)) { return false; } } for (double key : DoubleBooleanHashMap.this.keys) { if (isNonSentinel(key) && !predicate.accept(key)) { return false; } } return true; } @Override public boolean noneSatisfy(DoublePredicate predicate) { return !this.anySatisfy(predicate); } @Override public double detectIfNone(DoublePredicate predicate, double value) { if (DoubleBooleanHashMap.this.sentinelValues != null) { if (DoubleBooleanHashMap.this.getSentinelValues().containsZeroKey && predicate.accept(EMPTY_KEY)) { return EMPTY_KEY; } if (DoubleBooleanHashMap.this.getSentinelValues().containsOneKey && predicate.accept(REMOVED_KEY)) { return REMOVED_KEY; } } for (double key : DoubleBooleanHashMap.this.keys) { if (isNonSentinel(key) && predicate.accept(key)) { return key; } } return value; } @Override public double sum() { double result = 0.0; if (DoubleBooleanHashMap.this.sentinelValues != null) { if (DoubleBooleanHashMap.this.getSentinelValues().containsZeroKey) { result += EMPTY_KEY; } if (DoubleBooleanHashMap.this.getSentinelValues().containsOneKey) { result += REMOVED_KEY; } } for (double key : DoubleBooleanHashMap.this.keys) { if (isNonSentinel(key)) { result += key; } } return result; } @Override public double max() { if (this.isEmpty()) { throw new NoSuchElementException(); } DoubleIterator iterator = this.doubleIterator(); double max = iterator.next(); while (iterator.hasNext()) { double value = iterator.next(); if (Double.compare(max, value) < 0) { max = value; } } return max; } @Override public double min() { if (this.isEmpty()) { throw new NoSuchElementException(); } DoubleIterator iterator = this.doubleIterator(); double min = iterator.next(); while (iterator.hasNext()) { double value = iterator.next(); if (Double.compare(value, min) < 0) { min = value; } } return min; } @Override public double[] toSortedArray() { double[] array = this.toArray(); Arrays.sort(array); return array; } @Override public double[] toArray() { int size = DoubleBooleanHashMap.this.size(); final double[] result = new double[size]; DoubleBooleanHashMap.this.forEachKey(new DoubleProcedure() { private int index; @Override public void value(double each) { result[this.index] = each; this.index++; } }); return result; } @Override public <T> T injectInto(T injectedValue, ObjectDoubleToObjectFunction<? super T, ? extends T> function) { T result = injectedValue; if (DoubleBooleanHashMap.this.sentinelValues != null) { if (DoubleBooleanHashMap.this.getSentinelValues().containsZeroKey) { result = function.valueOf(result, EMPTY_KEY); } if (DoubleBooleanHashMap.this.getSentinelValues().containsOneKey) { result = function.valueOf(result, REMOVED_KEY); } } for (int i = 0; i < DoubleBooleanHashMap.this.keys.length; i++) { if (isNonSentinel(DoubleBooleanHashMap.this.keys[i])) { result = function.valueOf(result, DoubleBooleanHashMap.this.keys[i]); } } return result; } @Override public MutableDoubleList toList() { return DoubleArrayList.newList(this); } @Override public MutableDoubleSet toSet() { return DoubleHashSet.newSet(this); } @Override public MutableDoubleBag toBag() { return DoubleHashBag.newBag(this); } } @Override public MutableDoubleSet keySet() { return new KeySet(); } private class KeySet extends AbstractMutableDoubleKeySet { @Override protected double getKeyAtIndex(int index) { return DoubleBooleanHashMap.this.keys[index]; } @Override protected int getTableSize() { return DoubleBooleanHashMap.this.keys.length; } @Override protected MutableDoubleKeysMap getOuter() { return DoubleBooleanHashMap.this; } @Override protected SentinelValues getSentinelValues() { return DoubleBooleanHashMap.this.sentinelValues; } @Override public MutableDoubleIterator doubleIterator() { return new KeySetIterator(); } @Override public boolean retainAll(DoubleIterable source) { int oldSize = DoubleBooleanHashMap.this.size(); final DoubleSet sourceSet = source instanceof DoubleSet ? (DoubleSet) source : source.toSet(); DoubleBooleanHashMap retained = DoubleBooleanHashMap.this.select((double key, boolean value) -> sourceSet.contains(key)); if (retained.size() != oldSize) { DoubleBooleanHashMap.this.keys = retained.keys; DoubleBooleanHashMap.this.values = retained.values; DoubleBooleanHashMap.this.occupiedWithData = retained.occupiedWithData; DoubleBooleanHashMap.this.occupiedWithSentinels = retained.occupiedWithSentinels; DoubleBooleanHashMap.this.sentinelValues = retained.sentinelValues; return true; } return false; } @Override public boolean retainAll(double... source) { return this.retainAll(DoubleHashSet.newSetWith(source)); } @Override public DoubleSet freeze() { throw new UnsupportedOperationException(this.getClass().getSimpleName() + ".freeze() not implemented yet"); }
Since:9.2.
/** * @since 9.2. */
@Override public MutableDoubleSet newEmpty() { return new DoubleHashSet(); } } @Override public MutableBooleanCollection values() { return new ValuesCollection(); } private class ValuesCollection extends AbstractBooleanValuesCollection { @Override public void appendString(Appendable appendable, String start, String separator, String end) { try { appendable.append(start); boolean first = true; if (DoubleBooleanHashMap.this.sentinelValues != null) { if (DoubleBooleanHashMap.this.getSentinelValues().containsZeroKey) { appendable.append(String.valueOf(DoubleBooleanHashMap.this.getSentinelValues().zeroValue)); first = false; } if (DoubleBooleanHashMap.this.getSentinelValues().containsOneKey) { if (!first) { appendable.append(separator); } appendable.append(String.valueOf(DoubleBooleanHashMap.this.getSentinelValues().oneValue)); first = false; } } for (int i = 0; i < DoubleBooleanHashMap.this.keys.length; i++) { if (DoubleBooleanHashMap.this.isNonSentinelAtIndex(i)) { if (!first) { appendable.append(separator); } appendable.append(String.valueOf(DoubleBooleanHashMap.this.getValueAtIndex(i))); first = false; } } appendable.append(end); } catch (IOException e) { throw new RuntimeException(e); } } @Override public MutableBooleanIterator booleanIterator() { return DoubleBooleanHashMap.this.booleanIterator(); } @Override public boolean remove(boolean item) { int oldSize = DoubleBooleanHashMap.this.size(); if (DoubleBooleanHashMap.this.sentinelValues != null) { if (DoubleBooleanHashMap.this.getSentinelValues().containsZeroKey && item == DoubleBooleanHashMap.this.getSentinelValues().zeroValue) { DoubleBooleanHashMap.this.removeKey(EMPTY_KEY); } if (DoubleBooleanHashMap.this.getSentinelValues().containsOneKey && item == DoubleBooleanHashMap.this.getSentinelValues().oneValue) { DoubleBooleanHashMap.this.removeKey(REMOVED_KEY); } } for (int i = 0; i < DoubleBooleanHashMap.this.keys.length; i++) { if (isNonSentinel(DoubleBooleanHashMap.this.keys[i]) && item == DoubleBooleanHashMap.this.getValueAtIndex(i)) { DoubleBooleanHashMap.this.removeKey(DoubleBooleanHashMap.this.keys[i]); } } return oldSize != DoubleBooleanHashMap.this.size(); } @Override public boolean retainAll(BooleanIterable source) { int oldSize = DoubleBooleanHashMap.this.size(); final BooleanSet sourceSet = source instanceof BooleanSet ? (BooleanSet) source : source.toSet(); DoubleBooleanHashMap retained = DoubleBooleanHashMap.this.select((double key, boolean value) -> sourceSet.contains(value)); if (retained.size() != oldSize) { DoubleBooleanHashMap.this.keys = retained.keys; DoubleBooleanHashMap.this.values = retained.values; DoubleBooleanHashMap.this.occupiedWithData = retained.occupiedWithData; DoubleBooleanHashMap.this.occupiedWithSentinels = retained.occupiedWithSentinels; DoubleBooleanHashMap.this.sentinelValues = retained.sentinelValues; return true; } return false; } } private class KeySetIterator implements MutableDoubleIterator { private int count; private int position; private double lastKey; private boolean handledZero; private boolean handledOne; private boolean removed = true; @Override public boolean hasNext() { return this.count < DoubleBooleanHashMap.this.size(); } @Override public double next() { if (!this.hasNext()) { throw new NoSuchElementException("next() called, but the iterator is exhausted"); } this.count++; this.removed = false; if (!this.handledZero) { this.handledZero = true; if (DoubleBooleanHashMap.this.containsKey(EMPTY_KEY)) { this.lastKey = EMPTY_KEY; return this.lastKey; } } if (!this.handledOne) { this.handledOne = true; if (DoubleBooleanHashMap.this.containsKey(REMOVED_KEY)) { this.lastKey = REMOVED_KEY; return this.lastKey; } } double[] keys = DoubleBooleanHashMap.this.keys; while (!isNonSentinel(keys[this.position])) { this.position++; } this.lastKey = keys[this.position]; this.position++; return this.lastKey; } @Override public void remove() { if (this.removed) { throw new IllegalStateException(); } DoubleBooleanHashMap.this.removeKey(this.lastKey); this.count--; this.removed = true; } } private class KeyValuesView extends AbstractLazyIterable<DoubleBooleanPair> { @Override public void each(Procedure<? super DoubleBooleanPair> procedure) { if (DoubleBooleanHashMap.this.sentinelValues != null) { if (DoubleBooleanHashMap.this.getSentinelValues().containsZeroKey) { procedure.value(PrimitiveTuples.pair(EMPTY_KEY, DoubleBooleanHashMap.this.getSentinelValues().zeroValue)); } if (DoubleBooleanHashMap.this.getSentinelValues().containsOneKey) { procedure.value(PrimitiveTuples.pair(REMOVED_KEY, DoubleBooleanHashMap.this.getSentinelValues().oneValue)); } } for (int i = 0; i < DoubleBooleanHashMap.this.keys.length; i++) { if (isNonSentinel(DoubleBooleanHashMap.this.keys[i])) { procedure.value(PrimitiveTuples.pair(DoubleBooleanHashMap.this.keys[i], DoubleBooleanHashMap.this.getValueAtIndex(i))); } } } @Override public void forEachWithIndex(ObjectIntProcedure<? super DoubleBooleanPair> objectIntProcedure) { int index = 0; if (DoubleBooleanHashMap.this.sentinelValues != null) { if (DoubleBooleanHashMap.this.getSentinelValues().containsZeroKey) { objectIntProcedure.value(PrimitiveTuples.pair(EMPTY_KEY, DoubleBooleanHashMap.this.getSentinelValues().zeroValue), index); index++; } if (DoubleBooleanHashMap.this.getSentinelValues().containsOneKey) { objectIntProcedure.value(PrimitiveTuples.pair(REMOVED_KEY, DoubleBooleanHashMap.this.getSentinelValues().oneValue), index); index++; } } for (int i = 0; i < DoubleBooleanHashMap.this.keys.length; i++) { if (isNonSentinel(DoubleBooleanHashMap.this.keys[i])) { objectIntProcedure.value(PrimitiveTuples.pair(DoubleBooleanHashMap.this.keys[i], DoubleBooleanHashMap.this.getValueAtIndex(i)), index); index++; } } } @Override public <P> void forEachWith(Procedure2<? super DoubleBooleanPair, ? super P> procedure, P parameter) { if (DoubleBooleanHashMap.this.sentinelValues != null) { if (DoubleBooleanHashMap.this.getSentinelValues().containsZeroKey) { procedure.value(PrimitiveTuples.pair(EMPTY_KEY, DoubleBooleanHashMap.this.getSentinelValues().zeroValue), parameter); } if (DoubleBooleanHashMap.this.getSentinelValues().containsOneKey) { procedure.value(PrimitiveTuples.pair(REMOVED_KEY, DoubleBooleanHashMap.this.getSentinelValues().oneValue), parameter); } } for (int i = 0; i < DoubleBooleanHashMap.this.keys.length; i++) { if (isNonSentinel(DoubleBooleanHashMap.this.keys[i])) { procedure.value(PrimitiveTuples.pair(DoubleBooleanHashMap.this.keys[i], DoubleBooleanHashMap.this.getValueAtIndex(i)), parameter); } } } @Override public Iterator<DoubleBooleanPair> iterator() { return new InternalKeyValuesIterator(); } public class InternalKeyValuesIterator implements Iterator<DoubleBooleanPair> { private int count; private int position; private boolean handledZero; private boolean handledOne; @Override public DoubleBooleanPair next() { if (!this.hasNext()) { throw new NoSuchElementException("next() called, but the iterator is exhausted"); } this.count++; if (!this.handledZero) { this.handledZero = true; if (DoubleBooleanHashMap.this.containsKey(EMPTY_KEY)) { return PrimitiveTuples.pair(EMPTY_KEY, DoubleBooleanHashMap.this.getSentinelValues().zeroValue); } } if (!this.handledOne) { this.handledOne = true; if (DoubleBooleanHashMap.this.containsKey(REMOVED_KEY)) { return PrimitiveTuples.pair(REMOVED_KEY, DoubleBooleanHashMap.this.getSentinelValues().oneValue); } } double[] keys = DoubleBooleanHashMap.this.keys; while (!isNonSentinel(keys[this.position])) { this.position++; } DoubleBooleanPair result = PrimitiveTuples.pair(keys[this.position], DoubleBooleanHashMap.this.values.get(this.position)); this.position++; return result; } @Override public void remove() { throw new UnsupportedOperationException("Cannot call remove() on " + this.getClass().getSimpleName()); } @Override public boolean hasNext() { return this.count != DoubleBooleanHashMap.this.size(); } } } }