setupEpg(_epgMap, et -> ((RequestHeader) et).getUpdatedBy(), (et, vl) -> ((RequestHeader) et).setUpdatedBy(DfTypeUtil.toString(vl)),
                "updatedBy");
        setupEpg(_epgMap, et -> ((RequestHeader) et).getUpdatedTime(),
                (et, vl) -> ((RequestHeader) et).setUpdatedTime(DfTypeUtil.toLong(vl)), "updatedTime");

		</postConstruct>
		<postConstruct name="addIndexConfig">
			<arg>"fess_config.related_query/related_query"</arg>
		</postConstruct>
		<postConstruct name="addIndexConfig">
			<arg>"fess_config.request_header/request_header"</arg>
		</postConstruct>
		<postConstruct name="addIndexConfig">
			<arg>"fess_config.role_type/role_type"</arg>
		</postConstruct>
		<postConstruct name="addIndexConfig">

        // request header
        final List<RequestHeader> requestHeaderList = requestHeaderService.getRequestHeaderList(getId());
        final List<org.codelibs.fess.crawler.client.http.RequestHeader> rhList = new ArrayList<>();
        for (final RequestHeader requestHeader : requestHeaderList) {
            rhList.add(requestHeader.getCrawlerRequestHeader());
        }

     */
    public static OptionalEntity<RequestHeader> getEntity(final CreateForm form, final String username, final long currentTime) {
        switch (form.crudMode) {
        case CrudMode.CREATE:
            return OptionalEntity.of(new RequestHeader()).map(entity -> {
                entity.setCreatedBy(username);
                entity.setCreatedTime(currentTime);

   *     Corresponds to `FLAG_FIN`.
   */
  @Throws(IOException::class)
  fun newStream(
    requestHeaders: List<Header>,
    out: Boolean,
  ): Http2Stream = newStream(0, requestHeaders, out)

  @Throws(IOException::class)
  private fun newStream(
    associatedStreamId: Int,
    requestHeaders: List<Header>,
    out: Boolean,
  ): Http2Stream {
    val outFinished = !out
    val inFinished = false

      val requestHeaders = networkResponse!!.request.headers
      val responseHeaders = headers
      return varyHeaders(requestHeaders, responseHeaders)
    }

    /**
     * Returns the subset of the headers in [requestHeaders] that impact the content of the
     * response's body.
     */
    private fun varyHeaders(
      requestHeaders: Headers,
      responseHeaders: Headers,

            count++;
            headerName = paramMap.get(CRAWLER_WEB_HEADER_PREFIX + count + ".name");
        }
        if (!rhList.isEmpty()) {
            factoryParamMap.put(HcHttpClient.REQUEST_HEADERS_PROPERTY,
                    rhList.toArray(new org.codelibs.fess.crawler.client.http.RequestHeader[rhList.size()]));
        }

   * @param requestHeaders minimally includes `:method`, `:scheme`, `:authority`, and `:path`.
   */
  @Throws(IOException::class)
  fun pushPromise(
    streamId: Int,
    promisedStreamId: Int,
    requestHeaders: List<Header>,
  ) {
    withLock {
      if (closed) throw IOException("closed")
      hpackWriter.writeHeaders(requestHeaders)

      val byteCount = hpackBuffer.size

  "requestID": "17CDC1F4D7E69123",
  "userAgent": "MinIO (linux; amd64) minio-go/v7.0.70 mc/RELEASE.2024-04-30T17-44-48Z",
  "requestPath": "/testbucket/hosts",
  "requestHost": "localhost:9000",
  "requestHeader": {
    "Accept-Encoding": "zstd,gzip",

        override fun pushPromise(
          streamId: Int,
          promisedStreamId: Int,
          requestHeaders: List<Header>,
        ) {
          assertThat(streamId).isEqualTo(expectedStreamId)
          assertThat(promisedStreamId).isEqualTo(expectedPromisedStreamId)
          assertThat(requestHeaders).isEqualTo(pushPromise)
        }
      },
    )
  }

  /** Headers are compressed, then framed.  */