diff --git a/java/RocksDBSample.java b/java/RocksDBSample.java index 8a1a3ccbc..a457701a5 100644 --- a/java/RocksDBSample.java +++ b/java/RocksDBSample.java @@ -38,14 +38,14 @@ public class RocksDBSample { options.setDisableSeekCompaction(true); options.setBlockSize(64*1024); options.setMaxBackgroundCompactions(10); - + assert(options.createIfMissing() == true); assert(options.writeBufferSize() == 8192); assert(options.maxWriteBufferNumber() == 3); assert(options.disableSeekCompaction() == true); assert(options.blockSize() == 65536); assert(options.maxBackgroundCompactions() == 10); - + try { db = RocksDB.open(options, db_path_not_found); db.put("hello".getBytes(), "world".getBytes()); diff --git a/java/org/rocksdb/Options.java b/java/org/rocksdb/Options.java index 8d1e1ed78..d33b5b424 100644 --- a/java/org/rocksdb/Options.java +++ b/java/org/rocksdb/Options.java @@ -34,7 +34,7 @@ public class Options { * @see RocksDB::Open() */ public void setCreateIfMissing(boolean flag) { - checkInitialization(); + assert(isInitialized()); setCreateIfMissing(nativeHandle_, flag); } @@ -46,31 +46,31 @@ public class Options { * @see setCreateIfMissing() */ public boolean createIfMissing() { - checkInitialization(); + assert(isInitialized()); return createIfMissing(nativeHandle_); } - + /** * Amount of data to build up in memory (backed by an unsorted log * on disk) before converting to a sorted on-disk file. - * + * * Larger values increase performance, especially during bulk loads. * Up to max_write_buffer_number write buffers may be held in memory - * at the same time, so you may wish to adjust this parameter + * at the same time, so you may wish to adjust this parameter * to control memory usage. - * + * * Also, a larger write buffer will result in a longer recovery time * the next time the database is opened. - * + * * Default: 4MB * @param size of write buffer * @see RocksDB::Open() - */ + */ public void setWriteBufferSize(int writeBufferSize) { - checkInitialization(); + assert(isInitialized()); setWriteBufferSize(nativeHandle_, writeBufferSize); } - + /** * Return size of write buffer size. * @@ -78,108 +78,109 @@ public class Options { * @see setWriteBufferSize() */ public int writeBufferSize() { - checkInitialization(); + assert(isInitialized()); return writeBufferSize(nativeHandle_); } - + /** * The maximum number of write buffers that are built up in memory. * The default is 2, so that when 1 write buffer is being flushed to * storage, new writes can continue to the other write buffer. * Default: 2 - * + * * @param maximum number of write buffers * @see RocksDB::Open() */ public void setMaxWriteBufferNumber(int maxWriteBufferNumber) { - checkInitialization(); + assert(isInitialized()); setMaxWriteBufferNumber(nativeHandle_, maxWriteBufferNumber); } - + /** * Returns maximum number of write buffers. - * + * * @return maximum number of write buffers. * @see setMaxWriteBufferNumber() */ public int maxWriteBufferNumber() { - checkInitialization(); + assert(isInitialized()); return maxWriteBufferNumber(nativeHandle_); } - + /* * Approximate size of user data packed per block. Note that the * block size specified here corresponds to uncompressed data. The * actual size of the unit read from disk may be smaller if * compression is enabled. This parameter can be changed dynamically. - * + * * Default: 4K - * + * * @param block size * @see RocksDB::Open() */ public void setBlockSize(int blockSize) { - checkInitialization(); + assert(isInitialized()); setBlockSize(nativeHandle_, blockSize); } - + /* * Returns block size. - * + * * @return block size. - * @see setBlockSize() + * @see setBlockSize() */ public int blockSize() { - checkInitialization(); + assert(isInitialized()); return blockSize(nativeHandle_); } - + /* * Disable compaction triggered by seek. * With bloomfilter and fast storage, a miss on one level * is very cheap if the file handle is cached in table cache * (which is true if max_open_files is large). - * + * Default: true + * * @param disable seek compaction * @see RocksDB::Open() */ public void setDisableSeekCompaction(boolean disableSeekCompaction) { - checkInitialization(); + assert(isInitialized()); setDisableSeekCompaction(nativeHandle_, disableSeekCompaction); } - + /* * Returns true if disable seek compaction is set to true. - * + * * @return true if disable seek compaction is set to true. * @see setDisableSeekCompaction() */ public boolean disableSeekCompaction() { - checkInitialization(); + assert(isInitialized()); return disableSeekCompaction(nativeHandle_); } - + /* * Maximum number of concurrent background jobs, submitted to * the default LOW priority thread pool * Default: 1 - * + * * @param maximum number of concurrent background jobs. * @see RocksDB::Open() */ public void setMaxBackgroundCompactions(int maxBackgroundCompactions) { - checkInitialization(); + assert(isInitialized()); setMaxBackgroundCompactions(nativeHandle_, maxBackgroundCompactions); } - + /* * Returns maximum number of background concurrent jobs - * + * * @return maximum number of background concurrent jobs * @see setMaxBackgroundCompactions */ public int maxBackgroundCompactions() { - checkInitialization(); + assert(isInitialized()); return maxBackgroundCompactions(nativeHandle_); } @@ -192,9 +193,9 @@ public class Options { dispose0(); } } - - private void checkInitialization() { - assert(nativeHandle_ != 0); + + private boolean isInitialized() { + return (nativeHandle_ != 0); } private native void newOptions(); @@ -202,7 +203,7 @@ public class Options { private native void setCreateIfMissing(long handle, boolean flag); private native boolean createIfMissing(long handle); private native void setWriteBufferSize(long handle, int writeBufferSize); - private native int writeBufferSize(long handle); + private native int writeBufferSize(long handle); private native void setMaxWriteBufferNumber(long handle, int maxWriteBufferNumber); private native int maxWriteBufferNumber(long handle); private native void setBlockSize(long handle, int blockSize); @@ -210,7 +211,7 @@ public class Options { private native void setDisableSeekCompaction(long handle, boolean disableSeekCompaction); private native boolean disableSeekCompaction(long handle); private native void setMaxBackgroundCompactions(long handle, int maxBackgroundCompactions); - private native int maxBackgroundCompactions(long handle); + private native int maxBackgroundCompactions(long handle); long nativeHandle_; } diff --git a/java/rocksjni/options.cc b/java/rocksjni/options.cc index 50ea53e39..925613fef 100644 --- a/java/rocksjni/options.cc +++ b/java/rocksjni/options.cc @@ -65,7 +65,7 @@ jboolean Java_org_rocksdb_Options_createIfMissing( */ void Java_org_rocksdb_Options_setWriteBufferSize( JNIEnv* env, jobject jobj, jlong jhandle, jint jwrite_buffer_size) { - reinterpret_cast(jhandle)->write_buffer_size = + reinterpret_cast(jhandle)->write_buffer_size = static_cast(jwrite_buffer_size); } @@ -77,7 +77,7 @@ void Java_org_rocksdb_Options_setWriteBufferSize( */ jint Java_org_rocksdb_Options_writeBufferSize( JNIEnv* env, jobject jobj, jlong jhandle) { - return reinterpret_cast(jhandle)->write_buffer_size; + return reinterpret_cast(jhandle)->write_buffer_size; } /* @@ -87,7 +87,8 @@ jint Java_org_rocksdb_Options_writeBufferSize( */ void Java_org_rocksdb_Options_setMaxWriteBufferNumber( JNIEnv* env, jobject jobj, jlong jhandle, jint jmax_write_buffer_number) { - reinterpret_cast(jhandle)->max_write_buffer_number = jmax_write_buffer_number; + reinterpret_cast(jhandle)->max_write_buffer_number = + jmax_write_buffer_number; } @@ -98,7 +99,7 @@ void Java_org_rocksdb_Options_setMaxWriteBufferNumber( */ jint Java_org_rocksdb_Options_maxWriteBufferNumber( JNIEnv* env, jobject jobj, jlong jhandle) { - return reinterpret_cast(jhandle)->max_write_buffer_number; + return reinterpret_cast(jhandle)->max_write_buffer_number; } /* @@ -108,7 +109,7 @@ jint Java_org_rocksdb_Options_maxWriteBufferNumber( */ void Java_org_rocksdb_Options_setBlockSize( JNIEnv* env, jobject jobj, jlong jhandle, jint jblock_size) { - reinterpret_cast(jhandle)->block_size = + reinterpret_cast(jhandle)->block_size = static_cast(jblock_size); } @@ -119,7 +120,7 @@ void Java_org_rocksdb_Options_setBlockSize( */ jint Java_org_rocksdb_Options_blockSize( JNIEnv* env, jobject jobj, jlong jhandle) { - return reinterpret_cast(jhandle)->block_size; + return reinterpret_cast(jhandle)->block_size; } /* @@ -128,8 +129,10 @@ jint Java_org_rocksdb_Options_blockSize( * Signature: (JZ)V */ void Java_org_rocksdb_Options_setDisableSeekCompaction( - JNIEnv* env, jobject jobj, jlong jhandle, jboolean jdisable_seek_compaction) { - reinterpret_cast(jhandle)->disable_seek_compaction = jdisable_seek_compaction; + JNIEnv* env, jobject jobj, jlong jhandle, + jboolean jdisable_seek_compaction) { + reinterpret_cast(jhandle)->disable_seek_compaction = + jdisable_seek_compaction; } /* @@ -148,8 +151,10 @@ jboolean Java_org_rocksdb_Options_disableSeekCompaction( * Signature: (JI)V */ void Java_org_rocksdb_Options_setMaxBackgroundCompactions( - JNIEnv* env, jobject jobj, jlong jhandle, jint jmax_background_compactions) { - reinterpret_cast(jhandle)->max_background_compactions = jmax_background_compactions; + JNIEnv* env, jobject jobj, jlong jhandle, + jint jmax_background_compactions) { + reinterpret_cast(jhandle)->max_background_compactions = + jmax_background_compactions; } /* @@ -159,7 +164,8 @@ void Java_org_rocksdb_Options_setMaxBackgroundCompactions( */ jint Java_org_rocksdb_Options_maxBackgroundCompactions( JNIEnv* env, jobject jobj, jlong jhandle) { - return reinterpret_cast(jhandle)->max_background_compactions; + return + reinterpret_cast(jhandle)->max_background_compactions; }