ContentOutputStream cos = new ContentOutputStream(10, Curl.tmpDir);
        cos.write(new byte[] { 0, 1, 2 });
        assertTrue(cos.isInMemory());
        cos.write(new byte[] { 3, 4 });
        assertTrue(cos.isInMemory());
        cos.write(new byte[] { 5 });
        assertTrue(cos.isInMemory());
        assertFalse(cos.done);
        cos.close();
    }

    @Test

     */
    @Override
    public void close() throws IOException {
        try {
            super.close();
        } finally {
            if (!isInMemory() && !done) {
                final File file = super.getFile();
                if (file != null) {
                    try {
                        Files.deleteIfExists(file.toPath());

     */
    public void setReplaceDuplication(final boolean replaceDuplication) {
        this.replaceDuplication = replaceDuplication;
    }

    /**
     * Sets the memory size.
     * @param memorySize The memory size.
     */
    public void setMemorySize(final int memorySize) {
        this.memorySize = memorySize;
    }

    /**
     * Sets the maximum size of an alpha-numeric term.

                }
                dfos.flush();
                final ContentCache contentCache;
                logger.fine(() -> "Response in " + (dfos.isInMemory() ? "Memory" : "File"));
                if (dfos.isInMemory()) {
                    contentCache = new ContentCache(dfos.getData());
                } else {
                    contentCache = new ContentCache(dfos.getFile());
                }

import java.util.logging.Logger;

/**
 * ContentCache is a class that provides a way to cache content either in memory or in a file.
 * It implements the Closeable interface to ensure that resources are properly released.
 *
 * <p>This class supports two types of content caching:
 * <ul>
 *   <li>In-memory caching using a byte array</li>
 *   <li>File-based caching using a File object</li>
 * </ul>
 *

   * value slightly too high than slightly too low. If the value is not exact, the {@link
   * ImmutableLongArray} that is built will very likely occupy more memory than strictly necessary;
   * to trim memory usage, build using {@code builder.build().trimmed()}.
   */
  public static Builder builder(int initialCapacity) {
    checkArgument(initialCapacity >= 0, "Invalid initialCapacity: %s", initialCapacity);

   * value slightly too high than slightly too low. If the value is not exact, the {@link
   * ImmutableIntArray} that is built will very likely occupy more memory than strictly necessary;
   * to trim memory usage, build using {@code builder.build().trimmed()}.
   */
  public static Builder builder(int initialCapacity) {
    checkArgument(initialCapacity >= 0, "Invalid initialCapacity: %s", initialCapacity);

		total:             "Total memory on the node",
		memUsed:           "Used memory on the node",
		memUsedPerc:       "Used memory percentage on the node",
		memFree:           "Free memory on the node",
		memShared:         "Shared memory on the node",
		memBuffers:        "Buffers memory on the node",
		memCache:          "Cache memory on the node",
		memAvailable:      "Available memory on the node",

#   request - Cache only for current request + its child requests
#   none    - Disable caching entirely
#
# REFERENCE OPTIONS:
#   hard - Strong reference (stays in memory, faster access)
#   soft - Weak reference (can be garbage collected under memory pressure)
#
# CONFIGURATION BREAKDOWN:
#   SourceCacheKey                   - File and RAW model requests (session/hard for consistent file access)

/**
 * A pluggable service for processing model objects during model building.
 *
 * <p>This service allows implementations to:</p>
 * <ul>
 *   <li>Pool identical objects to reduce memory footprint</li>
 *   <li>Intern objects for faster equality comparisons</li>
 *   <li>Apply custom optimization strategies</li>
 *   <li>Transform or modify objects during building</li>
 * </ul>
 *