inline fun <reified T : CallEvent> removeUpToEvent(): T = removeUpToEvent(T::class.java)

  inline fun <reified T : CallEvent> findEvent(): T = eventSequence.first { it is T } as T

  /**
   * Remove and return the next event from the recorded sequence.
   *
   * @param eventClass a class to assert that the returned event is an instance of, or null to
   *     take any event class.

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

That way, your application won't have to generate the schema every time a user opens your API docs.

It will be generated only once, and then the same cached schema will be used for the next requests.

{* ../../docs_src/extending_openapi/tutorial001_py39.py hl[13:14,25:26] *}

### Override the method { #override-the-method }

Now you can replace the `.openapi()` method with your new function.

                provides.entrySet().iterator();
        while (providesIter.hasNext()) {
            Map.Entry<String, RequirementMatcher> provideEntry = providesIter.next();
            builder.append(provideEntry.getKey()).append(" = ").append(provideEntry.getValue());
            if (providesIter.hasNext()) {
                builder.append(';');
            }
        }

And that function takes parameters in the same way that *path operation functions* do.

/// tip

You'll see what other "things", apart from functions, can be used as dependencies in the next chapter.

///

Whenever a new request arrives, **FastAPI** will take care of:

* Calling your dependency ("dependable") function with the correct parameters.
* Get the result from your function.

    URL url = getClass().getResource(resourceName);
    for (String line : Resources.readLines(url, UTF_8)) {
      Iterator<String> iterator = splitter.split(line).iterator();
      String input = iterator.next();
      String expectedOutput = iterator.next();
      assertFalse(iterator.hasNext());
      assertEquals(expectedOutput, simplifyPath(input));
    }
  }

    // ...and then putIfAbsent. Simulate failure on both
    when(backingMap.putIfAbsent(eq(KEY), isA(AtomicInteger.class))).thenReturn(existing);

    // next map.get()
    when(backingMap.get(KEY)).thenReturn(existingZero);
    // since get returned zero, try a replace; that fails due to a simulated race

   *     iterator().next()} or {@link Iterables#getFirst} instead.
   */
  @SuppressWarnings("nullness") // Unsafe, but we can't do much about it now.
  public final Optional<@NonNull E> first() {
    Iterator<E> iterator = getDelegate().iterator();
    return iterator.hasNext() ? Optional.of(iterator.next()) : Optional.absent();
  }

  /**

            }
        }
    }

    /**
     * Polls the next URL queue entry for the specified session.
     * This method manages local caches and fetches from OpenSearch when needed.
     *
     * @param sessionId The session ID.
     * @return The next URL queue entry, or null if none available.
     */
    @Override

    }
  }

  override fun onMessage(
    webSocket: WebSocket,
    text: String,
  ) {
    Platform.get().log("[WS $name] onMessage", Platform.INFO, null)
    val delegate = delegate
    if (delegate != null) {
      this.delegate = null
      delegate.onMessage(webSocket, text)
    } else {
      events.add(Message(string = text))
    }
  }

  override fun onClosing(
    webSocket: WebSocket,