private final ListenerCallQueue<Listener> listeners = new ListenerCallQueue<>();

  /**
   * The current state of the service. This should be written with the lock held but can be read
   * without it because it is an immutable object in a volatile field. This is desirable so that
   * methods like {@link #state}, {@link #failureCause} and notably {@link #toString} can be run
   * without grabbing the lock.

      fileSystem = fileSystem,
      directory = directory,
      appVersion = VERSION,
      valueCount = ENTRY_COUNT,
      maxSize = maxSize,
      taskRunner = taskRunner,
    )

  // read and write statistics, all guarded by 'this'.
  internal var writeSuccessCount = 0
  internal var writeAbortCount = 0
  private var networkCount = 0
  private var hitCount = 0
  private var requestCount = 0

Requests come from the client specifically asking for a set of resources. This could be requesting the initial set of resources on a new connection, or from a new dependency. For example, a push of `Cluster X` referencing `Endpoint Y` may lead to a request for `Endpoint Y` if it is not already known to the client.

    ticker.advance(1);
    segment.recordRead(entry, ticker.read());
    segment.expireEntries(ticker.read());
    assertTrue(map.containsKey(key));
    assertSame(entry, segment.accessQueue.peek());
    assertEquals(1, segment.accessQueue.size());

    ticker.advance(1);
    segment.recordRead(entry, ticker.read());
    segment.expireEntries(ticker.read());
    assertTrue(map.containsKey(key));

    ticker.advance(1);
    segment.recordRead(entry, ticker.read());
    segment.expireEntries(ticker.read());
    assertTrue(map.containsKey(key));
    assertSame(entry, segment.accessQueue.peek());
    assertEquals(1, segment.accessQueue.size());

    ticker.advance(1);
    segment.recordRead(entry, ticker.read());
    segment.expireEntries(ticker.read());
    assertTrue(map.containsKey(key));

    val buffer = Buffer()
    operator.read(6, buffer, 21)
    operator.read(36, buffer, 1)
    operator.read(5, buffer, 5)
    operator.read(28, buffer, 8)
    operator.read(17, buffer, 10)
    operator.read(36, buffer, 2)
    operator.read(2, buffer, 4)
    operator.write(0, buffer, buffer.size)
    operator.read(0, buffer, 12)
    operator.read(47, buffer, 3)
    operator.read(45, buffer, 2)
    operator.read(47, buffer, 3)

    assertEquals(0, ticker.read());
    assertEquals(10, ticker.read());
    assertEquals(20, ticker.read());
  }

  public void testAutoIncrementStep_millis() {
    FakeTicker ticker = new FakeTicker().setAutoIncrementStep(1, MILLISECONDS);
    assertEquals(0, ticker.read());
    assertEquals(1000000, ticker.read());
    assertEquals(2000000, ticker.read());
  }

        return super.read(reader);
    }

    @Override
    public Model read(InputStream in, boolean strict, InputSource source) throws IOException, XmlPullParserException {
        return super.read(in, strict, source);
    }

    @Override
    public Model read(InputStream in, boolean strict) throws IOException, XmlPullParserException {
        return super.read(in, strict);
    }

    @Override

     */
    public Metadata read(Reader reader) throws IOException, XmlPullParserException {
        try {
            return new Metadata(delegate.read(reader));
        } catch (XMLStreamException e) {
            throw new XmlPullParserException(e.getMessage(), null, e);
        }
    }

    /**
     * Method read.
     *
     * @param in     a in object.
     * @param strict a strict object.

      }

      val read = super.read(sink, minOf(byteCount, bytesRemainingInChunk))
      if (read == -1L) {
        carrier.noNewExchanges() // The server didn't supply the promised chunk length.
        val e = ProtocolException("unexpected end of stream")
        responseBodyComplete()
        throw e
      }
      bytesRemainingInChunk -= read
      return read
    }