A Consumer which always passes its its input to whatever Consumer is supplied by target.
<p>
By passing something mutable, such as a {@link Box}, you can redirect the returned consumer.
350924
public static <T> Consumer<T> redirectable(Supplier<Consumer<T>> target) {
		return value -> target.get().accept(value);
	}
1204908
public <T> Consumer<T> wrap(Throwing.Consumer<T> consumer) {
		return val -> {
			try {
				consumer.accept(val);
			} catch (Throwable e) {
				handler.accept(e);
			}
		};
	}
176339
@Nonnull
	public static <T> ConsumerBuilder<T> consumer(Consumer<Consumer<T>> consumer) {
		return new ConsumerBuilder(consumer);
	}
95200
@Nonnull
	public static <T1, T2> ToIntBiFunctionBuilder<T1, T2> toIntBiFunction(Consumer<ToIntBiFunction<T1, T2>> consumer) {
		return new ToIntBiFunctionBuilder(consumer);
	}
273771
public static <T, U> void consumeIfTrue(boolean bool, T target1, U target2,
            BiConsumer<T, U> biConsumer) {
        if (bool)
            biConsumer.accept(target1, target2);
    }
289065
@NotNull
    public Optional<T> executeIfPresent(@NotNull Consumer<? super T> consumer) {
        ifPresent(consumer);
        return this;
    }
468435
public static <T> void consumeIfTrue(T target, Predicate<T> targetTester,
            Consumer<T> consumer) {
        consumeIfTrue(targetTester.test(target), target, consumer);
    }
1136873
@Nonnull
	public static <T> LToSrtFunctionBuilder<T> toSrtFunction(Consumer<LToSrtFunction<T>> consumer) {
		return new LToSrtFunctionBuilder(consumer);
	}
663474
@Nonnull
	public static <R> LSrtFunctionBuilder<R> srtFunction(Consumer<LSrtFunction<R>> consumer) {
		return new LSrtFunctionBuilder(consumer);
	}
224344
@Nonnull
	public static <T> LToCharFunctionBuilder<T> toCharFunction(Consumer<LToCharFunction<T>> consumer) {
		return new LToCharFunctionBuilder(consumer);
	}
1343798
public <T> InjectorBuilder forEachElement(ElementVisitor<T> visitor, Consumer<T> consumer) {
        Elements
            .getElements(module)
            .forEach(element -> Optional.ofNullable(element.acceptVisitor(visitor)).ifPresent(consumer));
        return this;
    }
324294
public static <T> void forEach(Iterator<T> iterator, Consumer<T> consumer) {
		int index = 0;
		while (iterator.hasNext()) {
			consumer.accept(iterator.next(), index);
			index++;
		}
	}
45434
public static <T> ObjIntConsumer<T> objIntConsumer(CheckedObjIntConsumer<T> consumer) {
        return objIntConsumer(consumer, THROWABLE_TO_RUNTIME_EXCEPTION);
    }
1298480
public void ifPresent(@NotNull Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }
1215874
@Override
    public ConsumerManager chooseConsumerManager(SIBUuid12 gatheringTargetUuid,
                                                 SIBUuid8 fixedMEUuid,
                                                 HashSet<SIBUuid8> scopedMEs)
                    throws SIResourceException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "chooseConsumerManager", new Object[] { gatheringTargetUuid, fixedMEUuid, scopedMEs });

        ConsumerManager consumerManager = null;

        consumerManager = _ptoPRealization.chooseConsumerManager(definition,
                                                                 isReceiveAllowed(),
                                                                 gatheringTargetUuid,
                                                                 fixedMEUuid,
                                                                 scopedMEs);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "chooseConsumerManager", consumerManager);

        return consumerManager;
    }
883484
public void forEach(final EntryConsumer<V> consumer) {
        for (Map.Entry<Long, V> entry : map.entrySet()) {
            Long compoundKey = entry.getKey();
            final int keyPartA = (int) (compoundKey >>> Integer.SIZE);
            final int keyPartB = (int) (compoundKey & LOWER_INT_MASK);
            consumer.accept(keyPartA, keyPartB, entry.getValue());
        }
    }
104551
@Nonnull
	public static <T, R> FunctionBuilder<T, R> function(Consumer<Function<T, R>> consumer) {
		return new FunctionBuilder(consumer);
	}