All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • com.carrotsearch.hppcrt.sets.ObjectOpenIdentityHashSet Maven / Gradle / Ivy

    Go to download

    High Performance Primitive Collections Realtime (fork of HPPC of Carrotsearch) Fundamental data structures (maps, sets, lists, stacks, queues, heaps, sorts) generated for combinations of object and primitive types to conserve JVM memory and speed up execution. The Realtime fork intend of extending collections while tweaking and optimizations to remove any dynamic allocations at runtime, and low variance execution times.

    There is a newer version: 0.7.5
    Show newest version
    package com.carrotsearch.hppcrt.sets;

import com.carrotsearch.hppcrt.*;
import com.carrotsearch.hppcrt.cursors.*;
import com.carrotsearch.hppcrt.predicates.*;
import com.carrotsearch.hppcrt.procedures.*;
import com.carrotsearch.hppcrt.hash.*;

  
  
/**
 * An identity hash set of KType types, implemented using open
 * addressing with linear probing for collision resolution.
 *
 * The difference with {@link ObjectOpenHashSet} is that it uses direct Object reference equality for comparison and
 * direct "address" {@link System#identityHashCode(Object)} for hashCode(), instead of using
 * the built-in hashCode() /  equals().
 * 
    
 * The internal buffers of this implementation ({@link #keys}, etc...)
 * are always allocated to the nearest size that is a power of two. When
 * the capacity exceeds the given load factor, the buffer size is doubled.
 * 
    
 * 
 * 
    This implementation supports null keys.
    
 *
 * @author This code is inspired by the collaboration and implementation in the fastutil project.
 * 
 *
 */
 @javax.annotation.Generated(date = "2015-02-27T19:21:18+0100", value = "HPPC-RT generated from: ObjectOpenIdentityHashSet.java") 
public class ObjectOpenIdentityHashSet
        extends AbstractObjectCollection
        implements ObjectLookupContainer, ObjectSet, Cloneable
{
    /**
     * Minimum capacity for the map.
     */
    public final static int MIN_CAPACITY = HashContainerUtils.MIN_CAPACITY;

    /**
     * Default capacity.
     */
    public final static int DEFAULT_CAPACITY = HashContainerUtils.DEFAULT_CAPACITY;

    /**
     * Default load factor.
     */
    public final static float DEFAULT_LOAD_FACTOR = HashContainerUtils.DEFAULT_LOAD_FACTOR;

    /**
     * Hash-indexed array holding all set entries.
         * 
    Important!
     * The actual value in this field is always an instance of Object[].
     * Be warned that javac emits additional casts when keys
     * are directly accessed; these casts
     * may result in exceptions at runtime. A workaround is to cast directly to
     * Object[] before accessing the buffer's elements (although it is highly
     * recommended to use a {@link #iterator()} instead.
     *
    *

    * Direct set iteration: iterate {keys[i]} for i in [0; keys.length[ where keys[i] != null, then also * {null} is in the set if {@link #allocatedDefaultKey} = true. *

    *

    Direct iteration warning: * If the iteration goal is to fill another hash container, please iterate {@link #keys} in reverse to prevent performance losses. */ public KType[] keys; /** * True if key = null is in the map. */ public boolean allocatedDefaultKey = false; /** * Cached number of assigned slots in {@link #keys}. */ protected int assigned; /** * The load factor for this map (fraction of allocated slots * before the buffers must be rehashed or reallocated). */ protected float loadFactor; /** * Resize buffers when {@link #keys} hits this value. */ protected int resizeAt; /** * The most recent slot accessed in {@link #contains}. * * @see #contains * @see #lkey */ protected int lastSlot; /** * Creates a hash set with the default capacity of {@value #DEFAULT_CAPACITY}, * load factor of {@value #DEFAULT_LOAD_FACTOR}. */ public ObjectOpenIdentityHashSet() { this(ObjectOpenIdentityHashSet.DEFAULT_CAPACITY, ObjectOpenIdentityHashSet.DEFAULT_LOAD_FACTOR); } /** * Creates a hash set with the given capacity, * load factor of {@value #DEFAULT_LOAD_FACTOR}. */ public ObjectOpenIdentityHashSet(final int initialCapacity) { this(initialCapacity, ObjectOpenIdentityHashSet.DEFAULT_LOAD_FACTOR); } /** * Creates a hash set with the given capacity and load factor. */ public ObjectOpenIdentityHashSet(final int initialCapacity, final float loadFactor) { assert loadFactor > 0 && loadFactor <= 1 : "Load factor must be between (0, 1]."; this.loadFactor = loadFactor; //take into account of the load factor to garantee no reallocations before reaching initialCapacity. int internalCapacity = (int) (initialCapacity / loadFactor) + ObjectOpenIdentityHashSet.MIN_CAPACITY; //align on next power of two internalCapacity = HashContainerUtils.roundCapacity(internalCapacity); this.keys = (Internals.newArray(internalCapacity)); //Take advantage of the rounding so that the resize occur a bit later than expected. //allocate so that there is at least one slot that remains allocated = false //this is compulsory to guarantee proper stop in searching loops this.resizeAt = Math.max(3, (int) (internalCapacity * loadFactor)) - 2; } /** * Creates a hash set from elements of another container. Default load factor is used. */ public ObjectOpenIdentityHashSet(final ObjectContainer container) { this(container.size()); addAll(container); } /** * {@inheritDoc} */ @Override public boolean add(final KType e) { if (e == (null)) { if (this.allocatedDefaultKey) { return false; } this.allocatedDefaultKey = true; return true; } final int mask = this.keys.length - 1; final KType[] keys = this.keys; //copied straight from fastutil "fast-path" int slot; KType curr; //1.1 The rehashed key slot is occupied... if ((curr = keys[slot = PhiMix.hash(System.identityHashCode(e)) & mask]) != (null)) { //1.2 the occupied place is indeed key, return false if (curr == e) { return false; } //1.3 key is colliding, manage below : } else if (this.assigned < this.resizeAt) { //1.4 key is not colliding, without resize, so insert, return true. keys[slot] = e; this.assigned++; return true; } while ((keys[slot] != (null))) { if (e == keys[slot]) { return false; } slot = (slot + 1) & mask; } // Check if we need to grow. If so, reallocate new data, // fill in the last element and rehash. if (this.assigned == this.resizeAt) { expandAndAdd(e, slot); } else { this.assigned++; keys[slot] = e; } return true; } /** * Adds two elements to the set. */ public int add(final KType e1, final KType e2) { int count = 0; if (add(e1)) { count++; } if (add(e2)) { count++; } return count; } /** * Vararg-signature method for adding elements to this set. *

    This method is handy, but costly if used in tight loops (anonymous * array passing)

    * * @return Returns the number of elements that were added to the set * (were not present in the set). */ public int add(final KType... elements) { int count = 0; for (final KType e : elements) { if (add(e)) { count++; } } return count; } /** * Adds all elements from a given container to this set. * * @return Returns the number of elements actually added as a result of this * call (not previously present in the set). */ public int addAll(final ObjectContainer container) { return addAll((Iterable>) container); } /** * Adds all elements from a given iterable to this set. * * @return Returns the number of elements actually added as a result of this * call (not previously present in the set). */ public int addAll(final Iterable> iterable) { int count = 0; for (final ObjectCursor cursor : iterable) { if (add(cursor.value)) { count++; } } return count; } /** * Expand the internal storage buffers (capacity) or rehash current * keys and values if there are a lot of deleted slots. */ private void expandAndAdd(final KType pendingKey, final int freeSlot) { assert this.assigned == this.resizeAt; //default sentinel value is never in the keys[] array, so never trigger reallocs assert (pendingKey != (null)); // Try to allocate new buffers first. If we OOM, it'll be now without // leaving the data structure in an inconsistent state. final KType[] oldKeys = this.keys; allocateBuffers(HashContainerUtils.nextCapacity(this.keys.length)); // We have succeeded at allocating new data so insert the pending key/value at // the free slot in the old arrays before rehashing. this.lastSlot = -1; this.assigned++; oldKeys[freeSlot] = pendingKey; //Variables for adding final int mask = this.keys.length - 1; KType e = (null); //adding phase int slot = -1; final KType[] keys = this.keys; //iterate all the old arrays to add in the newly allocated buffers //It is important to iterate backwards to minimize the conflict chain length ! for (int i = oldKeys.length; --i >= 0;) { if ((oldKeys[i] != (null))) { e = oldKeys[i]; slot = PhiMix.hash(System.identityHashCode(e)) & mask; while ((keys[slot] != (null))) { slot = (slot + 1) & mask; } //end while keys[slot] = e; } } } /** * Allocate internal buffers for a given capacity. * * @param capacity New capacity (must be a power of two). */ private void allocateBuffers(final int capacity) { final KType[] keys = (Internals.newArray(capacity)); this.keys = keys; //allocate so that there is at least one slot that remains allocated = false //this is compulsory to guarantee proper stop in searching loops this.resizeAt = Math.max(3, (int) (capacity * this.loadFactor)) - 2; } /** * {@inheritDoc} */ @Override public int removeAllOccurrences(final KType key) { return remove(key) ? 1 : 0; } /** * An alias for the (preferred) {@link #removeAllOccurrences}. */ public boolean remove(final KType key) { if (key == (null)) { if (this.allocatedDefaultKey) { this.allocatedDefaultKey = false; return true; } return false; } final int mask = this.keys.length - 1; final KType[] keys = this.keys; //copied straight from fastutil "fast-path" int slot; KType curr; //1.1 The rehashed slot is free, nothing to remove, return false if ((curr = keys[slot = PhiMix.hash(System.identityHashCode(key)) & mask]) == (null)) { return false; } //1.2) The rehashed entry is occupied by the key, remove it, return true if (curr == key) { this.assigned--; shiftConflictingKeys(slot); return true; } //2. Hash collision, search for the key along the path slot = (slot + 1) & mask; while ((keys[slot] != (null))) { if (key == keys[slot]) { this.assigned--; shiftConflictingKeys(slot); return true; } slot = (slot + 1) & mask; } //end while true return false; } /** * Shift all the slot-conflicting keys allocated to (and including) slot. */ protected void shiftConflictingKeys(int slotCurr) { // Copied nearly verbatim from fastutil's impl. final int mask = this.keys.length - 1; int slotPrev, slotOther; final KType[] keys = this.keys; while (true) { slotCurr = ((slotPrev = slotCurr) + 1) & mask; while ((keys[slotCurr] != (null))) { slotOther = (PhiMix.hash(System.identityHashCode(keys[slotCurr])) & mask); if (slotPrev <= slotCurr) { // We are on the right of the original slot. if (slotPrev >= slotOther || slotOther > slotCurr) { break; } } else { // We have wrapped around. if (slotPrev >= slotOther && slotOther > slotCurr) { break; } } slotCurr = (slotCurr + 1) & mask; } if (!(keys[slotCurr] != (null))) { break; } // Shift key/allocated pair. keys[slotPrev] = keys[slotCurr]; } //means not allocated and for GC keys[slotPrev] = (null); } /** * Returns the last key saved in a call to {@link #contains} if it returned true. * Precondition : {@link #contains} must have been called previously ! * @see #contains */ public KType lkey() { if (this.lastSlot == -2) { return (null); } assert this.lastSlot >= 0 : "Call containsKey() first."; assert (this.keys[this.lastSlot] != (null)) : "Last call to exists did not have any associated value."; return this.keys[this.lastSlot]; } /** * @return Returns the slot of the last key looked up in a call to {@link #contains} if * it returned true. * or else -2 if {@link #contains} were succesfull on key = 0/null * @see #contains */ public int lslot() { assert this.lastSlot >= 0 || this.lastSlot == -2 : "Call contains() first."; return this.lastSlot; } /** * {@inheritDoc} * *

    Saves the associated value for fast access using {@link #lkey()}.

    * 
         * if (map.contains(key))
     *     value = map.lkey();
     * 
     *
    */ @Override public boolean contains(final KType key) { if (key == (null)) { if (this.allocatedDefaultKey) { this.lastSlot = -2; } else { this.lastSlot = -1; } return this.allocatedDefaultKey; } final int mask = this.keys.length - 1; final KType[] keys = this.keys; //copied straight from fastutil "fast-path" int slot; KType curr; //1.1 The rehashed slot is free, return false if ((curr = keys[slot = PhiMix.hash(System.identityHashCode(key)) & mask]) == (null)) { this.lastSlot = -1; return false; } //1.2) The rehashed entry is occupied by the key, return true if (curr == key) { this.lastSlot = slot; return true; } //2. Hash collision, search for the key along the path slot = (slot + 1) & mask; while ((keys[slot] != (null))) { if (key == keys[slot]) { this.lastSlot = slot; return true; } slot = (slot + 1) & mask; } //end while true //unsuccessful search this.lastSlot = -1; return false; } /** * {@inheritDoc} * *

    Does not release internal buffers.

    */ @Override public void clear() { this.assigned = 0; this.lastSlot = -1; // States are always cleared. this.allocatedDefaultKey = false; //Faster than Arrays.fill(keys, null); // Help the GC. ObjectArrays. blankArray(this.keys, 0, this.keys.length); } /** * {@inheritDoc} */ @Override public int size() { return this.assigned + (this.allocatedDefaultKey ? 1 : 0); } /** * {@inheritDoc} */ @Override public int capacity() { return this.resizeAt - 1; } /** * {@inheritDoc} */ @Override public int hashCode() { int h = 0; if (this.allocatedDefaultKey) { h += 0; } final KType[] keys = this.keys; for (int i = keys.length; --i >= 0;) { if ((keys[i] != (null))) { //This hash is an intrinsic property of the container contents h += PhiMix.hash(System.identityHashCode(keys[i])); } } return h; } /** * this instance and obj can only be equal if : 
         * (both are  ObjectOpenCustomHashSet)
     * and
     * (both have equal hash strategies defined by {@link #ObjectHashingStrategy}.equals(obj.hashStrategy))
    * then, both sets are compared as follows, using their {@link #ObjectHashingStrategy}. */ @SuppressWarnings("unchecked") @Override public boolean equals(final Object obj) { if (obj != null) { if (obj == this) { return true; } if (!(obj instanceof ObjectOpenIdentityHashSet)) { return false; } final ObjectOpenIdentityHashSet other = (ObjectOpenIdentityHashSet) obj; if (other.size() == this.size()) { final EntryIterator it = this.iterator(); while (it.hasNext()) { if (!other.contains(it.next().value)) { //recycle it.release(); return false; } } return true; } } return false; } /** * An iterator implementation for {@link #iterator}. */ public final class EntryIterator extends AbstractIterator> { public final ObjectCursor cursor; public EntryIterator() { this.cursor = new ObjectCursor(); this.cursor.index = -2; } /** * Iterate backwards w.r.t the buffer, to * minimize collision chains when filling another hash container (ex. with putAll()) */ @Override protected ObjectCursor fetch() { if (this.cursor.index == ObjectOpenIdentityHashSet.this.keys.length + 1) { if (ObjectOpenIdentityHashSet.this.allocatedDefaultKey) { this.cursor.index = ObjectOpenIdentityHashSet.this.keys.length; this.cursor.value = (null); return this.cursor; } //no value associated with the default key, continue iteration... this.cursor.index = ObjectOpenIdentityHashSet.this.keys.length; } int i = this.cursor.index - 1; while (i >= 0 && !(ObjectOpenIdentityHashSet.this.keys[i] != (null))) { i--; } if (i == -1) { return done(); } this.cursor.index = i; this.cursor.value = ObjectOpenIdentityHashSet.this.keys[i]; return this.cursor; } } /** * internal pool of EntryIterator */ protected final IteratorPool, EntryIterator> entryIteratorPool = new IteratorPool, EntryIterator>( new ObjectFactory() { @Override public EntryIterator create() { return new EntryIterator(); } @Override public void initialize(final EntryIterator obj) { obj.cursor.index = ObjectOpenIdentityHashSet.this.keys.length + 1; } @Override public void reset(final EntryIterator obj) { // nothing } }); /** * {@inheritDoc} * @return */ @Override public EntryIterator iterator() { //return new EntryIterator(); return this.entryIteratorPool.borrow(); } /** * {@inheritDoc} */ @Override public > T forEach(final T procedure) { if (this.allocatedDefaultKey) { procedure.apply((null)); } final KType[] keys = this.keys; //Iterate in reverse for side-stepping the longest conflict chain //in another hash, in case apply() is actually used to fill another hash container. for (int i = keys.length - 1; i >= 0; i--) { if ((keys[i] != (null))) { procedure.apply(keys[i]); } } return procedure; } /** * {@inheritDoc} */ @Override public KType[] toArray(final KType[] target) { int count = 0; if (this.allocatedDefaultKey) { target[count++] = (null); } final KType[] keys = this.keys; for (int i = 0; i < keys.length; i++) { if ((keys[i] != (null))) { target[count++] = keys[i]; } } assert count == this.size(); return target; } /** * Clone this object. * * It also realizes a trim-to- this.size() in the process. * */ @Override public ObjectOpenIdentityHashSet clone() { final ObjectOpenIdentityHashSet cloned = new ObjectOpenIdentityHashSet(this.size(), this.loadFactor); cloned.addAll(this); cloned.allocatedDefaultKey = this.allocatedDefaultKey; cloned.defaultValue = this.defaultValue; return cloned; } /** * {@inheritDoc} */ @Override public > T forEach(final T predicate) { if (this.allocatedDefaultKey) { if (!predicate.apply((null))) { return predicate; } } final KType[] keys = this.keys; //Iterate in reverse for side-stepping the longest conflict chain //in another hash, in case apply() is actually used to fill another hash container. for (int i = keys.length - 1; i >= 0; i--) { if ((keys[i] != (null))) { if (!predicate.apply(keys[i])) { break; } } } return predicate; } /** * {@inheritDoc} *

    Important! * If the predicate actually injects the removed keys in another hash container, you may experience performance losses. */ @Override public int removeAll(final ObjectPredicate predicate) { final int before = this.size(); if (this.allocatedDefaultKey) { if (predicate.apply((null))) { this.allocatedDefaultKey = false; } } final KType[] keys = this.keys; for (int i = 0; i < keys.length;) { if ((keys[i] != (null))) { if (predicate.apply(keys[i])) { this.assigned--; shiftConflictingKeys(i); // Repeat the check for the same i. continue; } } i++; } return before - this.size(); } /** * Create a set from a variable number of arguments or an array of KType. */ public static ObjectOpenIdentityHashSet from(final KType... elements) { final ObjectOpenIdentityHashSet set = new ObjectOpenIdentityHashSet(elements.length); set.add(elements); return set; } /** * Create a set from elements of another container. */ public static ObjectOpenIdentityHashSet from(final ObjectContainer container) { return new ObjectOpenIdentityHashSet(container); } /** * Create a new hash set with default parameters (shortcut * instead of using a constructor). */ public static ObjectOpenIdentityHashSet newInstance() { return new ObjectOpenIdentityHashSet(); } /** * Returns a new object of this class with no need to declare generic type (shortcut * instead of using a constructor). */ public static ObjectOpenIdentityHashSet newInstanceWithCapacity(final int initialCapacity, final float loadFactor) { return new ObjectOpenIdentityHashSet(initialCapacity, loadFactor); } //Test for existence in template }



    © 2015 - 2025 Weber Informatics LLC | Privacy Policy