/**
     * Returns a view of this collector that never returns a missing value.
     */
    Collector<T> absentIgnoring();

    /**
     * Convenience method that returns a view of this collector that never returns a missing value,
     * if that capability is required, or this very collector.
     */
    default Collector<T> absentIgnoringIfNeeded(boolean required) {

    private final ValidationProblemCollector collector;

    public DefaultRuleSourceValidationProblemCollector(ValidationProblemCollector collector) {
        this.collector = collector;
    }

    @Override
    public boolean hasProblems() {
        return collector.hasProblems();
    }

    @Override
    public void add(String problem) {
        collector.add(problem);
    }

    @Override

        public Value<Void> collectEntries(ValueConsumer consumer, MapEntryCollector<K, V> collector, Map<K, V> dest) {
            collector.add(key, value, dest);
            return Value.present();
        }

        @Override
        public Value<Void> collectKeys(ValueConsumer consumer, ValueCollector<K> collector, ImmutableCollection.Builder<K> dest) {
            collector.add(key, dest);
            return Value.present();
        }

 * </p>
 */
public interface MapCollector<K, V> extends ValueSupplier {

    Value<Void> collectEntries(ValueConsumer consumer, MapEntryCollector<K, V> collector, Map<K, V> dest);

    Value<Void> collectKeys(ValueConsumer consumer, ValueCollector<K> collector, ImmutableCollection.Builder<K> dest);

    }

    def "formats message with multiple problems"() {
        given:
        def collector = new FormattingValidationProblemCollector("<thing>", ModelType.of(String))
        collector.add("does not extend RuleSource")
        collector.add("does not have any rule method")

        expect:
        collector.format() == '''Type java.lang.String is not a valid <thing>:
- does not extend RuleSource

    /**
     * Combines the current collection supplier with the given {@link Collector} (also a {@link ValueSupplier value supplier}), producing a new
     * collection supplier that produces a collection that contains the original elements and the
     * elements supplied by the given collector.
     *
     * @param added a collector that represents an addition to the collection to be returned by this supplier

    Value<? extends Map<K, V>> calculateValue(ValueConsumer consumer);

    Value<? extends Set<K>> calculateKeys(ValueConsumer consumer);

    MapSupplier<K, V> plus(MapCollector<K, V> collector);

    /**
     * Returns a view of this supplier that may calculate its value as empty if it would be missing.
     */
    MapSupplier<K, V> absentIgnoring();

import org.gradle.internal.watch.registry.FileWatcherUpdater;

import java.io.File;
import java.util.Collection;
import java.util.concurrent.BlockingQueue;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class LinuxFileWatcherRegistryFactory extends AbstractFileWatcherRegistryFactory<LinuxFileEventFunctions, LinuxFileWatcher> {

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collectors;

public class HandleStaleOutputsStep<C extends WorkspaceContext, R extends AfterExecutionResult> implements Step<C, R> {
    @VisibleForTesting

import org.gradle.api.NonNullApi;
import org.gradle.api.problems.internal.GradleCoreProblemGroup;
import org.gradle.internal.reflect.validation.TypeValidationContext;

import java.util.Optional;
import java.util.stream.Collectors;

import static org.gradle.api.problems.Severity.WARNING;
import static org.gradle.internal.deprecation.Documentation.userManual;

/**
 * Utility methods for validating {@link org.gradle.api.tasks.Nested} properties.