def renderHeaders()

in http-core/src/main/scala/org/apache/pekko/http/impl/engine/http2/HttpMessageRendering.scala [139:210]
58 lines of code
33 McCabe index (conditional complexity)

  def renderHeaders(
      headersSeq: immutable.Seq[HttpHeader],
      headerPairs: VectorBuilder[(String, String)],
      peerIdHeader: Option[(String, String)],
      log: LoggingAdapter,
      isServer: Boolean,
      shouldRenderAutoHeaders: Boolean,
      dateHeaderRendering: DateHeaderRendering): Unit = {
    def suppressionWarning(h: HttpHeader, msg: String): Unit =
      log.warning("Explicitly set HTTP header '{}' is ignored, {}", h, msg)

    val it = headersSeq.iterator
    var peerIdSeen, dateSeen = false
    def addHeader(h: HttpHeader): Unit = headerPairs += h.lowercaseName -> h.value

    while (it.hasNext) {
      import pekko.http.scaladsl.model.headers._
      val header = it.next()
      if ((header.renderInResponses && isServer) || (header.renderInRequests && !isServer)) {
        header match {
          case x: Server if isServer =>
            addHeader(x)
            peerIdSeen = true

          case x: `User-Agent` if !isServer =>
            addHeader(x)
            peerIdSeen = true

          case x: Date if isServer =>
            addHeader(x)
            dateSeen = true

          case x: CustomHeader =>
            addHeader(x)

          case x: RawHeader
              if (x.is("content-type")) || (x.is("content-length")) || (x.is("transfer-encoding")) ||
              (x.is("date")) || (x.is("server")) || (x.is("user-agent")) || (x.is("connection")) =>
            suppressionWarning(x, "illegal RawHeader")

          case x: `Content-Length` =>
            suppressionWarning(x,
              "explicit `Content-Length` header is not allowed. Use the appropriate HttpEntity subtype.")

          case x: `Content-Type` =>
            suppressionWarning(x,
              "explicit `Content-Type` header is not allowed. Set `HttpResponse.entity.contentType` instead.")

          case x: `Transfer-Encoding` =>
            suppressionWarning(x, "`Transfer-Encoding` header is not allowed for HTTP/2")

          case x: Connection =>
            suppressionWarning(x, "`Connection` header is not allowed for HTTP/2")

          case x =>
            addHeader(x)
        }
      }
    }

    if (shouldRenderAutoHeaders && !dateSeen && isServer) {
      headerPairs += dateHeaderRendering.renderHeaderPair()
    }

    if (shouldRenderAutoHeaders && !peerIdSeen) {
      peerIdHeader match {
        case Some(peerIdTuple) => headerPairs += peerIdTuple
        case None              =>
      }
    }

  }