// https://datatracker.ietf.org/doc/html/rfc7231#page-47
//
// From https://github.com/apache/httpcomponents-core/blob/master/httpcore5/src/main/java/org/apache/hc/core5/http/HttpStatus.java

/** `100 Continue` (HTTP/1.1 - RFC 7231)  */
const val HTTP_CONTINUE = 100

/** `102 Processing` (WebDAV - RFC 2518)  */
const val HTTP_PROCESSING = 102

/** `103 Early Hints (Early Hints - RFC 8297)` */
const val HTTP_EARLY_HINTS = 103

  // The continue option should be set when retrieving more results from the server. Since this value is
  // server defined, clients may only use the continue value from a previous query result with identical
  // query parameters (except for the value of continue) and the server may reject a continue value it
  // does not recognize. If the specified continue value is no longer valid whether due to expiration

                val result = mutableListOf<ClassId>()
                for (annotation in fe10Annotations) {
                    val classId = annotation.classIdForAnnotation ?: continue
                    if (classId in annotationsToIgnore) continue
                    result += classId
                }

                return result
            }
        }

        for (tool in tools) {
            for (declaration in getDeclarationsByProvider(tool.declarationProvider)) {
                val declarationName = declaration.nameAsName ?: continue
                if (!nameFilter(declarationName)) continue
                with(analysisSession) {
                    yield(declaration.getSymbol() as S)
                }
            }
        }
    }

      val result = mutableListOf<String>()
      for (subjectAltName in subjectAltNames) {
        if (subjectAltName == null || subjectAltName.size < 2) continue
        if (subjectAltName[0] != type) continue
        val altName = subjectAltName[1] ?: continue
        result.add(altName as String)
      }
      return result
    } catch (_: CertificateParsingException) {
      return emptyList()
    }
  }

            else -> {
              connectionUser.acquireConnectionNoEvents(connection)
              true
            }
          }
        }
      if (!acquired) continue

      // Confirm the connection is healthy and return it.
      if (connection.isHealthy(doExtensiveHealthChecks)) return connection

            pluginPortalUrlOverride,
            "-s",
            "--no-configuration-cache",
            "%additional.gradle.parameters%",
            "--daemon",
            "--continue",
            "\"-Dscan.tag.PerformanceTest\""
        )

        assertEquals(
            (
                listOf(
                    "clean",

        val value = cachedHeaders.value(index)
        if ("Warning".equals(fieldName, ignoreCase = true) && value.startsWith("1")) {
          // Drop 100-level freshness warnings.
          continue
        }
        if (isContentSpecificHeader(fieldName) ||
          !isEndToEnd(fieldName) ||
          networkHeaders[fieldName] == null
        ) {
          result.addLenient(fieldName, value)
        }

      val equalsSign = header.delimiterOffset('=', pos, pairEnd)
      val name = header.trimSubstring(pos, equalsSign)
      if (name.startsWith("$")) {
        pos = pairEnd + 1
        continue
      }

      // We have either name=value or just a name.
      var value =
        if (equalsSign < pairEnd) {
          header.trimSubstring(equalsSign + 1, pairEnd)
        } else {
          ""

  * Not all "remote" repositories will fail. Specifically, if the remote
    repo uses the file:// protocol, and it doesn't refer to a shared
    filesystem, it will continue to be available.

  The question remaining is: Which level of offline mode will we support? It
  seems reasonable to assume that users will be able to tell when localhost is