*/

package org.gradle.api.internal.provider;

import com.google.common.collect.ImmutableCollection;
import org.gradle.api.Action;


/**
 * A collector is a value supplier of zero or more values of type {@link T}.
 * <p>
 *     A <code>Collector</code> represents an increment to a collection property.
 * </p>
 */
public interface Collector<T> extends ValueSupplier {

  private final BiPredicate<? super R, ? super R> equivalence;

  private CollectorTester(
      Collector<T, A, R> collector, BiPredicate<? super R, ? super R> equivalence) {
    this.collector = checkNotNull(collector);
    this.equivalence = checkNotNull(equivalence);
  }

  /**
   * Different orderings for combining the elements of an input array, which must all produce the
   * same result.
   */

   * collector without breaking j2cl?
   */
  private static final Collector<Object, ?, Optional<Object>> TO_OPTIONAL =
      Collector.of(
          ToOptionalState::new,
          ToOptionalState::add,
          ToOptionalState::combine,
          ToOptionalState::getOptional,
          Collector.Characteristics.UNORDERED);

  /**

apiVersion: v1
kind: ConfigMap
metadata:
  name: opentelemetry-collector-conf
  labels:
    app: opentelemetry-collector
data:
  opentelemetry-collector-config: |
    receivers:
      opencensus:
        endpoint: 0.0.0.0:55678
      otlp:
        protocols:
          grpc:
          http:
    processors:
      batch:
    exporters:
      zipkin:
        # Export to zipkin for easy querying

        protected final Collector collector;

        public CollectingFileVisitor(Collector collector) {
            this.collector = collector;
            collector.recordVisitHierarchy();
        }

        @Override
        public final FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
            collector.recordVisitDirectory();

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

```yaml
exporters:
  jaeger:
    endpoint: jaeger-collector.istio-system.svc.cluster.local:14250
    tls:
      insecure: true
    sending_queue:
      enabled: true

                    collector.checkResolveCall(resolvedCall)
                }
            }

            override fun visitForExpression(expression: KtForExpression) {
                super.visitForExpression(expression)

                val bindingContext = analysisContext.analyze(expression)

import java.util.function.Supplier;
import java.util.stream.Collector;
import org.checkerframework.checker.nullness.qual.Nullable;

/** Collectors utilities for {@code common.collect.Table} internals. */
@GwtCompatible
@ElementTypesAreNonnullByDefault
final class TableCollectors {

  static <T extends @Nullable Object, R, C, V>
      Collector<T, ?, ImmutableTable<R, C, V>> toImmutableTable(

    // TODO - b/335044516 : Find a way to flush outside of the destructor.
    CalibrationStatisticsMap statistics_map;
    for (const auto& [id, collector] : id_to_collector_) {
      std::optional<CalibrationStatistics> statistics =
          collector->GetStatistics();
      if (!statistics.has_value()) continue;

      statistics_map.mutable_statistics()->emplace(id, std::move(*statistics));
    }