}

      @Override
      int minSize() {
        int difference = minSize(set1) - maxSize(set2);
        return difference >= 0 ? difference : max(minSize(set2) - maxSize(set1), 0);
      }

      @Override
      int maxSize() {
        return saturatedAdd(maxSize(set1), maxSize(set2));
      }
    };
  }

  /**

     * Validates buffer size to prevent overflow
     *
     * @param size the buffer size to validate
     * @param maxSize the maximum allowed size
     * @param fieldName the field name for error reporting
     * @throws IllegalArgumentException if size is invalid
     */
    public static void validateBufferSize(int size, int maxSize, String fieldName) {
        if (size < 0) {

{
    "properties": {
      "term": {
        "type": "keyword"
      },
      "query": {
        "type": "keyword"
      },
      "maxSize": {
        "type": "integer"
      },
      "boost": {
        "type": "float"
      },
      "virtualHost": {
        "type": "keyword"
      },
      "createdBy": {
        "type": "keyword"
      },
      "createdTime": {
        "type": "long"
      },

        }
        return super.sink(file, mustCreate)
      }
    }

  /** The maximum number of bytes that this cache should use to store its data. */
  @get:Synchronized @set:Synchronized
  var maxSize: Long = maxSize
    set(value) {
      field = value
      if (initialized) {
        cleanupQueue.schedule(cleanupTask) // Trim the existing store if necessary.
      }
    }

  /*

        }
    }

    static class TestSubSearcher extends RankFusionSearcher {

        private int mainSize;
        private int inSize;
        private int outSize;

        TestSubSearcher(int mainSize, int inSize, int outSize) {
            this.mainSize = mainSize;
            this.inSize = inSize;
            this.outSize = outSize;
        }

        @Override

  constructor(directory: File, maxSize: Long) : this(
    FileSystem.SYSTEM,
    directory.toOkioPath(),
    maxSize,
  )

  internal val cache =
    DiskLruCache(
      fileSystem = fileSystem,
      directory = directory,
      appVersion = VERSION,
      valueCount = ENTRY_COUNT,
      maxSize = maxSize,
      taskRunner = taskRunner,
    )

import okhttp3.internal.connection.RealCall
import okhttp3.internal.connection.RealConnection
import okio.FileSystem
import okio.Path

internal fun buildCache(
  file: Path,
  maxSize: Long,
  fileSystem: FileSystem,
): Cache = Cache(fileSystem, file, maxSize)

internal var RealConnection.idleAtNsAccessor: Long
  get() = idleAtNs
  set(value) {
    idleAtNs = value
  }

internal val Response.exchangeAccessor: Exchange?

  }

  public void testUnion_maxSize_saturated() {
    assertThat(union(setSize(Integer.MAX_VALUE), setSize(1)).maxSize())
        .isEqualTo(Integer.MAX_VALUE);
    assertThat(union(setSize(1), setSize(Integer.MAX_VALUE)).maxSize())
        .isEqualTo(Integer.MAX_VALUE);
  }

  public void testIntersection_minSize() {
    assertMinSize(intersection(emptySet(), emptySet()), 0);

    /** The term of the key match. */
    public String term;

    /** The query of the key match. */
    public String query;

    /** The max size of the key match. */
    public String maxSize;

    /** The boost of the key match. */
    public String boost;

    /** The creator of the key match. */
    public String createdBy;

    /** The created time of the key match. */

    public String query;

    /**
     * The maximum number of results to return.
     */
    @Required
    @Min(value = 0)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer maxSize;

    /**
     * The boost score for matched results.
     */
    @Required
    @ValidateTypeFailure
    public Float boost;

    /**
     * The virtual host for the key match.
     */