* stored bytes exceeds the limit, the cache will remove entries in the background until the limit
 * is satisfied. The limit is not strict: the cache may temporarily exceed it while waiting for
 * files to be deleted. The limit does not include filesystem overhead or the cache journal so
 * space-sensitive applications should set a conservative limit.
 *

        lock = new Object();
    }

    @Override
    public int read() throws IOException {
        int result = -1;

        synchronized (lock) {
            try {
                while (used == 0) {
                    lock.wait();
                }
            } catch (final InterruptedException ie) {
                throw new IOException(ie.getMessage());
            }

   * and returns it.
   */
  fun <T : CallEvent> removeUpToEvent(eventClass: Class<T>): T {
    val fullEventSequence = eventSequence.toList()
    try {
      while (true) {
        val event = takeEvent()
        if (eventClass.isInstance(event)) {
          return eventClass.cast(event)
        }
      }
    } catch (e: NoSuchElementException) {

        buffer.append("Progress (").append(transfers.size()).append("): ");

        synchronized (transfers) {
            Iterator<TransferResourceAndSize> entries = transfers.values().iterator();
            while (entries.hasNext()) {
                TransferResourceAndSize entry = entries.next();
                long total = entry.resource.getContentLength();
                long complete = entry.transferredBytes;

   * and returns it.
   */
  fun <T : ConnectionEvent> removeUpToEvent(eventClass: Class<T>): T {
    val fullEventSequence = eventSequence.toList()
    try {
      while (true) {
        val event = takeEvent()
        if (eventClass.isInstance(event)) {
          return eventClass.cast(event)
        }
      }
    } catch (e: NoSuchElementException) {

            final String key = property.getKey();
            final StringBuilder value = new StringBuilder();
            final Iterator<String> values = property.getValue().iterator();
            while (values.hasNext()) {
                value.append(values.next());
                if (values.hasNext()) {
                    value.append(", ");
                }
            }

   * data section was empty. Any number of calls to [Callback.onRetryChange] may occur while
   * processing an event.
   *
   * @return false when EOF is reached
   */
  @Throws(IOException::class)
  fun processNextEvent(): Boolean {
    var id = lastId
    var type: String? = null
    val data = Buffer()

    while (true) {
      when (source.select(options)) {
        in 0..2 -> {

// any for the associated TargetID
type TargetIDResult struct {
	// ID where the remove or send were initiated.
	ID TargetID
	// Stores any error while removing a target or while sending an event.
	Err error
}

// Remove - closes and removes targets by given target IDs.
func (list *TargetList) Remove(targetIDSet TargetIDSet) {
	list.Lock()
	defer list.Unlock()

      }
      List<Element> tmp = new ArrayList<>(elementsInSet);
      shuffle(tmp, random);
      queryList.addAll(tmp.subList(0, extras));
    }

    // now add bad queries
    while (queryList.size() < numQueries) {
      Element candidate = newElement();
      if (!elementsInSet.contains(candidate)) {
        queryList.add(candidate);
      }
    }
    shuffle(queryList, random);

    Interruptenator(Thread interruptee, long everyMillis) {
      this.everyMillis = everyMillis;
      this.interruptee = interruptee;
    }

    @Override
    public void run() {
      while (true) {
        try {
          Thread.sleep(everyMillis);
        } catch (InterruptedException e) {
          // ok. just stop sleeping.
        }
        if (shouldStop) {
          break;
        }