For each element in order provide the int value to a {@link IntConsumer}.

@param consumer for each element.
344557
public void forEachOrderedInt(final IntConsumer consumer)
    {
        for (@DoNotSub int i = 0; i < size; i++)
        {
            consumer.accept(elements[i]);
        }
    }
97548
@Nonnull
	public static <T1, T2> LTieConsumerBuilder<T1, T2> tieConsumer(Consumer<LTieConsumer<T1, T2>> consumer) {
		return new LTieConsumerBuilder(consumer);
	}
1346805
@Nonnull
	public static <T> LConsumer<T> consumerFrom(Consumer<LConsumerBuilder<T>> buildingFunction) {
		LConsumerBuilder builder = new LConsumerBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
401752
@Nonnull
	public static LByteIntConsumer byteIntConsumerFrom(Consumer<LByteIntConsumerBuilder> buildingFunction) {
		LByteIntConsumerBuilder builder = new LByteIntConsumerBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
918546
public static <T> void forEach(Enumeration<T> enumeration, Consumer<T> consumer) {
		int index = 0;
		while (enumeration.hasMoreElements()) {
			consumer.accept(enumeration.nextElement(), index);
			index++;
		}
	}
978546
@Nonnull
	public static LIntConsumer intConsumerFrom(Consumer<LIntConsumerBuilder> buildingFunction) {
		LIntConsumerBuilder builder = new LIntConsumerBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
45434
public static <T> ObjIntConsumer<T> objIntConsumer(CheckedObjIntConsumer<T> consumer) {
        return objIntConsumer(consumer, THROWABLE_TO_RUNTIME_EXCEPTION);
    }
343025
@Nonnull
	public final IntConsumer build() {

		final IntConsumer eventuallyFinal = this.eventually;

		IntConsumer retval;

		final Case<LIntPredicate, IntConsumer>[] casesArray = cases.toArray(new Case[cases.size()]);
		retval = Function4U.intCons(a -> {
			try {
				for (Case<LIntPredicate, IntConsumer> aCase : casesArray) {
					if (aCase.casePredicate().test(a)) {
						aCase.caseFunction().accept(a);
						return;
					}
				}

				eventuallyFinal.accept(a);
			} catch (Error e) { // NOSONAR
					throw e;
				} catch (Throwable e) { // NOSONAR
					throw Handler.handleOrPropagate(e, handling);
				}
			});

		if (consumer != null) {
			consumer.accept(retval);
		}
		return retval;
	}
949582
@Override
    public void accept(E value) {
        for (Consumer<E> consumer : consumers) {
            consumer.accept(value);
        }
    }
34301
public static final <T> void doFor(Object bean, String property, Consumer<T> consumer)
    {
        T t = (T) getValue(bean, property);
        consumer.accept(t);
    }
277728
@Nonnull
	public static <T1, T2> LToIntBiFunctionBuilder<T1, T2> toIntBiFunction(Consumer<LToIntBiFunction<T1, T2>> consumer) {
		return new LToIntBiFunctionBuilder(consumer);
	}
617312
private static IntConsumer adapt(Sink<Integer> sink) {
        if (sink instanceof IntConsumer) {
            return (IntConsumer) sink;
        }
        else {
//            if (Tripwire.ENABLED)
//                Tripwire.trip(AbstractPipeline.class,
//                              "using IntStream.adapt(Sink<Integer> s)");
            return sink::accept;
        }
    }
162198
public void forEach(final TimerConsumer consumer)
    {
        long numTimersLeft = timerCount;

        for (int j = currentTick, end = currentTick + wheel.length; j <= end; j++)
        {
            final long[] array = wheel[j & wheelMask];

            for (int i = 0, length = array.length; i < length; i++)
            {
                final long deadline = array[i];

                if (deadline != NULL_TIMER)
                {
                    consumer.accept(deadline, timerIdForSlot(j & wheelMask, i));

                    if (--numTimersLeft == 0)
                    {
                        return;
                    }
                }
            }
        }
    }
1206394
@Nonnull
	public static <T> LObjDblConsumerBuilder<T> objDblConsumer(Consumer<LObjDblConsumer<T>> consumer) {
		return new LObjDblConsumerBuilder(consumer);
	}
26117
@Nonnull
	public static <T> LConsumerBuilder<T> consumer(Consumer<LConsumer<T>> consumer) {
		return new LConsumerBuilder(consumer);
	}
844486
public void setConsumer(org.apache.kafka.clients.consumer.KafkaConsumer<Object, Object> consumer) {
        this.consumer = consumer;
    }
570805
public static <T> Runnable curry(Consumer<T> consumer, T value) {
        dbc.precondition(consumer != null, "cannot bind parameter of a null consumer");
        return () -> consumer.accept(value);
    }