public static boolean in(boolean booleanValue, BooleanOpenHashSet set) { return set.contains(booleanValue); }
@Override public BooleanColumn fillWith(BooleanIterable iterable) { BooleanIterator iterator = iterable.iterator(); for (int r = 0; r < size(); r++) { if (!iterator.hasNext()) { iterator = iterable.iterator(); if (!iterator.hasNext()) { break; } } set(r, iterator.nextBoolean()); } return this; }
@Override public BooleanColumn fillWith(BooleanIterator iterator) { for (int r = 0; r < size(); r++) { if (!iterator.hasNext()) { break; } set(r, iterator.nextBoolean()); } return this; }
outputStream.reset(); BooleanList expectedValues = new BooleanArrayList(1024); outputStream.writeBooleans(32, true); expectedValues.addAll(Collections.nCopies(32, true)); outputStream.writeBooleans(32, false); expectedValues.addAll(Collections.nCopies(32, false)); expectedValues.add(true); outputStream.writeBooleans(1, false); expectedValues.add(false); expectedValues.addAll(Collections.nCopies(34, true)); outputStream.writeBooleans(34, false); expectedValues.addAll(Collections.nCopies(34, false)); expectedValues.add(true); outputStream.writeBoolean(false); expectedValues.add(false); for (int index = 0; index < expectedValues.size(); index++) { boolean expectedValue = expectedValues.getBoolean(index); boolean actualValue = readValue(valueStream); assertEquals(actualValue, expectedValue);
private ColumnChunk readArray(GroupField field) throws IOException { List<Type> parameters = field.getType().getTypeParameters(); checkArgument(parameters.size() == 1, "Arrays must have a single type parameter, found %d", parameters.size()); Field elementField = field.getChildren().get(0).get(); ColumnChunk columnChunk = readColumnChunk(elementField); IntList offsets = new IntArrayList(); BooleanList valueIsNull = new BooleanArrayList(); calculateCollectionOffsets(field, offsets, valueIsNull, columnChunk.getDefinitionLevels(), columnChunk.getRepetitionLevels()); Block arrayBlock = ArrayBlock.fromElementBlock(valueIsNull.size(), Optional.of(valueIsNull.toBooleanArray()), offsets.toIntArray(), columnChunk.getBlock()); return new ColumnChunk(arrayBlock, columnChunk.getDefinitionLevels(), columnChunk.getRepetitionLevels()); }
BooleanList structIsNull = new BooleanArrayList(); boolean required = field.isRequired(); if (fieldDefinitionLevels == null) { if (isValueNull(required, fieldDefinitionLevels[i], maxDefinitionLevel)) { structIsNull.add(true); structIsNull.add(false);
private ColumnChunk readMap(GroupField field) throws IOException { List<Type> parameters = field.getType().getTypeParameters(); checkArgument(parameters.size() == 2, "Maps must have two type parameters, found %d", parameters.size()); Block[] blocks = new Block[parameters.size()]; ColumnChunk columnChunk = readColumnChunk(field.getChildren().get(0).get()); blocks[0] = columnChunk.getBlock(); blocks[1] = readColumnChunk(field.getChildren().get(1).get()).getBlock(); IntList offsets = new IntArrayList(); BooleanList valueIsNull = new BooleanArrayList(); calculateCollectionOffsets(field, offsets, valueIsNull, columnChunk.getDefinitionLevels(), columnChunk.getRepetitionLevels()); Block mapBlock = ((MapType) field.getType()).createBlockFromKeyValue(Optional.of(valueIsNull.toBooleanArray()), offsets.toIntArray(), blocks[0], blocks[1]); return new ColumnChunk(mapBlock, columnChunk.getDefinitionLevels(), columnChunk.getRepetitionLevels()); }
@Override public boolean retainAll(final BooleanCollection c) { boolean retVal = false; for (final BooleanIterator i = iterator(); i.hasNext();) if (!c.contains(i.nextBoolean())) { i.remove(); retVal = true; } return retVal; } @Override
@Override public boolean removeAll(final BooleanCollection c) { boolean retVal = false; for (final BooleanIterator i = c.iterator(); i.hasNext();) if (rem(i.nextBoolean())) retVal = true; return retVal; } @Override
@Override public boolean containsAll(final BooleanCollection c) { for (final BooleanIterator i = c.iterator(); i.hasNext();) if (!contains(i.nextBoolean())) return false; return true; } @Override
public BooleanSet asSet() { BooleanSet set = new BooleanOpenHashSet(3); BooleanColumn unique = unique(); for (int i = 0; i < unique.size(); i++) { set.add((boolean) unique.get(i)); } return set; }
if (ParquetTypeUtils.isValueNull(required, definitionLevels[i], maxDefinitionLevel)) { collectionIsNull.add(true); offsets.add(offset); collectionIsNull.add(false); offsets.add(offset); collectionIsNull.add(false); offset += getCollectionSize(repetitionLevels, maxElementRepetitionLevel, i + 1); offsets.add(offset);
@SuppressWarnings("unchecked") public static Set<?> toFastutilHashSet(Set<?> set, Type type, FunctionRegistry registry) { // 0.25 as the load factor is chosen because the argument set is assumed to be small (<10000), // and the return set is assumed to be read-heavy. // The performance of InCodeGenerator heavily depends on the load factor being small. Class<?> javaElementType = type.getJavaType(); if (javaElementType == long.class) { return new LongOpenCustomHashSet((Collection<Long>) set, 0.25f, new LongStrategy(registry, type)); } if (javaElementType == double.class) { return new DoubleOpenCustomHashSet((Collection<Double>) set, 0.25f, new DoubleStrategy(registry, type)); } if (javaElementType == boolean.class) { return new BooleanOpenHashSet((Collection<Boolean>) set, 0.25f); } else if (!type.getJavaType().isPrimitive()) { return new ObjectOpenCustomHashSet(set, 0.25f, new ObjectStrategy(registry, type)); } else { throw new UnsupportedOperationException("Unsupported native type in set: " + type.getJavaType() + " with type " + type.getTypeSignature()); } }
@Override public boolean addAll(BooleanCollection 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
private ColumnChunk readStruct(GroupField field) throws IOException { List<TypeSignatureParameter> fields = field.getType().getTypeSignature().getParameters(); Block[] blocks = new Block[fields.size()]; ColumnChunk columnChunk = null; List<Optional<Field>> parameters = field.getChildren(); for (int i = 0; i < fields.size(); i++) { Optional<Field> parameter = parameters.get(i); if (parameter.isPresent()) { columnChunk = readColumnChunk(parameter.get()); blocks[i] = columnChunk.getBlock(); } } for (int i = 0; i < fields.size(); i++) { if (blocks[i] == null) { blocks[i] = RunLengthEncodedBlock.create(field.getType(), null, columnChunk.getBlock().getPositionCount()); } } BooleanList structIsNull = StructColumnReader.calculateStructOffsets(field, columnChunk.getDefinitionLevels(), columnChunk.getRepetitionLevels()); boolean[] structIsNullVector = structIsNull.toBooleanArray(); Block rowBlock = RowBlock.fromFieldBlocks(structIsNullVector.length, Optional.of(structIsNullVector), blocks); return new ColumnChunk(rowBlock, columnChunk.getDefinitionLevels(), columnChunk.getRepetitionLevels()); }
@Override public BooleanBigListIterator listIterator(final long index) { return BooleanBigListIterators.asBigListIterator(list.listIterator(intIndex(index))); } @Override
@Override public boolean add(final boolean k) { l.add(to, k); to++; assert assertRange(); return true; } @Override
@Override public boolean getBoolean(long index) { ensureRestrictedIndex(index); return l.getBoolean(from + index); } @Override
T fillWith(Supplier<Boolean> supplier); }
/** * {@inheritDoc} * * <p> * This implementation delegates to the analogous method for big-array * fragments. */ @Override public void addElements(final long index, final boolean a[][]) { addElements(index, a, 0, BooleanBigArrays.length(a)); } /**