@Test public void containsValuesAddedFromIntersectingSet() { addTwoElements(testSet); final ObjectHashSet<Integer> intersecting = new ObjectHashSet<>(100); intersecting.add(1); intersecting.add(1002); assertTrue(testSet.addAll(intersecting)); assertTrue(testSet.contains(1)); assertTrue(testSet.contains(1001)); assertTrue(testSet.containsAll(intersecting)); }
@Test public void chainCompactionShouldNotCauseElementsToBeMovedBeforeTheirHash() { final ObjectHashSet<String> requiredFields = new ObjectHashSet<>(14); requiredFields.add("8"); requiredFields.add("9"); requiredFields.add("35"); requiredFields.add("49"); requiredFields.add("56"); assertTrue("Failed to remove 8", requiredFields.remove("8")); assertTrue("Failed to remove 9", requiredFields.remove("9")); assertThat(requiredFields, containsInAnyOrder("35", "49", "56")); }
/** * Fast Path set difference for comparison with another ObjectHashSet. * <p> * NB: garbage free in the identical case, allocates otherwise. * * @param other the other set to subtract * @return null if identical, otherwise the set of differences */ public ObjectHashSet<T> difference(final ObjectHashSet<T> other) { ObjectHashSet<T> difference = null; for (final T value : values) { if (value != MISSING_VALUE && !other.contains(value)) { if (difference == null) { difference = new ObjectHashSet<>(size); } difference.add(value); } } return difference; }
/** * Compact the backing arrays by rehashing with a capacity just larger than current size * and giving consideration to the load factor. */ public void compact() { final int idealCapacity = (int)Math.round(size() * (1.0 / loadFactor)); rehash(findNextPositivePowerOfTwo(Math.max(DEFAULT_INITIAL_CAPACITY, idealCapacity))); }
return otherSet.size == size && containsAll(otherSet); if (c.size() != size()) return containsAll(c);
@Test public void doesNotContainDisjointSet() { addTwoElements(testSet); final ObjectHashSet<String> other = new ObjectHashSet<>(100); other.add("1"); other.add("1002"); assertFalse(testSet.containsAll(other)); }
@Test public void doesNotContainRemovedIntersectingSet() { addTwoElements(testSet); final ObjectHashSet<Integer> intersecting = new ObjectHashSet<>(100); intersecting.add(1); intersecting.add(1002); assertTrue(testSet.removeAll(intersecting)); assertTrue(testSet.contains(1001)); assertFalse(testSet.containsAll(intersecting)); }
public Set<String> create(final Object... elements) { final ObjectHashSet<String> set = new ObjectHashSet<>( elements.length * 2, Hashing.DEFAULT_LOAD_FACTOR, false); for (final Object o : elements) { set.add((String)o); } return set; }
public DirectBuffer getVariablesAsDocument(long scopeKey, Collection<DirectBuffer> names) { variablesToCollect.clear(); variablesToCollect.addAll(names); writer.wrap(documentResultBuffer, 0); writer.reserveMapHeader(); visitVariables( scopeKey, name -> variablesToCollect.contains(name.getBuffer()), (name, value) -> { writer.writeString(name.getBuffer()); writer.writeRaw(value.getValue()); variablesToCollect.remove(name.getBuffer()); }, () -> variablesToCollect.isEmpty()); writer.writeReservedMapHeader(0, names.size() - variablesToCollect.size()); resultView.wrap(documentResultBuffer, 0, writer.getOffset()); return resultView; }
public DirectBuffer getVariablesAsDocument(long scopeKey) { collectedVariables.clear(); writer.wrap(documentResultBuffer, 0); writer.reserveMapHeader(); visitVariables( scopeKey, name -> !collectedVariables.contains(name.getBuffer()), (name, value) -> { final DirectBuffer variableNameBuffer = name.getBuffer(); writer.writeString(variableNameBuffer); writer.writeRaw(value.getValue()); // must create a new name wrapper, because we keep them all in the hashset at the same // time final MutableDirectBuffer nameView = new UnsafeBuffer(variableNameBuffer); collectedVariables.add(nameView); }, () -> false); writer.writeReservedMapHeader(0, collectedVariables.size()); resultView.wrap(documentResultBuffer, 0, writer.getOffset()); return resultView; }
@Test public void addingSubsetDoesNothing() { addTwoElements(testSet); final ObjectHashSet<Integer> subset = new ObjectHashSet<>(100); subset.add(1); assertFalse(testSet.addAll(subset)); assertContainsElements(testSet); }
@Test public void differenceReturnsSetDifference() { addTwoElements(testSet); final ObjectHashSet<String> other = new ObjectHashSet<>(100); other.add("1"); final ObjectHashSet<String> diff = testSet.difference(other); assertThat(diff, containsInAnyOrder("1001")); }
@Test public void removingDisjointSetDoesNothing() { addTwoElements(testSet); final ObjectHashSet<Integer> disjoint = new ObjectHashSet<>(100); disjoint.add(2); disjoint.add(1002); assertFalse(testSet.removeAll(disjoint)); assertContainsElements(testSet); }
@Test public void containsEmptySet() { final ObjectHashSet<Integer> other = new ObjectHashSet<>(100); assertTrue(testSet.containsAll(other)); }
@Parameters public static ObjectHashSet[] data() { return new ObjectHashSet[] { new ObjectHashSet<String>(INITIAL_CAPACITY), new ObjectHashSet<String>(INITIAL_CAPACITY, Hashing.DEFAULT_LOAD_FACTOR, false)}; }