*
 * <p>This class can't depend on other Guava code. If we were to load this class in the same class
 * loader as the rest of Guava, this thread would keep an indirect strong reference to the class
 * loader and prevent it from being garbage collected. This poses a problem for environments where

In this case the middleware will intercept the incoming request and respond with appropriate CORS headers, and either a `200` or `400` response for informational purposes.

### Simple requests { #simple-requests }

Any request with an `Origin` header. In this case the middleware will pass the request through as normal, but will include appropriate CORS headers on the response.

    /**
     * Retrieves a specific request header by its ID.
     *
     * @param id the unique identifier of the request header
     * @return an OptionalEntity containing the request header if found, empty otherwise
     */
    public OptionalEntity<RequestHeader> getRequestHeader(final String id) {
        return requestHeaderBhv.selectByPK(id);
    }

    /**
     * Stores a request header configuration to the database.

pkg compress/gzip, type Header struct
pkg compress/gzip, type Header struct, Comment string
pkg compress/gzip, type Header struct, Extra []uint8
pkg compress/gzip, type Header struct, ModTime time.Time
pkg compress/gzip, type Header struct, Name string
pkg compress/gzip, type Header struct, OS uint8
pkg compress/gzip, type Reader struct
pkg compress/gzip, type Reader struct, embedded Header
pkg compress/gzip, type Writer struct

	return *resp, nil
}

// where we keep old *Readers
var readMsgpReaderPool = bpool.Pool[*msgp.Reader]{New: func() *msgp.Reader { return &msgp.Reader{} }}

// mspNewReader returns a *Reader that reads from the provided reader.
// The reader will be buffered.
// Return with readMsgpReaderPoolPut when done.
func msgpNewReader(r io.Reader) *msgp.Reader {
	p := readMsgpReaderPool.Get()
	if p.R == nil {

  public static <K, V> CacheLoader<K, V> asyncReloading(
      CacheLoader<K, V> loader, Executor executor) {
    checkNotNull(loader);
    checkNotNull(executor);
    return new CacheLoader<K, V>() {
      @Override
      public V load(K key) throws Exception {
        return loader.load(key);
      }

      @Override
      public ListenableFuture<V> reload(K key, V oldValue) {

                                <%-- Card Header --%>
                            <div class="card-header">
                                <jsp:include page="/WEB-INF/view/common/admin/crud/header.jsp"></jsp:include>
                            </div>
                                <%-- Card Body --%>

    }

    @Nonnull
    default T read(@Nonnull Reader reader) throws XmlReaderException {
        return read(reader, true);
    }

    @Nonnull
    default T read(@Nonnull Reader reader, boolean strict) throws XmlReaderException {
        return read(XmlReaderRequest.builder().reader(reader).strict(strict).build());
    }

    @Nonnull

        // of
        // InputStream.read(byte[], int, int)
        // See https://github.com/google/guava/issues/3542
        Reader reader = new StringReader(cannotDecode);
        InputStream decodingStream = encoding.decodingStream(reader);
        try {
          ByteStreams.exhaust(decodingStream);
          fail("Expected DecodingException");
        } catch (DecodingException expected) {

   * {@linkplain Thread#getContextClassLoader() context class loader}. In simple environments, the
   * context class loader will find resources from the class path. In environments where different
   * threads can have different class loaders, for example app servers, the context class loader
   * will typically have been set to an appropriate loader for the current thread.
   *