content: // Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
  //  This source code is licensed under both the GPLv2 (found in the
  //  COPYING file in the root directory) and Apache 2.0 License
  //  (found in the LICENSE.Apache file in the root directory).
  
  package org.rocksdb;
  
  /**
   * Options for Universal Compaction
   */
  public class CompactionOptionsUniversal extends RocksObject {
  
    public CompactionOptionsUniversal() {
      super(newCompactionOptionsUniversal());
    }
  
    /**
     * Percentage flexibility while comparing file size. If the candidate file(s)
     * size is 1% smaller than the next file's size, then include next file into
     * this candidate set.
     *
     * Default: 1
     *
     * @param sizeRatio The size ratio to use
     *
     * @return the reference to the current options.
     */
    public CompactionOptionsUniversal setSizeRatio(final int sizeRatio) {
      setSizeRatio(nativeHandle_, sizeRatio);
      return this;
    }
  
    /**
     * Percentage flexibility while comparing file size. If the candidate file(s)
     * size is 1% smaller than the next file's size, then include next file into
     * this candidate set.
     *
     * Default: 1
     *
     * @return The size ratio in use
     */
    public int sizeRatio() {
      return sizeRatio(nativeHandle_);
    }
  
    /**
     * The minimum number of files in a single compaction run.
     *
     * Default: 2
     *
     * @param minMergeWidth minimum number of files in a single compaction run
     *
     * @return the reference to the current options.
     */
    public CompactionOptionsUniversal setMinMergeWidth(final int minMergeWidth) {
      setMinMergeWidth(nativeHandle_, minMergeWidth);
      return this;
    }
  
    /**
     * The minimum number of files in a single compaction run.
     *
     * Default: 2
     *
     * @return minimum number of files in a single compaction run
     */
    public int minMergeWidth() {
      return minMergeWidth(nativeHandle_);
    }
  
    /**
     * The maximum number of files in a single compaction run.
     *
     * Default: {@link Long#MAX_VALUE}
     *
     * @param maxMergeWidth maximum number of files in a single compaction run
     *
     * @return the reference to the current options.
     */
    public CompactionOptionsUniversal setMaxMergeWidth(final int maxMergeWidth) {
      setMaxMergeWidth(nativeHandle_, maxMergeWidth);
      return this;
    }
  
    /**
     * The maximum number of files in a single compaction run.
     *
     * Default: {@link Long#MAX_VALUE}
     *
     * @return maximum number of files in a single compaction run
     */
    public int maxMergeWidth() {
      return maxMergeWidth(nativeHandle_);
    }
  
    /**
     * The size amplification is defined as the amount (in percentage) of
     * additional storage needed to store a single byte of data in the database.
     * For example, a size amplification of 2% means that a database that
     * contains 100 bytes of user-data may occupy upto 102 bytes of
     * physical storage. By this definition, a fully compacted database has
     * a size amplification of 0%. Rocksdb uses the following heuristic
     * to calculate size amplification: it assumes that all files excluding
     * the earliest file contribute to the size amplification.
     *
     * Default: 200, which means that a 100 byte database could require upto
     * 300 bytes of storage.
     *
     * @param maxSizeAmplificationPercent the amount of additional storage needed
     *     (as a percentage) to store a single byte in the database
     *
     * @return the reference to the current options.
     */
    public CompactionOptionsUniversal setMaxSizeAmplificationPercent(
        final int maxSizeAmplificationPercent) {
      setMaxSizeAmplificationPercent(nativeHandle_, maxSizeAmplificationPercent);
      return this;
    }
  
    /**
     * The size amplification is defined as the amount (in percentage) of
     * additional storage needed to store a single byte of data in the database.
     * For example, a size amplification of 2% means that a database that
     * contains 100 bytes of user-data may occupy upto 102 bytes of
     * physical storage. By this definition, a fully compacted database has
     * a size amplification of 0%. Rocksdb uses the following heuristic
     * to calculate size amplification: it assumes that all files excluding
     * the earliest file contribute to the size amplification.
     *
     * Default: 200, which means that a 100 byte database could require upto
     * 300 bytes of storage.
     *
     * @return the amount of additional storage needed (as a percentage) to store
     *     a single byte in the database
     */
    public int maxSizeAmplificationPercent() {
      return maxSizeAmplificationPercent(nativeHandle_);
    }
  
    /**
     * If this option is set to be -1 (the default value), all the output files
     * will follow compression type specified.
     *
     * If this option is not negative, we will try to make sure compressed
     * size is just above this value. In normal cases, at least this percentage
     * of data will be compressed.
     *
     * When we are compacting to a new file, here is the criteria whether
     * it needs to be compressed: assuming here are the list of files sorted
     * by generation time:
     *    A1...An B1...Bm C1...Ct
     * where A1 is the newest and Ct is the oldest, and we are going to compact
     * B1...Bm, we calculate the total size of all the files as total_size, as
     * well as  the total size of C1...Ct as total_C, the compaction output file
     * will be compressed iff
     *    total_C / total_size &lt; this percentage
     *
     * Default: -1
     *
     * @param compressionSizePercent percentage of size for compression
     *
     * @return the reference to the current options.
     */
    public CompactionOptionsUniversal setCompressionSizePercent(
        final int compressionSizePercent) {
      setCompressionSizePercent(nativeHandle_, compressionSizePercent);
      return this;
    }
  
    /**
     * If this option is set to be -1 (the default value), all the output files
     * will follow compression type specified.
     *
     * If this option is not negative, we will try to make sure compressed
     * size is just above this value. In normal cases, at least this percentage
     * of data will be compressed.
     *
     * When we are compacting to a new file, here is the criteria whether
     * it needs to be compressed: assuming here are the list of files sorted
     * by generation time:
     *    A1...An B1...Bm C1...Ct
     * where A1 is the newest and Ct is the oldest, and we are going to compact
     * B1...Bm, we calculate the total size of all the files as total_size, as
     * well as  the total size of C1...Ct as total_C, the compaction output file
     * will be compressed iff
     *    total_C / total_size &lt; this percentage
     *
     * Default: -1
     *
     * @return percentage of size for compression
     */
    public int compressionSizePercent() {
      return compressionSizePercent(nativeHandle_);
    }
  
    /**
     * The algorithm used to stop picking files into a single compaction run
     *
     * Default: {@link CompactionStopStyle#CompactionStopStyleTotalSize}
     *
     * @param compactionStopStyle The compaction algorithm
     *
     * @return the reference to the current options.
     */
    public CompactionOptionsUniversal setStopStyle(
        final CompactionStopStyle compactionStopStyle) {
      setStopStyle(nativeHandle_, compactionStopStyle.getValue());
      return this;
    }
  
    /**
     * The algorithm used to stop picking files into a single compaction run
     *
     * Default: {@link CompactionStopStyle#CompactionStopStyleTotalSize}
     *
     * @return The compaction algorithm
     */
    public CompactionStopStyle stopStyle() {
      return CompactionStopStyle.getCompactionStopStyle(stopStyle(nativeHandle_));
    }
  
    /**
     * Option to optimize the universal multi level compaction by enabling
     * trivial move for non overlapping files.
     *
     * Default: false
     *
     * @param allowTrivialMove true if trivial move is allowed
     *
     * @return the reference to the current options.
     */
    public CompactionOptionsUniversal setAllowTrivialMove(
        final boolean allowTrivialMove) {
      setAllowTrivialMove(nativeHandle_, allowTrivialMove);
      return this;
    }
  
    /**
     * Option to optimize the universal multi level compaction by enabling
     * trivial move for non overlapping files.
     *
     * Default: false
     *
     * @return true if trivial move is allowed
     */
    public boolean allowTrivialMove() {
      return allowTrivialMove(nativeHandle_);
    }
  
    private native static long newCompactionOptionsUniversal();
    @Override protected final native void disposeInternal(final long handle);
  
    private native void setSizeRatio(final long handle, final int sizeRatio);
    private native int sizeRatio(final long handle);
    private native void setMinMergeWidth(
        final long handle, final int minMergeWidth);
    private native int minMergeWidth(final long handle);
    private native void setMaxMergeWidth(
        final long handle, final int maxMergeWidth);
    private native int maxMergeWidth(final long handle);
    private native void setMaxSizeAmplificationPercent(
        final long handle, final int maxSizeAmplificationPercent);
    private native int maxSizeAmplificationPercent(final long handle);
    private native void setCompressionSizePercent(
        final long handle, final int compressionSizePercent);
    private native int compressionSizePercent(final long handle);
    private native void setStopStyle(
        final long handle, final byte stopStyle);
    private native byte stopStyle(final long handle);
    private native void setAllowTrivialMove(
        final long handle, final boolean allowTrivialMove);
    private native boolean allowTrivialMove(final long handle);
  }
  