private final ThreadLocal<Boolean> dispatching =
        new ThreadLocal<Boolean>() {
          @Override
          protected Boolean initialValue() {
            return false;
          }
        };

    @Override
    void dispatch(Object event, Iterator<Subscriber> subscribers) {
      checkNotNull(event);
      checkNotNull(subscribers);

        ) : RequestBody() {

          override fun contentType() = delegate.contentType()

          @Throws(IOException::class)
          override fun contentLength(): Long = delegate.contentLength()

          @Throws(IOException::class)
          override fun writeTo(sink: BufferedSink) {
            val forwardingSink = object : ForwardingSink(sink) {

     * element.
     */
    NEXT_LOWER {
      @Override
      int resultIndex(int higherIndex) {
        return higherIndex - 1;
      }
    },
    /**
     * Return the index of the next higher element in the list, or {@code list.size()} if there is
     * no such element.
     */
    NEXT_HIGHER {
      @Override
      public int resultIndex(int higherIndex) {
        return higherIndex;

import org.elasticsearch.gradle.Version;

public class DebElasticsearchDistributionType implements ElasticsearchDistributionType {

    DebElasticsearchDistributionType() {}

    @Override
    public String getName() {
        return "deb";
    }

    @Override
    public String getClassifier(ElasticsearchDistribution.Platform platform, Version version) {
        return ":amd64";
    }

public class BaseComparable implements Comparable<BaseComparable>, Serializable {
  private final String s;

  public BaseComparable(String s) {
    this.s = s;
  }

  @Override
  public int hashCode() { // delegate to 's'
    return s.hashCode();
  }

  @Override
  public boolean equals(@Nullable Object other) {
    if (other == null) {
      return false;
    } else if (other instanceof BaseComparable) {

  }

  private abstract static class FailToForward extends ForwardingObject implements Runnable {
    @Override
    public void run() {}
  }

  private abstract static class ForwardToDelegate extends ForwardingObject implements Runnable {
    @Override
    public void run() {
      delegate().run();
    }

    @Override
    protected abstract Runnable delegate();
  }

    }

    @Override
    public Iterator<T> iterator() {
      return Iterators.unmodifiableIterator(iterable.iterator());
    }

    @Override
    public void forEach(Consumer<? super T> action) {
      iterable.forEach(action);
    }

    @SuppressWarnings("unchecked") // safe upcast, assuming no one has a crazy Spliterator subclass
    @Override
    public Spliterator<T> spliterator() {

      this.interfaceType = interfaceType;
    }

    @Override
    protected @Nullable Object handleInvocation(
        Object proxy, Method method, @Nullable Object[] args) {
      return interfaceMethodCalled(interfaceType, method);
    }

    @Override
    public int hashCode() {
      return identity;
    }

    @Override
    public boolean equals(@Nullable Object obj) {

        @Override
        protected Extractor getExtractor(final ResponseData responseData) {
            return null; // Return null for testing
        }

        @Override
        public Logger getLogger() {
            return logger;
        }

        @Override
        public FessConfig getFessConfig() {
            return fessConfig;

    List<Object> invalidated = new ArrayList<>();
    Cache<Integer, Integer> cache =
        new AbstractCache<Integer, Integer>() {
          @Override
          public Integer getIfPresent(Object key) {
            throw new UnsupportedOperationException();
          }

          @Override
          public void invalidate(Object key) {
            invalidated.add(key);
          }
        };