org.rocksdb.EnvOptions Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of rocksdbjni Show documentation
RocksDB fat jar that contains .so files for linux32 and linux64 (glibc and musl-libc), jnilib files for Mac OSX, and a .dll for Windows x64.
There is a newer version: 9.7.3
Show newest version
// 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;
}