* limitations under the License.
 */

package org.gradle.api.internal.provider;

import com.google.common.collect.ImmutableCollection;

import javax.annotation.Nullable;

public interface ValueCollector<T> {
    void add(@Nullable T value, ImmutableCollection.Builder<T> dest);

    void addAll(Iterable<? extends T> values, ImmutableCollection.Builder<T> dest);

        @Override
        @Nullable
        public Object sanitize(@Nullable Object value) {
            return value;
        }
    };
    private static final ValueCollector<Object> IDENTITY_VALUE_COLLECTOR = new ValueCollector<Object>() {
        @Override
        public void add(@Nullable Object value, ImmutableCollection.Builder<Object> dest) {
            dest.add(value);
        }

        @Override

    }

    private ValueCollector copySources(ValueCollector conventionCollector) {
        return conventionCollector.isolated();
    }

    private ValueCollector newValue(ValueCollector baseValue, Object[] paths) {
        return baseValue.setFrom(this, resolver, patternSetFactory, dependencyFactory, host, paths);
    }

    private ValueCollector newValue(ValueCollector baseValue, Iterable<?> paths) {

        protected final Collector<T> delegate;
        private final ValueCollector<T> valueCollector;

        public TypedCollector(@Nullable Class<? extends T> type, Collector<T> delegate) {
            this.type = type;
            this.delegate = delegate;
            this.valueCollector = ValueSanitizers.collectorFor(type);
        }

        @Nullable

            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();
        }

        @Override

import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableCollection;

import javax.annotation.Nullable;

class ValidatingValueCollector<T> implements ValueCollector<T> {
    private final Class<?> collectionType;
    private final Class<T> elementType;
    private final ValueSanitizer<T> sanitizer;

    private final Class<? extends Collection> collectionType;
    private final Class<T> elementType;
    private final Supplier<ImmutableCollection.Builder<T>> collectionFactory;
    private final ValueCollector<T> valueCollector;
    private CollectionSupplier<T, C> defaultValue;

 * <p>
 *     A <code>Collector</code> represents an increment to a collection property.
 * </p>
 */
public interface Collector<T> extends ValueSupplier {
    Value<Void> collectEntries(ValueConsumer consumer, ValueCollector<T> collector, ImmutableCollection.Builder<T> dest);

    int size();

    void calculateExecutionTimeValue(Action<? super ExecutionTimeValue<? extends Iterable<? extends T>>> visitor);

    /**

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);

    void calculateExecutionTimeValue(Action<ExecutionTimeValue<? extends Map<? extends K, ? extends V>>> visitor);

    MapCollector<K, V> absentIgnoring();

    private final Class<K> keyType;
    private final Class<V> valueType;
    private final ValueCollector<K> keyCollector;
    private final MapEntryCollector<K, V> entryCollector;
    private MapSupplier<K, V> defaultValue = emptySupplier();