Consume path list.

@param isParallel the is parallel
@param pathList   the path list
@param consumer   the consumer
487398
public static void consumePathList(boolean isParallel, List<Path> pathList,
			Consumer<Path> consumer) {
		JMStream.buildStream(isParallel, pathList).forEach(consumer);
	}
1298134
public <T> void forEach(Stream<T> stream, Consumer<? super T> action) {
        Runnable runnable = () -> stream.forEach(action);
        ThreadMethods.forkJoinExecution(runnable, concurrencyConfiguration, stream.isParallel());
    }
805151
public static void isBlankThen(String str, Consumer<String> consumer) {
        if (isBlank(str)) {
            consumer.accept(str);
        }
    }
3458
@Override
    public java.util.concurrent.Future<ListPipelinesResult> listPipelinesAsync(
            com.amazonaws.handlers.AsyncHandler<ListPipelinesRequest, ListPipelinesResult> asyncHandler) {

        return listPipelinesAsync(new ListPipelinesRequest(), asyncHandler);
    }
777769
public static SyncListItemFetcher fetcher(final String pathServiceSid, 
                                              final String pathListSid, 
                                              final Integer pathIndex) {
        return new SyncListItemFetcher(pathServiceSid, pathListSid, pathIndex);
    }
1329979
protected final void registerConsumer( AbstractMessageConsumer consumer )
    {
        if (consumersMap.put(consumer.getId(),consumer) != null)
        	throw new IllegalArgumentException("Consumer "+consumer.getId()+" already exists");
    }
1015311
public void forEach(final IntIntConsumer consumer)
    {
        final int[] entries = this.entries;
        final int initialValue = this.initialValue;
        @DoNotSub final int length = entries.length;

        for (@DoNotSub int i = 0; i < length; i += 2)
        {
            if (entries[i + 1] != initialValue) // lgtm [java/index-out-of-bounds]
            {
                consumer.accept(entries[i], entries[i + 1]); // lgtm [java/index-out-of-bounds]
            }
        }
    }
342761
public void setParallelized(boolean parallelized) {
        for(Trainable t : bundle.values()) {
            if (t !=null && t instanceof Parallelizable) {
                ((Parallelizable)t).setParallelized(parallelized);
            }
        }
    }
312058
@SuppressWarnings("unchecked")
    public void forEach(final Consumer<V> consumer)
    {
        for (final Object value : values)
        {
            if (null != value)
            {
                consumer.accept((V)value);
            }
        }
    }
739158
public static <T> void consumeIfTrue(boolean bool, T target,
            Consumer<T> consumer) {
        if (bool)
            consumer.accept(target);
    }
1368456
public boolean isBound(@NonNull BeaconConsumer consumer) {
        synchronized(consumers) {
            // Annotation doesn't guarantee we get a non-null, but raising an NPE here is excessive
            //noinspection ConstantConditions
            return consumer != null && consumers.get(consumer) != null &&
                    (mScheduledScanJobsEnabled || serviceMessenger != null);
        }
    }
100002
public void forEach(IntConsumer consumer)
    {
        for (int ii=0;ii<array.length;ii++)
        {
            if (array[ii] != 0)
            {
                int lim = Math.min(bits, (ii+1)*8);
                for (int jj=ii*8;jj<lim;jj++)
                {
                    if (isSet(jj))
                    {
                        consumer.accept(jj);
                    }
                }
            }
        }
    }
1350872
@Nonnull
	public static <T> LObjIntSrtPredicateBuilder<T> objIntSrtPredicate(Consumer<LObjIntSrtPredicate<T>> consumer) {
		return new LObjIntSrtPredicateBuilder(consumer);
	}
100110
static public <E> LoadBalancedList<E> synchronizedList(LoadBalancedList<E> list) {
        return new ConcurrentLoadBalancedList<E>(list);
    }
679730
@Override
   public void forEach(Consumer<? super List<String>> consumer) {
      try (Stream<List<String>> stream = stream()) {
         stream.forEach(consumer);
      }
   }
514027
public void ifBound(Consumer<? super T> consumer) {
		Assert.notNull(consumer, "Consumer must not be null");
		if (this.value != null) {
			consumer.accept(this.value);
		}
	}
95303
public void forEach(final IntObjConsumer<String> consumer)
    {
        int counterId = 0;

        final AtomicBuffer metaDataBuffer = this.metaDataBuffer;
        for (int i = 0, capacity = metaDataBuffer.capacity(); i < capacity; i += METADATA_LENGTH)
        {
            final int recordStatus = metaDataBuffer.getIntVolatile(i);

            if (RECORD_ALLOCATED == recordStatus)
            {
                consumer.accept(counterId, labelValue(metaDataBuffer, i));
            }
            else if (RECORD_UNUSED == recordStatus)
            {
                break;
            }

            counterId++;
        }
    }