///

### Fonctions de chemin

Quand vous déclarez une *fonction de chemin* avec un `def` normal et non `async def`, elle est exécutée dans un groupe de threads (threadpool) externe qui est ensuite attendu, plutôt que d'être appelée directement (car cela bloquerait le serveur).

Mais vous pouvez retourner une `JSONResponse` directement à partir de vos *opérations de chemin*.

Cela peut être utile, par exemple, pour retourner des en-têtes personnalisés ou des cookies.

## Renvoyer une `Response`

En fait, vous pouvez retourner n'importe quelle `Response` ou n'importe quelle sous-classe de celle-ci.

labels.file_crawling_configuration=Exploration de fichiers
labels.file_crawling_title_details=Configuration de l'exploration de fichiers
labels.included_paths=Chemins inclus
labels.excluded_paths=Chemins exclus
labels.included_doc_paths=Chemins de documents inclus
labels.excluded_doc_paths=Chemins de documents exclus
labels.config_parameter=Paramètres de configuration
labels.max_access_count=Nombre d'accès maximum

* Les deux _chemins_ acceptent des opérations `GET` (également connu sous le nom de _méthodes_ HTTP).
* Le _chemin_ `/items/{item_id}` a un  _<abbr title="en anglais : path parameter">paramètre</abbr>_ `item_id` qui doit être un `int`.
* Le _chemin_ `/items/{item_id}` a un _<abbr title="en anglais : query param">paramètre de requête</abbr>_ optionnel `q` de type `str`.

### Documentation API interactive

Traditionelles Bogenschießen mit englischen Langbögen. Wir erhalten eine kurze Einführung in die Geschichte des
traditionellen Bogenschießens und Technik sowie sicherheitsrelevante Themen. Das Bogenschießen wird in Kleingruppen
durchgeführt.
Workshop Nr. 3:
Neben einer kleinen Einführung in die Geschichte und Chemie der Naturkosmetik steht Selbermachen auf dem Programm.
Im Grundkurs erlernen Sie die Herstellung von einfachen Hautcremes. In Kleingruppen erarbeiten Sie selbständig ein

  /**
   * Returns a cleaned chain for [chain].
   *
   * This method throws if the complete chain to a trusted CA certificate cannot be constructed.
   * This is unexpected unless the trust root index in this class has a different trust manager than
   * what was used to establish [chain].
   */
  @Throws(SSLPeerUnverifiedException::class)
  override fun clean(
    chain: List<Certificate>,
    hostname: String,

class LoggingInterceptor implements Interceptor {
  @Override public Response intercept(Interceptor.Chain chain) throws IOException {
    Request request = chain.request();

    long t1 = System.nanoTime();
    logger.info(String.format("Sending request %s on %s%n%s",
        request.url(), chain.connection(), request.headers()));

    Response response = chain.proceed(request);

    long t2 = System.nanoTime();

     *     chain.proceed(chain.request())
     * }
     * ```
     */
    inline operator fun invoke(crossinline block: (chain: Chain) -> Response): Interceptor = Interceptor { block(it) }
  }

  interface Chain {
    fun request(): Request

    @Throws(IOException::class)
    fun proceed(request: Request): Response

    /**

  fun networkInterceptorsCannotCallProceedMultipleTimes() {
    server.enqueue(MockResponse())
    server.enqueue(MockResponse())
    val interceptor =
      Interceptor { chain: Interceptor.Chain ->
        chain.proceed(chain.request())
        chain.proceed(chain.request())
      }
    client =
      client
        .newBuilder()
        .addNetworkInterceptor(interceptor)
        .build()
    val request =

        FilterChain chain = createDefaultFilterChain();
        for (final Filter element : filterList) {
            chain = appendFilterChain(element, chain);
        }
        filterChain = chain;
    }

    /**
     * Appends a filter to an existing filter chain.
     *
     * @param filter the filter to append
     * @param chain the existing filter chain to append to