private fun Buffer.skipCommasAndWhitespace(): Boolean {
  var commaFound = false
  loop@ while (!exhausted()) {
    when (this[0]) {
      ','.code.toByte() -> {
        // Consume ','.
        readByte()
        commaFound = true
      }

      ' '.code.toByte(), '\t'.code.toByte() -> {
        readByte()
        // Consume space or tab.
      }

      else -> {
        break@loop
      }
    }
  }

internal const val TYPE_VALID = 6

private fun BufferedSource.skipWhitespace() {
  while (!exhausted()) {
    if (buffer[0] != ' '.code.toByte()) return
    skip(1L)
  }
}

private fun BufferedSource.skipRestOfLine() {
  when (val newline = indexOf('\n'.code.toByte())) {
    -1L -> skip(buffer.size)

    // Exhaust this source.
    else -> skip(newline + 1)
  }
}

/**

      throw ProtocolException("constructed strings not supported for DER")
    }
    return source.readUtf8(bytesLeft)
  }

  fun readObjectIdentifier(): String {
    val result = Buffer()
    val dot = '.'.code.toByte().toInt()
    when (val xy = readVariableLengthLong()) {
      in 0L until 40L -> {
        result.writeDecimalLong(0)
        result.writeByte(dot)
        result.writeDecimalLong(xy)
      }

   * malformed.
   */
  @Throws(IOException::class)
  fun checkLowercase(name: ByteString): ByteString {
    for (i in 0 until name.size) {
      if (name[i] in 'A'.code.toByte()..'Z'.code.toByte()) {
        throw IOException("PROTOCOL_ERROR response malformed: mixed case name: ${name.utf8()}")
      }
    }
    return name
  }

    v1Creator.commit()

    cache["k1"]!!.use { snapshot1 ->
      val inV1 = snapshot1.getSource(0).buffer()
      assertThat(inV1.readByte()).isEqualTo('A'.code.toByte())
      assertThat(inV1.readByte()).isEqualTo('A'.code.toByte())

      val v1Updater = cache.edit("k1")!!
      v1Updater.setString(0, "CCcc")
      v1Updater.setString(1, "DDdd")
      v1Updater.commit()

    val source = response.body.source()
    source.timeout().timeout(1000, TimeUnit.MILLISECONDS)
    assertThat(source.readByte()).isEqualTo('A'.code.toByte())
    assertThat(source.readByte()).isEqualTo('B'.code.toByte())
    assertThat(source.readByte()).isEqualTo('C'.code.toByte())
    assertFailsWith<SocketTimeoutException> {
      source.readByte() // If Content-Length was accurate, this would return -1 immediately.
    }

    val request = Request.Builder().url(server.url("/b")).build()
    val response = client.newCall(request).execute()
    val bodySource = response.body.source()
    assertThat(bodySource.readByte()).isEqualTo('d'.code.toByte())

    // The second byte of this request will be delayed by 750ms so we should time out after 250ms.
    val startNanos = System.nanoTime()
    bodySource.use {
      assertFailsWith<IOException> {

Mais vous pouvez avoir des milliers d'endpoints (*chemins d'accès*) utilisant le même système de sécurité.

Et tous (ou seulement une partie d'entre eux, si vous le souhaitez) peuvent profiter de la réutilisation de ces dépendances ou de toute autre dépendance que vous créez.

///

## `HTTPSRedirectMiddleware` { #httpsredirectmiddleware }

Impose que toutes les requêtes entrantes soient soit `https`, soit `wss`.

Toute requête entrante en `http` ou `ws` sera redirigée vers le schéma sécurisé correspondant.

{* ../../docs_src/advanced_middleware/tutorial001_py310.py hl[2,6] *}

## `TrustedHostMiddleware` { #trustedhostmiddleware }

Cela signifie que **toute valeur** lue en Python à partir d'une variable d'environnement **sera une `str`**, et que toute conversion vers un autre type ou toute validation doit être effectuée dans le code.