// If the object ETag matches with the specified ETag.
			writeHeaders()
			writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrPreconditionFailed), r.URL)
			return true
		}
	}

	etagMatch := opts.PreserveETag != "" && isETagEqual(objInfo.ETag, opts.PreserveETag)
	vidMatch := opts.VersionID != "" && opts.VersionID == objInfo.VersionID
	if etagMatch && vidMatch {
		writeHeaders()

  }

  @Test
  fun staticTableIndexedHeaders() {
    hpackWriter!!.writeHeaders(headerEntries(":method", "GET"))
    assertBytes(0x82)
    assertThat(hpackWriter!!.headerCount).isEqualTo(0)
    hpackWriter!!.writeHeaders(headerEntries(":method", "POST"))
    assertBytes(0x83)
    assertThat(hpackWriter!!.headerCount).isEqualTo(0)
    hpackWriter!!.writeHeaders(headerEntries(":path", "/"))
    assertBytes(0x84)

        response.setContentType(buf.toString());
        writeHeaders(response);
        try (PrintWriter out = new PrintWriter(new OutputStreamWriter(response.getOutputStream(), enc))) {
            out.print(text);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    protected abstract void writeHeaders(final HttpServletResponse response);

            try (ServletOutputStream out = response.getOutputStream(); InputStream in = curlResponse.getContentAsStream()) {
                response.setStatus(curlResponse.getHttpStatusCode());
                writeHeaders(response);
                CopyUtil.copy(in, out);
            } catch (final ClientAbortException e) {
                logger.debug("Client aborts this request.", e);
            }

    path: String,
  ) {
    val responseHeaders =
      listOf(
        Header(":status", "404"),
        Header(":version", "HTTP/1.1"),
        Header("content-type", "text/plain"),
      )
    stream.writeHeaders(
      responseHeaders = responseHeaders,
      outFinished = false,
      flushHeaders = false,
    )
    val out = stream.getSink().buffer()
    out.writeUtf8("Not found: $path")
    out.close()
  }

    assumeFalse(
      story === Story.MISSING,
      "Test stories missing, checkout git submodule",
    )

    val newCases = mutableListOf<Case>()
    for (case in story.cases) {
      hpackWriter.writeHeaders(case.headersList)
      newCases += case.copy(wire = bytesOut.readByteString())
    }

    testDecoder(story.copy(cases = newCases))
  }

  companion object {
    private val RAW_DATA = arrayOf("raw-data")

	Data         []byte            `json:"data,omitempty" msg:",omitempty"` // Data can container full data of the object or partial
}

// WriteHeaders writes the response headers for conditional requests
func (oi ObjectInfo) WriteHeaders(w http.ResponseWriter, preamble, statusCode func()) {
	preamble()

	if !oi.ModTime.IsZero() {
		w.Header().Set(xhttp.LastModified, oi.ModTime.UTC().Format(http.TimeFormat))
	}

	// ... otherwise we return the <BLOB> place holder
	return blobBody
}

// WriteHeader - writes http status code
func (lrw *ResponseRecorder) WriteHeader(code int) {
	if !lrw.headersLogged {
		lrw.StatusCode = code
		lrw.writeHeaders(&lrw.headers, code, lrw.ResponseWriter.Header())
		lrw.headersLogged = true
		lrw.ResponseWriter.WriteHeader(code)
	}
}

// Flush - Calls the underlying Flush.

   * @param flushHeaders true to force flush the response headers. This should be true unless the
   *     response body exists and will be written immediately.
   */
  @Throws(IOException::class)
  fun writeHeaders(
    responseHeaders: List<Header>,
    outFinished: Boolean,
    flushHeaders: Boolean,
  ) {
    lock.assertNotHeld()

    var flushHeaders = flushHeaders
    this.withLock {

    body.writeTo(responseBodySink)
    responseBodySink.emit()

    if ("chunked".equals(response.headers["Transfer-Encoding"], ignoreCase = true)) {
      writeHeaders(sink, response.trailers)
    }
  }

  @Throws(IOException::class)
  private fun writeHeaders(
    sink: BufferedSink,
    headers: Headers,
  ) {
    for ((name, value) in headers) {
      sink.writeUtf8(name)
      sink.writeUtf8(": ")