return ImmutableMultimap.<String, Integer>of().asMap();
  }

  @Override
  protected Map<String, Collection<Integer>> makePopulatedMap() {
    Multimap<String, Integer> delegate = HashMultimap.create();
    populate(delegate);
    return ImmutableMultimap.copyOf(delegate).asMap();
  }

        .asMap();
  }

  @Override
  protected Map<String, Collection<Integer>> makePopulatedMap() {
    ListMultimap<String, Integer> delegate = ArrayListMultimap.create();
    populate(delegate);
    return Multimaps.transformValues(delegate, Functions.<Integer>identity()).asMap();
  }

import okio.Buffer
import okio.ForwardingSink
import okio.Sink

/** A sink that never throws IOExceptions, even if the underlying sink does. */
internal open class FaultHidingSink(
  delegate: Sink,
  val onException: (IOException) -> Unit,
) : ForwardingSink(delegate) {
  private var hasErrors = false

  override fun write(
    source: Buffer,
    byteCount: Long,
  ) {
    if (hasErrors) {
      source.skip(byteCount)

            }
          }

          private void mutateDelegate() {
            allStates.add(ImmutableList.copyOf(delegate));
            remainingActions.next().perform(delegate);
            allStates.add(ImmutableList.copyOf(delegate));
          }
        };

    @SuppressWarnings("unchecked")
    ConcurrentlyMutatedList<Integer> list =

    c = c.superclass
  }

  // Didn't find the field we wanted. As a last gasp attempt,
  // try to find the value on a delegate.
  if (fieldName != "delegate") {
    val delegate = readFieldOrNull(instance, Any::class.java, "delegate")
    if (delegate != null) return readFieldOrNull(delegate, fieldType, fieldName)
  }

  return null
}

@JvmField

class DirFileEntryAdapterIterator extends FileEntryAdapterIterator {

    /**
     * @param parent
     * @param delegate
     * @param filter
     */
    public DirFileEntryAdapterIterator(final SmbResource parent, final CloseableIterator<FileEntry> delegate, final ResourceFilter filter) {
        super(parent, delegate, filter);
    }

    /**
     * @param fe
     * @return
     * @throws MalformedURLException
     */

   */
  private inner class TaskFakerBlockingQueue<T>(
    val delegate: BlockingQueue<T>,
  ) : AbstractQueue<T>(),
    BlockingQueue<T> {
    override val size: Int = delegate.size

    private var editCount = 0

    override fun poll(): T = delegate.poll()

    override fun poll(
      timeout: Long,
      unit: TimeUnit,
    ): T? {

    /** Interval between requests in milliseconds */
    protected long requestInterval = 500;

    /**
     * Sends a list of documents to the search engine for indexing.
     * This method handles thumbnail processing, deletes old documents with the same URL,
     * and performs bulk indexing operations with proper error handling.
     *
     * @param searchEngineClient the search engine client to use for indexing

      checkNotNull(collection);
      throw new IllegalArgumentException("Key does not satisfy predicate: " + key);
    }

    @Override
    protected Set<V> delegate() {
      return emptySet();
    }
  }

  private static final class AddRejectingList<
          K extends @Nullable Object, V extends @Nullable Object>
      extends ForwardingList<V> {

      checkNotNull(collection);
      throw new IllegalArgumentException("Key does not satisfy predicate: " + key);
    }

    @Override
    protected Set<V> delegate() {
      return emptySet();
    }
  }

  private static final class AddRejectingList<
          K extends @Nullable Object, V extends @Nullable Object>
      extends ForwardingList<V> {