How to use

LongLinkedOpenHashSet

in

it.unimi.dsi.fastutil.longs

public synchronized void add(long uid) {
 if (elems.size() == capacity) {
  elems.remove(elems.firstLong());
 }
 elems.add(uid);
}

public RecentlyAddedUids(int capacity) {
 this.capacity = capacity;
 elems = new LongLinkedOpenHashSet(capacity);
}

protected synchronized void clear() {
 elems.clear();
}

@Override
public boolean addAll(Collection<? extends Long> c) {
  // The resulting collection will be at least c.size() big
  if (f <= .5)
    ensureCapacity(c.size()); // The resulting collection will be sized for c.size() elements
  else
    tryCapacity(size() + c.size()); // The resulting collection will be tentatively sized for size() + c.size()
                    // elements
  return super.addAll(c);
}
@Override

LongLinkedOpenHashSet s0 = new LongLinkedOpenHashSet();
LongLinkedOpenHashSet s1 = new LongLinkedOpenHashSet();
LongAVLTreeSet s2 = new LongAVLTreeSet();
LongBidirectionalIterator it;
        s0.clear();
        s1.clear();
        s0.retainAll( s1 );
        indexIterator =  termLists ? indexReader[ i ].documents( terms[ i ].get( t ) ) : indexReader[ i ].documents( t );
        additionalIterator = termLists ? additionalReader.documents( terms[ i ].get( u ) ) : additionalReader.documents( u );
        it = s0.iterator();
        documentIterator = AndDocumentIterator.getInstance( indexIterator, additionalIterator );
        for( int j = s0.size(); j-- != 0; ) if ( it.nextLong() != documentIterator.nextDocument() ) throw new AssertionError();

/**
 * Creates a new hash set and fills it with the elements of a given array.
 *
 * @param a
 *            an array whose elements will be used to fill the set.
 * @param offset
 *            the first element to use.
 * @param length
 *            the number of elements to use.
 * @param f
 *            the load factor.
 */
public LongLinkedOpenHashSet(final long[] a, final int offset, final int length, final float f) {
  this(length < 0 ? 0 : length, f);
  LongArrays.ensureOffsetLength(a, offset, length);
  for (int i = 0; i < length; i++)
    add(a[offset + i]);
}
/**

private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException {
  final LongIterator i = iterator();
  s.defaultWriteObject();
  for (int j = size; j-- != 0;)
    s.writeLong(i.nextLong());
}

/**
 * Creates a new hash set copying a given collection.
 *
 * @param c
 *            a {@link Collection} to be copied into the new hash set.
 * @param f
 *            the load factor.
 */
public LongLinkedOpenHashSet(final Collection<? extends Long> c, final float f) {
  this(c.size(), f);
  addAll(c);
}
/**

@Override
protected void trainInternal(List<Item> items, List<ClickData> clickData) {
  //whenever a click occurs, remove the id of the article that has been clicked
  //from the result list and push it to the front 
  for (ClickData c : clickData) {
    clickedItems.addAndMoveToFirst(c.click.item.id);
  }
}

public synchronized int markRecentAsFoundInBitSet(long[] uids, BitSet found, int bitSetLength) {
 if (found.length() == 0) {
  return 0;
 }
 int ret = 0;
 int index = 0;
 while (true) {
  if (index < 0 || index >= bitSetLength) {
   break;
  }
  index = found.nextClearBit(index);
  if (index < 0 || index >= bitSetLength) {
   break;
  }
  if (elems.contains(uids[index])) {
   found.set(index);
   ret++;
  } else {
  }
  index++;
 }
 return ret;
}

@Override
public boolean addAll(LongCollection c) {
  if (f <= .5)
    ensureCapacity(c.size()); // The resulting collection will be sized for c.size() elements
  else
    tryCapacity(size() + c.size()); // The resulting collection will be tentatively sized for size() + c.size()
                    // elements
  return super.addAll(c);
}
@Override

/**
 * Creates a new hash set using elements provided by a type-specific iterator.
 *
 * @param i
 *            a type-specific iterator whose elements will fill the set.
 * @param f
 *            the load factor.
 */
public LongLinkedOpenHashSet(final LongIterator i, final float f) {
  this(DEFAULT_INITIAL_SIZE, f);
  while (i.hasNext())
    add(i.nextLong());
}
/**

/**
 * Creates a new hash set copying a given type-specific collection.
 *
 * @param c
 *            a type-specific collection to be copied into the new hash set.
 * @param f
 *            the load factor.
 */
public LongLinkedOpenHashSet(final LongCollection c, final float f) {
  this(c.size(), f);
  addAll(c);
}
/**