@Override public void not() { bits.flip(0, vectorSize); }
private static BitSet getAllIncompatible(int regCount) { BitSet incompatRegs = new BitSet(regCount); incompatRegs.flip(0, regCount); return incompatRegs; }
@GwtIncompatible // used only from other GwtIncompatible code @Override void setBits(BitSet table) { BitSet tmp = new BitSet(); original.setBits(tmp); tmp.flip(Character.MIN_VALUE, Character.MAX_VALUE + 1); table.or(tmp); }
/** * Bitwise NEGATE a BitSet. * * @param self a BitSet * @return the bitwise NEGATE of the BitSet * @since 1.5.0 */ public static BitSet bitwiseNegate(BitSet self) { BitSet result = (BitSet) self.clone(); result.flip(0, result.size() - 1); return result; }
private ImmutableBitSet convert(long value, int length) { BitSet bits = new BitSet(); for (int index = length - 1; index >= 0; index--) { if (value % 2 != 0) { bits.set(index); } value = value >>> 1; } // We flip the bits because Calcite considers that '1' // means that the column participates in the GroupBy // and '0' does not, as opposed to grouping_id. bits.flip(0, length); return ImmutableBitSet.FROM_BIT_SET.apply(bits); }
/** * Called to coalesce a successor's usage into the current BB. Important: This should be called * before live variable analysis begins, because we don't bother merging this.in or this.born. */ void absorb(Usage succ) { BitSet b = (BitSet) this.def.clone(); b.flip(0, nLocals); b.and(succ.use); this.use.or(b); this.def.or(succ.def); }
@GwtIncompatible // used only from other GwtIncompatible code @Override void setBits(BitSet table) { BitSet tmp = new BitSet(); original.setBits(tmp); tmp.flip(Character.MIN_VALUE, Character.MAX_VALUE + 1); table.or(tmp); }
@GwtIncompatible // used only from other GwtIncompatible code @Override void setBits(BitSet table) { BitSet tmp = new BitSet(); original.setBits(tmp); tmp.flip(Character.MIN_VALUE, Character.MAX_VALUE + 1); table.or(tmp); }
@Override void setBits(BitSet table) { BitSet tmp = new BitSet(); original.setBits(tmp); tmp.flip(Character.MIN_VALUE, Character.MAX_VALUE + 1); table.or(tmp); }
private ImmutableBitSet convert(int value, int length) { BitSet bits = new BitSet(); for (int index = length - 1; index >= 0; index--) { if (value % 2 != 0) { bits.set(index); } value = value >>> 1; } // We flip the bits because Calcite considers that '1' // means that the column participates in the GroupBy // and '0' does not, as opposed to grouping_id. bits.flip(0, length); return ImmutableBitSet.FROM_BIT_SET.apply(bits); }
@GwtIncompatible // used only from other GwtIncompatible code @Override void setBits(BitSet table) { BitSet tmp = new BitSet(); original.setBits(tmp); tmp.flip(Character.MIN_VALUE, Character.MAX_VALUE + 1); table.or(tmp); }
} else { table.flip(Character.MIN_VALUE, Character.MAX_VALUE + 1); int negatedCharacters = DISTINCT_CHARS - totalCharacters; String suffix = ".negate()";
for (Handler handle : handUsage) def1.and(handle.catchBB.usage.def); def1.flip(0, nLocals); out.and(def1); for (Handler handler : handUsage)
} else { table.flip(Character.MIN_VALUE, Character.MAX_VALUE + 1); int negatedCharacters = DISTINCT_CHARS - totalCharacters; String suffix = ".negate()";
} else { table.flip(Character.MIN_VALUE, Character.MAX_VALUE + 1); int negatedCharacters = DISTINCT_CHARS - totalCharacters; String suffix = ".negate()";
fullSet.flip(0, graph.size());// set all to true
} else { table.flip(Character.MIN_VALUE, Character.MAX_VALUE + 1); int negatedCharacters = DISTINCT_CHARS - totalCharacters; String suffix = ".negate()";
@Override public void complement(FlowSet<T> destFlow) { if (sameType(destFlow)) { ArrayPackedSet<T> dest = (ArrayPackedSet<T>) destFlow; copyBitSet(dest).flip(0, dest.map.size()); } else { super.complement(destFlow); } }
@Override public void not() { bits.flip(0, vectorSize - 1); }
@Override public void not() { bits.flip(0, vectorSize - 1); }