@Override public boolean test( int item ) { return filter.test( item ); } };
/** * Evaluates whether the provided table bucket number passes the bucket predicate. * A bucket predicate can be present in two cases: * <ul> * <li>Filter on "$bucket" column. e.g. {@code "$bucket" between 0 and 100} * <li>Single-value equality filter on all bucket columns. e.g. for a table with two bucketing columns, * {@code bucketCol1 = 'a' AND bucketCol2 = 123} * </ul> */ public boolean isTableBucketEnabled(int tableBucketNumber) { return bucketFilter.test(tableBucketNumber); } }
@Override public int lastIndexOf(IntPredicate predicate, int fromIndex) { Assert.notNull(predicate, "IntPredicate must not be null"); int i = Math.min(fromIndex, this.writePosition - 1); for (; i >= 0; i--) { byte b = this.byteBuffer.get(i); if (predicate.test(b)) { return i; } } return -1; }
private boolean skip(int c) { return predicate.test(c); } };
private boolean skip(int c) { return predicate.test(c); } }
@Override public int indexOf(IntPredicate predicate, int fromIndex) { Assert.notNull(predicate, "IntPredicate must not be null"); if (fromIndex < 0) { fromIndex = 0; } else if (fromIndex >= this.writePosition) { return -1; } for (int i = fromIndex; i < this.writePosition; i++) { byte b = this.byteBuffer.get(i); if (predicate.test(b)) { return i; } } return -1; }
@Override public boolean anyMatch(IntPredicate predicate) { requireNonNull(predicate); return predicate.test(element); }
@Override public boolean noneMatch(IntPredicate predicate) { requireNonNull(predicate); return !predicate.test(element); }
@Override public boolean allMatch(IntPredicate predicate) { requireNonNull(predicate); return predicate.test(element); }
@Override public int lastIndexOf(IntPredicate predicate, int fromIndex) { Assert.notNull(predicate, "IntPredicate must not be null"); int i = Math.min(fromIndex, this.writePosition - 1); for (; i >= 0; i--) { byte b = this.byteBuffer.get(i); if (predicate.test(b)) { return i; } } return -1; }
@Override public int indexOf(IntPredicate predicate, int fromIndex) { Assert.notNull(predicate, "IntPredicate must not be null"); if (fromIndex < 0) { fromIndex = 0; } else if (fromIndex >= this.writePosition) { return -1; } for (int i = fromIndex; i < this.writePosition; i++) { byte b = this.byteBuffer.get(i); if (predicate.test(b)) { return i; } } return -1; }
private static int getInt(String name, int defaultValue, IntPredicate validator) { return Integer.parseInt(getNormalized(name, String.valueOf(defaultValue), value -> { try { return validator.test(Integer.parseInt(value)); } catch (Exception e) { // null or non-integer return false; } })); }
/** * Create the tokens by the given names, and store their ids in the corresponding entry in the {@code ids} array, * but only if the {@code indexFilter} returns {@code true} for the given index. * * @param names The array of token names we potentially want to create new ids for. * @param ids The array into which we still store the id we create for the various token names. * @param indexFilter A filter for the array indexes for which a token needs an id. * @throws KernelException If the inner transaction used to allocate the tokens encountered a problem. */ default void createTokens( String[] names, int[] ids, IntPredicate indexFilter ) throws KernelException { for ( int i = 0; i < ids.length; i++ ) { if ( indexFilter.test( i ) ) { ids[i] = createToken( names[i] ); } } } }
@Override protected IntPredicate wrap(IntPredicate consumer) { return e -> { elementConsumer.accept(e); return consumer.test(e); }; } }
@Override public boolean next(IntPredicate consumer) { while (true) { int valueToReport = value; value = f.applyAsInt(value); if (!consumer.test(valueToReport)) { return true; } } } }
@Override public synchronized void createTokens( String[] names, int[] ids, IntPredicate filter ) throws KernelException { Kernel kernel = kernelSupplier.get(); try ( Transaction tx = kernel.beginTransaction( Type.implicit, LoginContext.AUTH_DISABLED ) ) { for ( int i = 0; i < ids.length; i++ ) { if ( filter.test( i ) ) { ids[i] = createKey( tx, names[i] ); } } tx.success(); } }
private void mockAssignNewTokenIdsInBatch( AtomicInteger nextId ) throws KernelException { doAnswer( inv -> { int[] ids = inv.getArgument( 1 ); IntPredicate filter = inv.getArgument( 2 ); for ( int i = 0; i < ids.length; i++ ) { if ( filter.test( i ) ) { ids[i] = nextId.getAndIncrement(); } } return null; } ).when( creator ).createTokens( any( String[].class ), any( int[].class ), any( IntPredicate.class ) ); }
private synchronized IntArrayList partitionPage(Page page, IntPredicate spillPartitionMask) { IntArrayList unspilledPositions = new IntArrayList(); for (int position = 0; position < page.getPositionCount(); position++) { int partition = partitionFunction.getPartition(page, position); if (!spillPartitionMask.test(partition)) { unspilledPositions.add(position); continue; } spilledPartitions.add(partition); PageBuilder pageBuilder = pageBuilders[partition]; pageBuilder.declarePosition(); for (int channel = 0; channel < types.size(); channel++) { Type type = types.get(channel); type.appendTo(page.getBlock(channel), position, pageBuilder.getBlockBuilder(channel)); } } return unspilledPositions; }
private void writeNodeData( PrintStream writer, Configuration config, List<String> nodeIds, IntPredicate linePredicate, int extraColumns ) { char delimiter = config.delimiter(); char arrayDelimiter = config.arrayDelimiter(); for ( int i = 0; i < nodeIds.size(); i++ ) { if ( linePredicate.test( i ) ) { writer.println( getLine( nodeIds.get( i ), delimiter, arrayDelimiter, extraColumns ) ); } } }