Fix formatting errors

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_;
 }