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;
  
  public class EnvOptions extends RocksObject {
    static {
      RocksDB.loadLibrary();
    }
  
    public EnvOptions() {
      super(newEnvOptions());
    }
  
    public EnvOptions setUseOsBuffer(final boolean useOsBuffer) {
      setUseOsBuffer(nativeHandle_, useOsBuffer);
      return this;
    }
  
    public boolean useOsBuffer() {
      assert(isOwningHandle());
      return useOsBuffer(nativeHandle_);
    }
  
    public EnvOptions setUseMmapReads(final boolean useMmapReads) {
      setUseMmapReads(nativeHandle_, useMmapReads);
      return this;
    }
  
    public boolean useMmapReads() {
      assert(isOwningHandle());
      return useMmapReads(nativeHandle_);
    }
  
    public EnvOptions setUseMmapWrites(final boolean useMmapWrites) {
      setUseMmapWrites(nativeHandle_, useMmapWrites);
      return this;
    }
  
    public boolean useMmapWrites() {
      assert(isOwningHandle());
      return useMmapWrites(nativeHandle_);
    }
  
    public EnvOptions setUseDirectReads(final boolean useDirectReads) {
      setUseDirectReads(nativeHandle_, useDirectReads);
      return this;
    }
  
    public boolean useDirectReads() {
      assert(isOwningHandle());
      return useDirectReads(nativeHandle_);
    }
  
    public EnvOptions setUseDirectWrites(final boolean useDirectWrites) {
      setUseDirectWrites(nativeHandle_, useDirectWrites);
      return this;
    }
  
    public boolean useDirectWrites() {
      assert(isOwningHandle());
      return useDirectWrites(nativeHandle_);
    }
  
    public EnvOptions setAllowFallocate(final boolean allowFallocate) {
      setAllowFallocate(nativeHandle_, allowFallocate);
      return this;
    }
  
    public boolean allowFallocate() {
      assert(isOwningHandle());
      return allowFallocate(nativeHandle_);
    }
  
    public EnvOptions setSetFdCloexec(final boolean setFdCloexec) {
      setSetFdCloexec(nativeHandle_, setFdCloexec);
      return this;
    }
  
    public boolean setFdCloexec() {
      assert(isOwningHandle());
      return setFdCloexec(nativeHandle_);
    }
  
    public EnvOptions setBytesPerSync(final long bytesPerSync) {
      setBytesPerSync(nativeHandle_, bytesPerSync);
      return this;
    }
  
    public long bytesPerSync() {
      assert(isOwningHandle());
      return bytesPerSync(nativeHandle_);
    }
  
    public EnvOptions setFallocateWithKeepSize(final boolean fallocateWithKeepSize) {
      setFallocateWithKeepSize(nativeHandle_, fallocateWithKeepSize);
      return this;
    }
  
    public boolean fallocateWithKeepSize() {
      assert(isOwningHandle());
      return fallocateWithKeepSize(nativeHandle_);
    }
  
    public EnvOptions setCompactionReadaheadSize(final long compactionReadaheadSize) {
      setCompactionReadaheadSize(nativeHandle_, compactionReadaheadSize);
      return this;
    }
  
    public long compactionReadaheadSize() {
      assert(isOwningHandle());
      return compactionReadaheadSize(nativeHandle_);
    }
  
    public EnvOptions setRandomAccessMaxBufferSize(final long randomAccessMaxBufferSize) {
      setRandomAccessMaxBufferSize(nativeHandle_, randomAccessMaxBufferSize);
      return this;
    }
  
    public long randomAccessMaxBufferSize() {
      assert(isOwningHandle());
      return randomAccessMaxBufferSize(nativeHandle_);
    }
  
    public EnvOptions setWritableFileMaxBufferSize(final long writableFileMaxBufferSize) {
      setWritableFileMaxBufferSize(nativeHandle_, writableFileMaxBufferSize);
      return this;
    }
  
    public long writableFileMaxBufferSize() {
      assert(isOwningHandle());
      return writableFileMaxBufferSize(nativeHandle_);
    }
  
    public EnvOptions setRateLimiter(final RateLimiter rateLimiter) {
      this.rateLimiter = rateLimiter;
      setRateLimiter(nativeHandle_, rateLimiter.nativeHandle_);
      return this;
    }
  
    public RateLimiter rateLimiter() {
      assert(isOwningHandle());
      return rateLimiter;
    }
  
    private native static long newEnvOptions();
  
    @Override protected final native void disposeInternal(final long handle);
  
    private native void setUseOsBuffer(final long handle, final boolean useOsBuffer);
  
    private native boolean useOsBuffer(final long handle);
  
    private native void setUseMmapReads(final long handle, final boolean useMmapReads);
  
    private native boolean useMmapReads(final long handle);
  
    private native void setUseMmapWrites(final long handle, final boolean useMmapWrites);
  
    private native boolean useMmapWrites(final long handle);
  
    private native void setUseDirectReads(final long handle, final boolean useDirectReads);
  
    private native boolean useDirectReads(final long handle);
  
    private native void setUseDirectWrites(final long handle, final boolean useDirectWrites);
  
    private native boolean useDirectWrites(final long handle);
  
    private native void setAllowFallocate(final long handle, final boolean allowFallocate);
  
    private native boolean allowFallocate(final long handle);
  
    private native void setSetFdCloexec(final long handle, final boolean setFdCloexec);
  
    private native boolean setFdCloexec(final long handle);
  
    private native void setBytesPerSync(final long handle, final long bytesPerSync);
  
    private native long bytesPerSync(final long handle);
  
    private native void setFallocateWithKeepSize(
        final long handle, final boolean fallocateWithKeepSize);
  
    private native boolean fallocateWithKeepSize(final long handle);
  
    private native void setCompactionReadaheadSize(
        final long handle, final long compactionReadaheadSize);
  
    private native long compactionReadaheadSize(final long handle);
  
    private native void setRandomAccessMaxBufferSize(
        final long handle, final long randomAccessMaxBufferSize);
  
    private native long randomAccessMaxBufferSize(final long handle);
  
    private native void setWritableFileMaxBufferSize(
        final long handle, final long writableFileMaxBufferSize);
  
    private native long writableFileMaxBufferSize(final long handle);
  
    private native void setRateLimiter(final long handle, final long rateLimiterHandle);
  
    private RateLimiter rateLimiter;
  }
  