@Override public void xor(Filter filter) { if(filter == null || !(filter instanceof BloomFilter) || filter.vectorSize != this.vectorSize || filter.nbHash != this.nbHash) { throw new IllegalArgumentException("filters cannot be xor-ed"); } bits.xor(((BloomFilter) filter).bits); }
/** * Bitwise XOR together two BitSets. Called when the '^' operator is used * between two bit sets. * * @param left a BitSet * @param right another BitSet to bitwise AND * @return the bitwise XOR of both BitSets * @since 1.5.0 */ public static BitSet xor(BitSet left, BitSet right) { BitSet result = (BitSet) left.clone(); result.xor(right); return result; }
ms[j].xor(temp); bxor.get(i).add(j, ms[j]);
public BitIntegerSet xor(BitIntegerSet set) {myBits.xor(set.myBits); return this;} public BitIntegerSet andNot(BitIntegerSet set) {myBits.andNot(set.myBits); return this;}
public BitIntegerSet xor(BitSet set) {myBits.xor(set); return this;} public BitIntegerSet andNot(BitSet set) {myBits.andNot(set); return this;}
@Override public void xor(final Filter filter) { if (filter == null || !(filter instanceof BloomFilter) || filter.vectorSize != this.vectorSize || filter.nbHash != this.nbHash) { throw new IllegalArgumentException("filters cannot be xor-ed"); } bits.xor(((BloomFilter) filter).bits); }
@Override public void xor(Filter filter) { BloomFilter bfilter = (BloomFilter) filter; if (filter == null || !(filter instanceof BloomFilter) || bfilter.vectorSize != this.vectorSize || bfilter.nbHash != this.nbHash) { throw new IllegalArgumentException("filters cannot be xor-ed"); } bits.xor(((BloomFilter) filter).bits); }
@Override public boolean containsAll(Collection<?> collection) { if (collection instanceof BitIntegerSet) { BitSet other = ((BitIntegerSet) collection).myBits; BitSet bitSet = (BitSet) this.myBits.clone(); bitSet.xor(other); bitSet.and(other); return bitSet.isEmpty(); } for (Object o : collection) { if (!contains(o)) return false; } return true; }
@Override public boolean addAll(Collection<? extends Integer> collection) { if (collection instanceof BitIntegerSet) { BitSet other = ((BitIntegerSet) collection).myBits; BitSet bitSet = (BitSet) this.myBits.clone(); myBits.or(other); bitSet.xor(bitSet); return !bitSet.isEmpty(); } boolean changed = false; for (Object o : collection) { if (add((Integer) o)) changed = true; } return changed; }
@Override public boolean retainAll(Collection<?> collection) { BitSet other; if (!(collection instanceof BitSet)) { other = new BitSet(); for (Object o : collection) { if (contains(o)) { other.set((Integer) o); } } } else { other = (BitSet) collection; } BitSet bitSet = (BitSet) this.myBits.clone(); myBits.and(other); bitSet.xor(bitSet); return !bitSet.isEmpty(); }
@Override public boolean removeAll(Collection<?> collection) { if (collection instanceof BitIntegerSet) { BitSet other = ((BitIntegerSet) collection).myBits; BitSet bitSet = (BitSet) this.myBits.clone(); myBits.andNot(other); bitSet.xor(bitSet); return !bitSet.isEmpty(); } boolean changed = false; for (Object o : collection) { if (contains(o)) { myBits.clear((Integer) o); changed = true; } } return changed; }
@Override public void xor(final Filter filter) { if (filter == null || !(filter instanceof BloomFilter) || filter.vectorSize != this.vectorSize || filter.nbHash != this.nbHash) { throw new IllegalArgumentException("filters cannot be xor-ed"); } bits.xor(((BloomFilter) filter).bits); }
@Override public void xor(AbstractFilter filter) { if(filter == null || !(filter instanceof BloomFilter) || filter.vectorSize != this.vectorSize || filter.nbHash != this.nbHash) { throw new IllegalArgumentException("filters cannot be xor-ed"); } bits.xor(((BloomFilter) filter).bits); }
private static void printBitSetDiff(BitSet current, BitSet old) { if(current.length() != old.length()) { System.err.println("BitSet size does not match!"); return; } BitSet diff = (BitSet) current.clone(); diff.xor(old); System.err.println(diff); }
void verify() { checkState(delayReleaseClaims == 0, "%s lazy scope(s) are still active", delayReleaseClaims); checkState(slotsToRelease.isEmpty(), "%s slots are waiting to be released", slotsToRelease); BitSet unavailableSlots = new BitSet(nextSlotToClaim); unavailableSlots.set(0, nextSlotToClaim); // now the only bits on will be the ones where available slots has '0'. unavailableSlots.xor(availableSlots); checkState( unavailableSlots.isEmpty(), "Expected all slots to be available: %s", unavailableSlots); } }
/** represents the result of this bit list logically XORred with the other */ public BitList xorred(BitList other) { BitSet result = asBitSet(); result.xor(other.asBitSet()); return new BitList(result, Math.max(length, other.length)); }