*/
public interface BufferCache {

    /**
     * Gets a buffer from the cache or creates a new one if the cache is empty.
     *
     * @return a buffer from the cache, or a new one
     */
    byte[] getBuffer();

    /**
     * Return a buffer to the cache
     *
     * @param buf the buffer to return to the cache for reuse
     */
    void releaseBuffer(byte[] buf);

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;

/**
 * This class provides a skeletal implementation of the {@code Cache} interface to minimize the
 * effort required to implement this interface.
 *
 * <p>To implement a cache, the programmer needs only to extend this class and provide an
 * implementation for the {@link #get(Object)} and {@link #getIfPresent} methods. {@link

 */

package com.google.common.cache;

import static com.google.common.cache.CacheBuilder.NULL_TICKER;
import static com.google.common.cache.LocalCache.DISCARDING_QUEUE;
import static com.google.common.cache.LocalCache.DRAIN_THRESHOLD;
import static com.google.common.cache.LocalCache.nullEntry;
import static com.google.common.cache.LocalCache.unset;
import static com.google.common.cache.TestingCacheLoaders.identityLoader;

### Armazenar em cache o esquema OpenAPI { #cache-the-openapi-schema }

Você pode usar a propriedade `.openapi_schema` como um "cache" para armazenar o esquema gerado.

Dessa forma, sua aplicação não precisará gerar o esquema toda vez que um usuário abrir a documentação da sua API.

Ele será gerado apenas uma vez, e o mesmo esquema armazenado em cache será utilizado nas próximas requisições.

    bus = new AsyncEventBus(executor);
  }

  public void testBasicDistribution() {
    StringCatcher catcher = new StringCatcher();
    bus.register(catcher);

    // We post the event, but our Executor will not deliver it until instructed.
    bus.post(EVENT);

    List<String> events = catcher.getEvents();
    assertTrue("No events should be delivered synchronously.", events.isEmpty());

    /**
     * Returns the [Cache] for the OkHttpClient, or an override from the Call.Chain.
     */
    val cache: Cache?

    /**
     * Override the [Cache] for the Call.Chain.
     *
     * @throws IllegalStateException if this is a Network Interceptor, since the override is too late.
     */
    fun withCache(cache: Cache?): Chain

    /**

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.cache;

import com.google.common.cache.AbstractCache.StatsCounter;
import com.google.common.cache.LocalCache.Timestamped;
import java.util.LinkedHashMap;
import org.jspecify.annotations.Nullable;

/**

 */
package okhttp3.recipes.kt

import java.io.File
import java.io.IOException
import okhttp3.Cache
import okhttp3.OkHttpClient
import okhttp3.Request

class CacheResponse(
  cacheDirectory: File,
) {
  private val client: OkHttpClient =
    OkHttpClient
      .Builder()
      .cache(
        Cache(
          directory = cacheDirectory,
          // 1 MiB.
          maxSize = 10L * 1024L * 1024L,

    bytesIn.writeByte(0x58) // == Literal indexed ==
    // Indexed name (idx = 24) -> cache-control
    bytesIn.writeByte(0x08) // Literal value (len = 8)
    bytesIn.writeUtf8("no-cache")
  }

  private fun checkReadSecondRequestWithoutHuffman() {
    assertThat(hpackReader!!.headerCount).isEqualTo(2)

    // [  1] (s =  53) cache-control: no-cache
    var entry = hpackReader!!.dynamicTable[readerHeaderTableLength() - 2]!!

                String key = "key-" + i;
                entry.setKey(key);
                entry.setCacheMap(cache);
                entry.replaceCache();
            }

            // Verify all entries
            assertEquals(10, cache.size());
            for (int i = 0; i < 10; i++) {
                assertNotNull(cache.get("key-" + i));
            }

            // Replace some entries