// 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;

import java.nio.file.Paths;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.List;

/**

* Options to control the behavior of a database. It will be used

* during the creation of a {@link org.rocksdb.RocksDB} (i.e., RocksDB.open()).

*

* If {@link #dispose()} function is not called, then it will be GC'd

* automaticallyand native resources will be released as part of the process.

*/

public class Options extends RocksObject

implements DBOptionsInterface<Options>, ColumnFamilyOptionsInterface<Options>,

MutableColumnFamilyOptionsInterface<Options> {

static {

RocksDB.loadLibrary();

}

/**

* Construct options for opening a RocksDB.

*

* This constructor will create (by allocating a block of memory)

* an {@code rocksdb::Options} in the c++ side.

*/

public Options() {

super(newOptions());

env_ = Env.getDefault();

}

/**

* Construct options for opening a RocksDB. Reusing database options

* and column family options.

*

* @param dbOptions {@link org.rocksdb.DBOptions} instance

* @param columnFamilyOptions {@link org.rocksdb.ColumnFamilyOptions}

* instance

*/

public Options(final DBOptions dbOptions,

final ColumnFamilyOptions columnFamilyOptions) {

super(newOptions(dbOptions.nativeHandle_,

columnFamilyOptions.nativeHandle_));

env_ = Env.getDefault();

}

@Override

public Options setIncreaseParallelism(final int totalThreads) {

assert(isOwningHandle());

setIncreaseParallelism(nativeHandle_, totalThreads);

return this;

}

@Override

public Options setCreateIfMissing(final boolean flag) {

assert(isOwningHandle());

setCreateIfMissing(nativeHandle_, flag);

return this;

}

@Override

public Options setCreateMissingColumnFamilies(final boolean flag) {

assert(isOwningHandle());

setCreateMissingColumnFamilies(nativeHandle_, flag);

return this;

}

@Override

public Options setEnv(final Env env) {

assert(isOwningHandle());

setEnv(nativeHandle_, env.nativeHandle_);

env_ = env;

return this;

}

@Override

public Env getEnv() {

return env_;

}

/**

* <p>Set appropriate parameters for bulk loading.

* The reason that this is a function that returns "this" instead of a

* constructor is to enable chaining of multiple similar calls in the future.

* </p>

*

* <p>All data will be in level 0 without any automatic compaction.

* It's recommended to manually call CompactRange(NULL, NULL) before reading

* from the database, because otherwise the read can be very slow.</p>

*

* @return the instance of the current Options.

*/

public Options prepareForBulkLoad() {

prepareForBulkLoad(nativeHandle_);

return this;

}

@Override

public boolean createIfMissing() {

assert(isOwningHandle());

return createIfMissing(nativeHandle_);

}

@Override

public boolean createMissingColumnFamilies() {

assert(isOwningHandle());

return createMissingColumnFamilies(nativeHandle_);

}

@Override

public Options optimizeForSmallDb() {

optimizeForSmallDb(nativeHandle_);

return this;

}

@Override

public Options optimizeForPointLookup(

long blockCacheSizeMb) {

optimizeForPointLookup(nativeHandle_,

blockCacheSizeMb);

return this;

}

@Override

public Options optimizeLevelStyleCompaction() {

optimizeLevelStyleCompaction(nativeHandle_,

DEFAULT_COMPACTION_MEMTABLE_MEMORY_BUDGET);

return this;

}

@Override

public Options optimizeLevelStyleCompaction(

long memtableMemoryBudget) {

optimizeLevelStyleCompaction(nativeHandle_,

memtableMemoryBudget);

return this;

}

@Override

public Options optimizeUniversalStyleCompaction() {

optimizeUniversalStyleCompaction(nativeHandle_,

DEFAULT_COMPACTION_MEMTABLE_MEMORY_BUDGET);

return this;

}

@Override

public Options optimizeUniversalStyleCompaction(

final long memtableMemoryBudget) {

optimizeUniversalStyleCompaction(nativeHandle_,

memtableMemoryBudget);

return this;

}

@Override

public Options setComparator(final BuiltinComparator builtinComparator) {

assert(isOwningHandle());

setComparatorHandle(nativeHandle_, builtinComparator.ordinal());

return this;

}

@Override

public Options setComparator(

final AbstractComparator<? extends AbstractSlice<?>> comparator) {

assert(isOwningHandle());

setComparatorHandle(nativeHandle_, comparator.getNativeHandle());

comparator_ = comparator;

return this;

}

@Override

public Options setMergeOperatorName(final String name) {

assert(isOwningHandle());

if (name == null) {

throw new IllegalArgumentException(

"Merge operator name must not be null.");

}

setMergeOperatorName(nativeHandle_, name);

return this;

}

@Override

public Options setMergeOperator(final MergeOperator mergeOperator) {

setMergeOperator(nativeHandle_, mergeOperator.nativeHandle_);

return this;

}

@Override

public Options setWriteBufferSize(final long writeBufferSize) {

assert(isOwningHandle());

setWriteBufferSize(nativeHandle_, writeBufferSize);

return this;

}

@Override

public long writeBufferSize() {

assert(isOwningHandle());

return writeBufferSize(nativeHandle_);

}

@Override

public Options setMaxWriteBufferNumber(final int maxWriteBufferNumber) {

assert(isOwningHandle());

setMaxWriteBufferNumber(nativeHandle_, maxWriteBufferNumber);

return this;

}

@Override

public int maxWriteBufferNumber() {

assert(isOwningHandle());

return maxWriteBufferNumber(nativeHandle_);

}

@Override

public boolean errorIfExists() {

assert(isOwningHandle());

return errorIfExists(nativeHandle_);

}

@Override

public Options setErrorIfExists(final boolean errorIfExists) {

assert(isOwningHandle());

setErrorIfExists(nativeHandle_, errorIfExists);

return this;

}

@Override

public boolean paranoidChecks() {

assert(isOwningHandle());

return paranoidChecks(nativeHandle_);

}

@Override

public Options setParanoidChecks(final boolean paranoidChecks) {

assert(isOwningHandle());

setParanoidChecks(nativeHandle_, paranoidChecks);

return this;

}

@Override

public int maxOpenFiles() {

assert(isOwningHandle());

return maxOpenFiles(nativeHandle_);

}

@Override

public Options setMaxFileOpeningThreads(final int maxFileOpeningThreads) {

assert(isOwningHandle());

setMaxFileOpeningThreads(nativeHandle_, maxFileOpeningThreads);

return this;

}

@Override

public int maxFileOpeningThreads() {

assert(isOwningHandle());

return maxFileOpeningThreads(nativeHandle_);

}

@Override

public Options setMaxTotalWalSize(final long maxTotalWalSize) {

assert(isOwningHandle());

setMaxTotalWalSize(nativeHandle_, maxTotalWalSize);

return this;

}

@Override

public long maxTotalWalSize() {

assert(isOwningHandle());

return maxTotalWalSize(nativeHandle_);

}

@Override

public Options setMaxOpenFiles(final int maxOpenFiles) {

assert(isOwningHandle());

setMaxOpenFiles(nativeHandle_, maxOpenFiles);

return this;

}

@Override

public boolean useFsync() {

assert(isOwningHandle());

return useFsync(nativeHandle_);

}

@Override

public Options setUseFsync(final boolean useFsync) {

assert(isOwningHandle());

setUseFsync(nativeHandle_, useFsync);

return this;

}

@Override

public Options setDbPaths(final Collection<DbPath> dbPaths) {

assert(isOwningHandle());

final int len = dbPaths.size();

final String paths[] = new String[len];

final long targetSizes[] = new long[len];

int i = 0;

for(final DbPath dbPath : dbPaths) {

paths[i] = dbPath.path.toString();

targetSizes[i] = dbPath.targetSize;

i++;

}

setDbPaths(nativeHandle_, paths, targetSizes);

return this;

}

@Override

public List<DbPath> dbPaths() {

final int len = (int)dbPathsLen(nativeHandle_);

if(len == 0) {

return Collections.emptyList();

} else {

final String paths[] = new String[len];

final long targetSizes[] = new long[len];

dbPaths(nativeHandle_, paths, targetSizes);

final List<DbPath> dbPaths = new ArrayList<>();

for(int i = 0; i < len; i++) {

dbPaths.add(new DbPath(Paths.get(paths[i]), targetSizes[i]));

}

return dbPaths;

}

}

@Override

public String dbLogDir() {

assert(isOwningHandle());

return dbLogDir(nativeHandle_);

}

@Override

public Options setDbLogDir(final String dbLogDir) {

assert(isOwningHandle());

setDbLogDir(nativeHandle_, dbLogDir);

return this;

}

@Override

public String walDir() {

assert(isOwningHandle());

return walDir(nativeHandle_);

}

@Override

public Options setWalDir(final String walDir) {

assert(isOwningHandle());

setWalDir(nativeHandle_, walDir);

return this;

}

@Override

public long deleteObsoleteFilesPeriodMicros() {

assert(isOwningHandle());

return deleteObsoleteFilesPeriodMicros(nativeHandle_);

}

@Override

public Options setDeleteObsoleteFilesPeriodMicros(

final long micros) {

assert(isOwningHandle());

setDeleteObsoleteFilesPeriodMicros(nativeHandle_, micros);

return this;

}

@Override

public int maxBackgroundCompactions() {

assert(isOwningHandle());

return maxBackgroundCompactions(nativeHandle_);

}

@Override

public Options createStatistics() {

assert(isOwningHandle());

createStatistics(nativeHandle_);

return this;

}

@Override

public Statistics statisticsPtr() {

assert(isOwningHandle());

long statsPtr = statisticsPtr(nativeHandle_);

if(statsPtr == 0) {

createStatistics();

statsPtr = statisticsPtr(nativeHandle_);

}

return new Statistics(statsPtr);

}

@Override

public void setBaseBackgroundCompactions(

final int baseBackgroundCompactions) {

assert(isOwningHandle());

setBaseBackgroundCompactions(nativeHandle_, baseBackgroundCompactions);

}

@Override

public int baseBackgroundCompactions() {

assert(isOwningHandle());

return baseBackgroundCompactions(nativeHandle_);

}

@Override

public Options setMaxBackgroundCompactions(

final int maxBackgroundCompactions) {

assert(isOwningHandle());

setMaxBackgroundCompactions(nativeHandle_, maxBackgroundCompactions);

return this;

}

@Override

public void setMaxSubcompactions(final int maxSubcompactions) {

assert(isOwningHandle());

setMaxSubcompactions(nativeHandle_, maxSubcompactions);

}

@Override

public int maxSubcompactions() {

assert(isOwningHandle());

return maxSubcompactions(nativeHandle_);

}

@Override

public int maxBackgroundFlushes() {

assert(isOwningHandle());

return maxBackgroundFlushes(nativeHandle_);

}

@Override

public Options setMaxBackgroundFlushes(

final int maxBackgroundFlushes) {

assert(isOwningHandle());

setMaxBackgroundFlushes(nativeHandle_, maxBackgroundFlushes);

return this;

}

@Override

public long maxLogFileSize() {

assert(isOwningHandle());

return maxLogFileSize(nativeHandle_);

}

@Override

public Options setMaxLogFileSize(final long maxLogFileSize) {

assert(isOwningHandle());

setMaxLogFileSize(nativeHandle_, maxLogFileSize);

return this;

}

@Override

public long logFileTimeToRoll() {

assert(isOwningHandle());

return logFileTimeToRoll(nativeHandle_);

}

@Override

public Options setLogFileTimeToRoll(final long logFileTimeToRoll) {

assert(isOwningHandle());

setLogFileTimeToRoll(nativeHandle_, logFileTimeToRoll);

return this;

}

@Override

public long keepLogFileNum() {

assert(isOwningHandle());

return keepLogFileNum(nativeHandle_);

}

@Override

public Options setKeepLogFileNum(final long keepLogFileNum) {

assert(isOwningHandle());

setKeepLogFileNum(nativeHandle_, keepLogFileNum);

return this;

}

@Override

public Options setRecycleLogFileNum(final long recycleLogFileNum) {

assert(isOwningHandle());

setRecycleLogFileNum(nativeHandle_, recycleLogFileNum);

return this;

}

@Override

public long recycleLogFileNum() {

assert(isOwningHandle());

return recycleLogFileNum(nativeHandle_);

}

@Override

public long maxManifestFileSize() {

assert(isOwningHandle());

return maxManifestFileSize(nativeHandle_);

}

@Override

public Options setMaxManifestFileSize(

final long maxManifestFileSize) {

assert(isOwningHandle());

setMaxManifestFileSize(nativeHandle_, maxManifestFileSize);

return this;

}

@Override

public Options setMaxTableFilesSizeFIFO(

final long maxTableFilesSize) {

assert(maxTableFilesSize > 0); // unsigned native type

assert(isOwningHandle());

setMaxTableFilesSizeFIFO(nativeHandle_, maxTableFilesSize);

return this;

}

@Override

public long maxTableFilesSizeFIFO() {

return maxTableFilesSizeFIFO(nativeHandle_);

}

@Override

public int tableCacheNumshardbits() {

assert(isOwningHandle());

return tableCacheNumshardbits(nativeHandle_);

}

@Override

public Options setTableCacheNumshardbits(

final int tableCacheNumshardbits) {

assert(isOwningHandle());

setTableCacheNumshardbits(nativeHandle_, tableCacheNumshardbits);

return this;

}

@Override

public long walTtlSeconds() {

assert(isOwningHandle());

return walTtlSeconds(nativeHandle_);

}

@Override

public Options setWalTtlSeconds(final long walTtlSeconds) {

assert(isOwningHandle());

setWalTtlSeconds(nativeHandle_, walTtlSeconds);

return this;

}

@Override

public long walSizeLimitMB() {

assert(isOwningHandle());

return walSizeLimitMB(nativeHandle_);

}

@Override

public Options setWalSizeLimitMB(final long sizeLimitMB) {

assert(isOwningHandle());

setWalSizeLimitMB(nativeHandle_, sizeLimitMB);

return this;

}

@Override

public long manifestPreallocationSize() {

assert(isOwningHandle());

return manifestPreallocationSize(nativeHandle_);

}

@Override

public Options setManifestPreallocationSize(final long size) {

assert(isOwningHandle());

setManifestPreallocationSize(nativeHandle_, size);

return this;

}

@Override

public Options setUseDirectReads(final boolean useDirectReads) {

assert(isOwningHandle());

setUseDirectReads(nativeHandle_, useDirectReads);

return this;

}

@Override

public boolean useDirectReads() {

assert(isOwningHandle());

return useDirectReads(nativeHandle_);

}

@Override

public Options setUseDirectIoForFlushAndCompaction(

final boolean useDirectIoForFlushAndCompaction) {

assert(isOwningHandle());

setUseDirectIoForFlushAndCompaction(nativeHandle_, useDirectIoForFlushAndCompaction);

return this;

}

@Override

public boolean useDirectIoForFlushAndCompaction() {

assert(isOwningHandle());

return useDirectIoForFlushAndCompaction(nativeHandle_);

}

@Override

public Options setAllowFAllocate(final boolean allowFAllocate) {

assert(isOwningHandle());

setAllowFAllocate(nativeHandle_, allowFAllocate);

return this;

}

@Override

public boolean allowFAllocate() {

assert(isOwningHandle());

return allowFAllocate(nativeHandle_);

}

@Override

public boolean allowMmapReads() {

assert(isOwningHandle());

return allowMmapReads(nativeHandle_);

}

@Override

public Options setAllowMmapReads(final boolean allowMmapReads) {

assert(isOwningHandle());

setAllowMmapReads(nativeHandle_, allowMmapReads);

return this;

}

@Override

public boolean allowMmapWrites() {

assert(isOwningHandle());

return allowMmapWrites(nativeHandle_);

}

@Override

public Options setAllowMmapWrites(final boolean allowMmapWrites) {

assert(isOwningHandle());

setAllowMmapWrites(nativeHandle_, allowMmapWrites);

return this;

}

@Override

public boolean isFdCloseOnExec() {

assert(isOwningHandle());

return isFdCloseOnExec(nativeHandle_);

}

@Override

public Options setIsFdCloseOnExec(final boolean isFdCloseOnExec) {

assert(isOwningHandle());

setIsFdCloseOnExec(nativeHandle_, isFdCloseOnExec);

return this;

}

@Override

public int statsDumpPeriodSec() {

assert(isOwningHandle());

return statsDumpPeriodSec(nativeHandle_);

}

@Override

public Options setStatsDumpPeriodSec(final int statsDumpPeriodSec) {

assert(isOwningHandle());

setStatsDumpPeriodSec(nativeHandle_, statsDumpPeriodSec);

return this;

}

@Override

public boolean adviseRandomOnOpen() {

return adviseRandomOnOpen(nativeHandle_);

}

@Override

public Options setAdviseRandomOnOpen(final boolean adviseRandomOnOpen) {

assert(isOwningHandle());

setAdviseRandomOnOpen(nativeHandle_, adviseRandomOnOpen);

return this;

}

@Override

public Options setDbWriteBufferSize(final long dbWriteBufferSize) {

assert(isOwningHandle());

setDbWriteBufferSize(nativeHandle_, dbWriteBufferSize);

return this;

}

@Override

public long dbWriteBufferSize() {

assert(isOwningHandle());

return dbWriteBufferSize(nativeHandle_);

}

@Override

public Options setAccessHintOnCompactionStart(final AccessHint accessHint) {

assert(isOwningHandle());

setAccessHintOnCompactionStart(nativeHandle_, accessHint.getValue());

return this;

}

@Override

public AccessHint accessHintOnCompactionStart() {

assert(isOwningHandle());

return AccessHint.getAccessHint(accessHintOnCompactionStart(nativeHandle_));

}

@Override

public Options setNewTableReaderForCompactionInputs(

final boolean newTableReaderForCompactionInputs) {

assert(isOwningHandle());

setNewTableReaderForCompactionInputs(nativeHandle_,

newTableReaderForCompactionInputs);

return this;

}

@Override

public boolean newTableReaderForCompactionInputs() {

assert(isOwningHandle());

return newTableReaderForCompactionInputs(nativeHandle_);

}

@Override

public Options setCompactionReadaheadSize(final long compactionReadaheadSize) {

assert(isOwningHandle());

setCompactionReadaheadSize(nativeHandle_, compactionReadaheadSize);

return this;

}

@Override

public long compactionReadaheadSize() {

assert(isOwningHandle());

return compactionReadaheadSize(nativeHandle_);

}

@Override

public Options setRandomAccessMaxBufferSize(final long randomAccessMaxBufferSize) {

assert(isOwningHandle());

setRandomAccessMaxBufferSize(nativeHandle_, randomAccessMaxBufferSize);

return this;

}

@Override

public long randomAccessMaxBufferSize() {

assert(isOwningHandle());

return randomAccessMaxBufferSize(nativeHandle_);

}

@Override

public Options setWritableFileMaxBufferSize(final long writableFileMaxBufferSize) {

assert(isOwningHandle());

setWritableFileMaxBufferSize(nativeHandle_, writableFileMaxBufferSize);

return this;

}

@Override

public long writableFileMaxBufferSize() {

assert(isOwningHandle());

return writableFileMaxBufferSize(nativeHandle_);

}

@Override

public boolean useAdaptiveMutex() {

assert(isOwningHandle());

return useAdaptiveMutex(nativeHandle_);

}

@Override

public Options setUseAdaptiveMutex(final boolean useAdaptiveMutex) {

assert(isOwningHandle());

setUseAdaptiveMutex(nativeHandle_, useAdaptiveMutex);

return this;

}

@Override

public long bytesPerSync() {

return bytesPerSync(nativeHandle_);

}

@Override

public Options setBytesPerSync(final long bytesPerSync) {

assert(isOwningHandle());

setBytesPerSync(nativeHandle_, bytesPerSync);

return this;

}

@Override

public Options setWalBytesPerSync(final long walBytesPerSync) {

assert(isOwningHandle());

setWalBytesPerSync(nativeHandle_, walBytesPerSync);

return this;

}

@Override

public long walBytesPerSync() {

assert(isOwningHandle());

return walBytesPerSync(nativeHandle_);

}

@Override

public Options setEnableThreadTracking(final boolean enableThreadTracking) {

assert(isOwningHandle());

setEnableThreadTracking(nativeHandle_, enableThreadTracking);

return this;

}

@Override

public boolean enableThreadTracking() {

assert(isOwningHandle());

return enableThreadTracking(nativeHandle_);

}

@Override

public Options setDelayedWriteRate(final long delayedWriteRate) {

assert(isOwningHandle());

setDelayedWriteRate(nativeHandle_, delayedWriteRate);

return this;

}

@Override

public long delayedWriteRate(){

return delayedWriteRate(nativeHandle_);

}

@Override

public Options setAllowConcurrentMemtableWrite(

final boolean allowConcurrentMemtableWrite) {

setAllowConcurrentMemtableWrite(nativeHandle_,

allowConcurrentMemtableWrite);

return this;

}

@Override

public boolean allowConcurrentMemtableWrite() {

return allowConcurrentMemtableWrite(nativeHandle_);

}

@Override

public Options setEnableWriteThreadAdaptiveYield(

final boolean enableWriteThreadAdaptiveYield) {

setEnableWriteThreadAdaptiveYield(nativeHandle_,

enableWriteThreadAdaptiveYield);

return this;

}

@Override

public boolean enableWriteThreadAdaptiveYield() {

return enableWriteThreadAdaptiveYield(nativeHandle_);

}

@Override

public Options setWriteThreadMaxYieldUsec(final long writeThreadMaxYieldUsec) {

setWriteThreadMaxYieldUsec(nativeHandle_, writeThreadMaxYieldUsec);

return this;

}

@Override

public long writeThreadMaxYieldUsec() {

return writeThreadMaxYieldUsec(nativeHandle_);

}

@Override

public Options setWriteThreadSlowYieldUsec(final long writeThreadSlowYieldUsec) {

setWriteThreadSlowYieldUsec(nativeHandle_, writeThreadSlowYieldUsec);

return this;

}

@Override

public long writeThreadSlowYieldUsec() {

return writeThreadSlowYieldUsec(nativeHandle_);

}

@Override

public Options setSkipStatsUpdateOnDbOpen(final boolean skipStatsUpdateOnDbOpen) {

assert(isOwningHandle());

setSkipStatsUpdateOnDbOpen(nativeHandle_, skipStatsUpdateOnDbOpen);

return this;

}

@Override

public boolean skipStatsUpdateOnDbOpen() {

assert(isOwningHandle());

return skipStatsUpdateOnDbOpen(nativeHandle_);

}

@Override

public Options setWalRecoveryMode(final WALRecoveryMode walRecoveryMode) {

assert(isOwningHandle());

setWalRecoveryMode(nativeHandle_, walRecoveryMode.getValue());

return this;

}

@Override

public WALRecoveryMode walRecoveryMode() {

assert(isOwningHandle());

return WALRecoveryMode.getWALRecoveryMode(walRecoveryMode(nativeHandle_));

}

@Override

public Options setAllow2pc(final boolean allow2pc) {

assert(isOwningHandle());

setAllow2pc(nativeHandle_, allow2pc);

return this;

}

@Override

public boolean allow2pc() {

assert(isOwningHandle());

return allow2pc(nativeHandle_);

}

@Override

public Options setRowCache(final Cache rowCache) {

assert(isOwningHandle());

setRowCache(nativeHandle_, rowCache.nativeHandle_);

this.rowCache_ = rowCache;

return this;

}

@Override

public Cache rowCache() {

assert(isOwningHandle());

return this.rowCache_;

}

@Override

public Options setFailIfOptionsFileError(final boolean failIfOptionsFileError) {

assert(isOwningHandle());

setFailIfOptionsFileError(nativeHandle_, failIfOptionsFileError);

return this;

}

@Override

public boolean failIfOptionsFileError() {

assert(isOwningHandle());

return failIfOptionsFileError(nativeHandle_);

}

@Override

public Options setDumpMallocStats(final boolean dumpMallocStats) {

assert(isOwningHandle());

setDumpMallocStats(nativeHandle_, dumpMallocStats);

return this;

}

@Override

public boolean dumpMallocStats() {

assert(isOwningHandle());

return dumpMallocStats(nativeHandle_);

}

@Override

public Options setAvoidFlushDuringRecovery(final boolean avoidFlushDuringRecovery) {

assert(isOwningHandle());

setAvoidFlushDuringRecovery(nativeHandle_, avoidFlushDuringRecovery);

return this;

}

@Override

public boolean avoidFlushDuringRecovery() {

assert(isOwningHandle());

return avoidFlushDuringRecovery(nativeHandle_);

}

@Override

public Options setAvoidFlushDuringShutdown(final boolean avoidFlushDuringShutdown) {

assert(isOwningHandle());

setAvoidFlushDuringShutdown(nativeHandle_, avoidFlushDuringShutdown);

return this;

}

@Override

public boolean avoidFlushDuringShutdown() {

assert(isOwningHandle());

return avoidFlushDuringShutdown(nativeHandle_);

}

@Override

public MemTableConfig memTableConfig() {

return this.memTableConfig_;

}

@Override

public Options setMemTableConfig(final MemTableConfig config) {

memTableConfig_ = config;

setMemTableFactory(nativeHandle_, config.newMemTableFactoryHandle());

return this;

}

@Override

public Options setRateLimiter(final RateLimiter rateLimiter) {

assert(isOwningHandle());

rateLimiter_ = rateLimiter;

setRateLimiter(nativeHandle_, rateLimiter.nativeHandle_);

return this;

}