2->4 spacing

src/ffi.rs

@@ -18,169 +18,170 @@ pub struct RocksDBFilterPolicy(pub *const c_void);
 
 #[repr(C)]
 pub enum RocksDBCompressionType {
-  RocksDBNoCompression   = 0,
-  RocksDBSnappyCompression = 1,
-  RocksDBZlibCompression   = 2,
-  RocksDBBz2Compression  = 3,
-  RocksDBLz4Compression  = 4,
-  RocksDBLz4hcCompression  = 5
+    RocksDBNoCompression     = 0,
+    RocksDBSnappyCompression = 1,
+    RocksDBZlibCompression   = 2,
+    RocksDBBz2Compression    = 3,
+    RocksDBLz4Compression    = 4,
+    RocksDBLz4hcCompression  = 5
 }
 
 #[repr(C)]
 pub enum RocksDBCompactionStyle {
-  RocksDBLevelCompaction   = 0,
-  RocksDBUniversalCompaction = 1,
-  RocksDBFifoCompaction    = 2
+    RocksDBLevelCompaction     = 0,
+    RocksDBUniversalCompaction = 1,
+    RocksDBFifoCompaction      = 2
 }
 
 #[repr(C)]
 pub enum RocksDBUniversalCompactionStyle {
-  rocksdb_similar_size_compaction_stop_style = 0,
-  rocksdb_total_size_compaction_stop_style   = 1
+    rocksdb_similar_size_compaction_stop_style = 0,
+    rocksdb_total_size_compaction_stop_style   = 1
 }
 
 #[link(name = "rocksdb")]
 extern {
-  pub fn rocksdb_options_create() -> RocksDBOptions;
-  pub fn rocksdb_options_increase_parallelism(
-    options: RocksDBOptions, threads: c_int);
-  pub fn rocksdb_options_optimize_level_style_compaction(
-    options: RocksDBOptions, memtable_memory_budget: c_int);
-  pub fn rocksdb_options_set_create_if_missing(
-    options: RocksDBOptions, v: c_int);
-  pub fn rocksdb_options_set_max_open_files(
-    options: RocksDBOptions, files: c_int);
-  pub fn rocksdb_options_set_use_fsync(
-    options: RocksDBOptions, v: c_int);
-  pub fn rocksdb_options_set_bytes_per_sync(
-    options: RocksDBOptions, bytes: u64);
-  pub fn rocksdb_options_set_disable_data_sync(
-    options: RocksDBOptions, v: c_int);
-  pub fn rocksdb_options_optimize_for_point_lookup(
-    options: RocksDBOptions, block_cache_size_mb: u64);
-  pub fn rocksdb_options_set_table_cache_numshardbits(
-    options: RocksDBOptions, bits: u64);
-  pub fn rocksdb_options_set_max_write_buffer_number(
-    options: RocksDBOptions, bufno: c_int);
-  pub fn rocksdb_options_set_min_write_buffer_number_to_merge(
-    options: RocksDBOptions, bufno: c_int);
-  pub fn rocksdb_options_set_level0_file_num_compaction_trigger(
-    options: RocksDBOptions, no: c_int);
-  pub fn rocksdb_options_set_level0_slowdown_writes_trigger(
-    options: RocksDBOptions, no: c_int);
-  pub fn rocksdb_options_set_level0_stop_writes_trigger(
-    options: RocksDBOptions, no: c_int);
-  pub fn rocksdb_options_set_write_buffer_size(
-    options: RocksDBOptions, bytes: u64);
-  pub fn rocksdb_options_set_target_file_size_base(
-    options: RocksDBOptions, bytes: u64);
-  pub fn rocksdb_options_set_target_file_size_multiplier(
-    options: RocksDBOptions, mul: c_int);
-  pub fn rocksdb_options_set_max_log_file_size(
-    options: RocksDBOptions, bytes: u64);
-  pub fn rocksdb_options_set_max_manifest_file_size(
-    options: RocksDBOptions, bytes: u64);
-  pub fn rocksdb_options_set_hash_skip_list_rep(
-    options: RocksDBOptions, bytes: u64, a1: i32, a2: i32);
-  pub fn rocksdb_options_set_compaction_style(
-    options: RocksDBOptions, cs: RocksDBCompactionStyle);
-  pub fn rocksdb_options_set_compression(
-    options: RocksDBOptions, compression_style_no: c_int);
-  pub fn rocksdb_options_set_max_background_compactions(
-    options: RocksDBOptions, max_bg_compactions: c_int);
-  pub fn rocksdb_options_set_max_background_flushes(
-    options: RocksDBOptions, max_bg_flushes: c_int);
-  pub fn rocksdb_options_set_filter_deletes(
-    options: RocksDBOptions, v: u8);
-  //pub fn rocksdb_compactionfilter_create() -> RocksDBCompactionFilter;
-  pub fn rocksdb_filterpolicy_create_bloom(
-    bits_per_key: c_int) -> RocksDBFilterPolicy;
-  pub fn rocksdb_open(options: RocksDBOptions,
-    path: *const i8, err: *mut i8) -> RocksDBInstance;
-  pub fn rocksdb_writeoptions_create() -> RocksDBWriteOptions;
-  pub fn rocksdb_put(db: RocksDBInstance, writeopts: RocksDBWriteOptions,
-    k: *const u8, kLen: size_t, v: *const u8,
-    vLen: size_t, err: *mut i8);
-  pub fn rocksdb_readoptions_create() -> RocksDBReadOptions;
-  pub fn rocksdb_get(db: RocksDBInstance, readopts: RocksDBReadOptions,
-    k: *const u8, kLen: size_t,
-    valLen: *const size_t, err: *mut i8) -> *mut c_void;
-  pub fn rocksdb_delete(db: RocksDBInstance, writeopts: RocksDBWriteOptions,
-    k: *const u8, kLen: size_t, err: *mut i8) -> *mut c_void;
-  pub fn rocksdb_close(db: RocksDBInstance);
-  pub fn rocksdb_destroy_db(
-    options: RocksDBOptions, path: *const i8, err: *mut i8);
-  pub fn rocksdb_repair_db(
-    options: RocksDBOptions, path: *const i8, err: *mut i8);
+    pub fn rocksdb_options_create() -> RocksDBOptions;
+    pub fn rocksdb_options_increase_parallelism(
+        options: RocksDBOptions, threads: c_int);
+    pub fn rocksdb_options_optimize_level_style_compaction(
+        options: RocksDBOptions, memtable_memory_budget: c_int);
+    pub fn rocksdb_options_set_create_if_missing(
+        options: RocksDBOptions, v: c_int);
+    pub fn rocksdb_options_set_max_open_files(
+        options: RocksDBOptions, files: c_int);
+    pub fn rocksdb_options_set_use_fsync(
+        options: RocksDBOptions, v: c_int);
+    pub fn rocksdb_options_set_bytes_per_sync(
+        options: RocksDBOptions, bytes: u64);
+    pub fn rocksdb_options_set_disable_data_sync(
+        options: RocksDBOptions, v: c_int);
+    pub fn rocksdb_options_optimize_for_point_lookup(
+        options: RocksDBOptions, block_cache_size_mb: u64);
+    pub fn rocksdb_options_set_table_cache_numshardbits(
+        options: RocksDBOptions, bits: u64);
+    pub fn rocksdb_options_set_max_write_buffer_number(
+        options: RocksDBOptions, bufno: c_int);
+    pub fn rocksdb_options_set_min_write_buffer_number_to_merge(
+        options: RocksDBOptions, bufno: c_int);
+    pub fn rocksdb_options_set_level0_file_num_compaction_trigger(
+        options: RocksDBOptions, no: c_int);
+    pub fn rocksdb_options_set_level0_slowdown_writes_trigger(
+        options: RocksDBOptions, no: c_int);
+    pub fn rocksdb_options_set_level0_stop_writes_trigger(
+        options: RocksDBOptions, no: c_int);
+    pub fn rocksdb_options_set_write_buffer_size(
+        options: RocksDBOptions, bytes: u64);
+    pub fn rocksdb_options_set_target_file_size_base(
+        options: RocksDBOptions, bytes: u64);
+    pub fn rocksdb_options_set_target_file_size_multiplier(
+        options: RocksDBOptions, mul: c_int);
+    pub fn rocksdb_options_set_max_log_file_size(
+        options: RocksDBOptions, bytes: u64);
+    pub fn rocksdb_options_set_max_manifest_file_size(
+        options: RocksDBOptions, bytes: u64);
+    pub fn rocksdb_options_set_hash_skip_list_rep(
+        options: RocksDBOptions, bytes: u64, a1: i32, a2: i32);
+    pub fn rocksdb_options_set_compaction_style(
+        options: RocksDBOptions, cs: RocksDBCompactionStyle);
+    pub fn rocksdb_options_set_compression(
+        options: RocksDBOptions, compression_style_no: c_int);
+    pub fn rocksdb_options_set_max_background_compactions(
+        options: RocksDBOptions, max_bg_compactions: c_int);
+    pub fn rocksdb_options_set_max_background_flushes(
+        options: RocksDBOptions, max_bg_flushes: c_int);
+    pub fn rocksdb_options_set_filter_deletes(
+        options: RocksDBOptions, v: u8);
+    //pub fn rocksdb_compactionfilter_create() -> RocksDBCompactionFilter;
+    pub fn rocksdb_filterpolicy_create_bloom(
+        bits_per_key: c_int) -> RocksDBFilterPolicy;
+    pub fn rocksdb_open(options: RocksDBOptions,
+        path: *const i8, err: *mut i8) -> RocksDBInstance;
+    pub fn rocksdb_writeoptions_create() -> RocksDBWriteOptions;
+    pub fn rocksdb_put(db: RocksDBInstance, writeopts: RocksDBWriteOptions,
+        k: *const u8, kLen: size_t, v: *const u8,
+        vLen: size_t, err: *mut i8);
+    pub fn rocksdb_readoptions_create() -> RocksDBReadOptions;
+    pub fn rocksdb_get(db: RocksDBInstance, readopts: RocksDBReadOptions,
+        k: *const u8, kLen: size_t,
+        valLen: *const size_t, err: *mut i8) -> *mut c_void;
+    pub fn rocksdb_delete(db: RocksDBInstance, writeopts: RocksDBWriteOptions,
+        k: *const u8, kLen: size_t, err: *mut i8) -> *mut c_void;
+    pub fn rocksdb_close(db: RocksDBInstance);
+    pub fn rocksdb_destroy_db(
+        options: RocksDBOptions, path: *const i8, err: *mut i8);
+    pub fn rocksdb_repair_db(
+        options: RocksDBOptions, path: *const i8, err: *mut i8);
 
-  // Merge Operator
-  pub fn rocksdb_mergeoperator_create(
-    state: *mut c_void,
-    destroy: extern fn(*mut c_void) -> (),
-    full_merge: extern fn (
-      arg: *mut c_void, key: *const c_char, key_len: *mut size_t,
-      existing_value: *const c_char, existing_value_len: *mut size_t,
-      operands_list: &[*const c_char], operands_list_len: *const size_t,
-      num_operands: c_int,
-      success: *mut u8, new_value_length: *mut size_t
-    ) -> *const c_char,
-    partial_merge: extern fn(
-      *mut c_void, key: *const c_char, key_len: *mut size_t,
-      operands_list: &[*const c_char], operands_list_len: *const size_t,
-      num_operands: c_int,
-      success: *mut u8, new_value_length: *mut size_t
-    ) -> *const c_char,
-    delete_value: extern fn(*mut c_void, value: *const c_char, value_len: *mut size_t) -> (),
-    name_fn: extern fn(*mut c_void) -> *const c_char,
-  ) -> RocksDBMergeOperator;
-  pub fn rocksdb_mergeoperator_destroy(mo: RocksDBMergeOperator);
-  pub fn rocksdb_options_set_merge_operator(
-    options: RocksDBOptions,
-    mo: RocksDBMergeOperator);
+    // Merge Operator
+    pub fn rocksdb_mergeoperator_create(
+        state: *mut c_void,
+        destroy: extern fn(*mut c_void) -> (),
+        full_merge: extern fn (
+            arg: *mut c_void, key: *const c_char, key_len: *mut size_t,
+            existing_value: *const c_char, existing_value_len: *mut size_t,
+            operands_list: &[*const c_char], operands_list_len: *const size_t,
+            num_operands: c_int,
+            success: *mut u8, new_value_length: *mut size_t
+        ) -> *const c_char,
+        partial_merge: extern fn(
+            *mut c_void, key: *const c_char, key_len: *mut size_t,
+            operands_list: &[*const c_char], operands_list_len: *const size_t,
+            num_operands: c_int,
+            success: *mut u8, new_value_length: *mut size_t
+        ) -> *const c_char,
+        delete_value: extern fn(*mut c_void, value: *const c_char,
+            value_len: *mut size_t) -> (),
+        name_fn: extern fn(*mut c_void) -> *const c_char,
+    ) -> RocksDBMergeOperator;
+    pub fn rocksdb_mergeoperator_destroy(mo: RocksDBMergeOperator);
+    pub fn rocksdb_options_set_merge_operator(
+        options: RocksDBOptions,
+        mo: RocksDBMergeOperator);
 }
 
 #[allow(dead_code)]
 #[test]
 fn internal() {
-  unsafe {
-    let opts = rocksdb_options_create();
-    let RocksDBOptions(opt_ptr) = opts;
-    assert!(opt_ptr.is_not_null());
+    unsafe {
+        let opts = rocksdb_options_create();
+        let RocksDBOptions(opt_ptr) = opts;
+        assert!(opt_ptr.is_not_null());
 
-    rocksdb_options_increase_parallelism(opts, 0);
-    rocksdb_options_optimize_level_style_compaction(opts, 0);
-    rocksdb_options_set_create_if_missing(opts, 1);
+        rocksdb_options_increase_parallelism(opts, 0);
+        rocksdb_options_optimize_level_style_compaction(opts, 0);
+        rocksdb_options_set_create_if_missing(opts, 1);
 
-    let rustpath = "internaltest";
-    let cpath = rustpath.to_c_str();
-    let cpath_ptr = cpath.as_ptr();
+        let rustpath = "internaltest";
+        let cpath = rustpath.to_c_str();
+        let cpath_ptr = cpath.as_ptr();
 
-    let err = 0 as *mut i8;
-    let db = rocksdb_open(opts, cpath_ptr, err);
-    assert!(err.is_null());
-    libc::free(err as *mut c_void);
+        let err = 0 as *mut i8;
+        let db = rocksdb_open(opts, cpath_ptr, err);
+        assert!(err.is_null());
+        libc::free(err as *mut c_void);
 
-    let writeopts = rocksdb_writeoptions_create();
-    let RocksDBWriteOptions(write_opt_ptr) = writeopts;
-    assert!(write_opt_ptr.is_not_null());
+        let writeopts = rocksdb_writeoptions_create();
+        let RocksDBWriteOptions(write_opt_ptr) = writeopts;
+        assert!(write_opt_ptr.is_not_null());
 
-    let key = b"name\x00";
-    let val = b"spacejam\x00";
+        let key = b"name\x00";
+        let val = b"spacejam\x00";
 
-    rocksdb_put(db, writeopts, key.as_ptr(), 4, val.as_ptr(), 8, err);
-    assert!(err.is_null());
-    libc::free(err as *mut c_void);
+        rocksdb_put(db, writeopts, key.as_ptr(), 4, val.as_ptr(), 8, err);
+        assert!(err.is_null());
+        libc::free(err as *mut c_void);
 
-    let readopts = rocksdb_readoptions_create();
-    let RocksDBReadOptions(read_opts_ptr) = readopts;
-    assert!(read_opts_ptr.is_not_null());
-    libc::free(err as *mut c_void);
+        let readopts = rocksdb_readoptions_create();
+        let RocksDBReadOptions(read_opts_ptr) = readopts;
+        assert!(read_opts_ptr.is_not_null());
+        libc::free(err as *mut c_void);
 
-    let val_len: size_t = 0;
-    let val_len_ptr = &val_len as *const size_t;
-    rocksdb_get(db, readopts, key.as_ptr(), 4, val_len_ptr, err);
-    assert!(err.is_null());
-    libc::free(err as *mut c_void);
-    rocksdb_close(db);
-  }
+        let val_len: size_t = 0;
+        let val_len_ptr = &val_len as *const size_t;
+        rocksdb_get(db, readopts, key.as_ptr(), 4, val_len_ptr, err);
+        assert!(err.is_null());
+        libc::free(err as *mut c_void);
+        rocksdb_close(db);
+    }
 }

src/lib.rs

@@ -4,8 +4,8 @@
 
 pub use ffi as rocksdb_ffi;
 pub use rocksdb::{
-  RocksDB,
-  RocksDBResult,
+    RocksDB,
+    RocksDBResult,
 };
 pub mod rocksdb;
 pub mod ffi;

src/main.rs

@@ -5,53 +5,52 @@ use test::Bencher;
 
 #[allow(dead_code)]
 fn main() {
-  match RocksDB::open_default("/tmp/rust-rocksdb") {
-    Ok(db) => {
-      assert!(db.put(b"my key", b"my value").is_ok());
+    match RocksDB::open_default("/tmp/rust-rocksdb") {
+        Ok(db) => {
+            assert!(db.put(b"my key", b"my value").is_ok());
 
-      db.get(b"my key").map( |value| {
-        match value.to_utf8() {
-          Some(v) =>
-            println!("retrieved utf8 value: {}", v),
-          None =>
-            println!("did not read valid utf-8 out of the db"),
-        }
-      })
-        .on_absent( || { println!("value not found") })
-        .on_error( |e| { println!("error retrieving value: {}", e) });
+            db.get(b"my key").map( |value| {
+                match value.to_utf8() {
+                    Some(v) =>
+                        println!("retrieved utf8 value: {}", v),
+                    None =>
+                        println!("did not read valid utf-8 out of the db"),
+                }
+            })
+                .on_absent( || { println!("value not found") })
+                .on_error( |e| { println!("error retrieving value: {}", e) });
 
-      assert!(db.delete(b"my key").is_ok());
+            assert!(db.delete(b"my key").is_ok());
 
-      db.close();
-    },
-    Err(e) => panic!(e),
-  }
+            db.close();
+        },
+        Err(e) => panic!(e),
+    }
 }
 
 #[allow(dead_code)]
 #[bench]
 fn writes(b: &mut Bencher) {
-  let db = RocksDB::open_default("testdb").unwrap();
-  let mut i = 0 as u64;
-  b.iter(|| {
-    db.put(i.to_string().as_bytes(), b"v1111");
-    i += 1;
-  });
-  db.close();
+    let db = RocksDB::open_default("testdb").unwrap();
+    let mut i = 0 as u64;
+    b.iter(|| {
+        db.put(i.to_string().as_bytes(), b"v1111");
+        i += 1;
+    });
+    db.close();
 }
 
 #[allow(dead_code)]
 #[bench]
 fn reads(b: &mut Bencher) {
-  let db = RocksDB::open_default("testdb").unwrap();
-  let mut i = 0 as u64;
-  b.iter(|| {
-    db.get(i.to_string().as_bytes()).on_error(
-      |e| {
-        println!("error: {}", e);
-        e
-      });
-    i += 1;
-  });
-  db.close();
+    let db = RocksDB::open_default("testdb").unwrap();
+    let mut i = 0 as u64;
+    b.iter(|| {
+        db.get(i.to_string().as_bytes()).on_error( |e| {
+            println!("error: {}", e);
+            e
+        });
+        i += 1;
+    });
+    db.close();
 }

src/rocksdb.rs

@@ -8,284 +8,292 @@ use std::str::from_utf8;
 use rocksdb_ffi;
 
 pub struct RocksDBOptions {
-  inner: rocksdb_ffi::RocksDBOptions,
+    inner: rocksdb_ffi::RocksDBOptions,
 }
 
 impl RocksDBOptions {
-  pub fn new() -> RocksDBOptions {
-    unsafe {
-      let opts = rocksdb_ffi::rocksdb_options_create();
-      let rocksdb_ffi::RocksDBOptions(opt_ptr) = opts;
-      if opt_ptr.is_null() {
-        panic!("Could not create rocksdb options".to_string());
-      }
+    pub fn new() -> RocksDBOptions {
+        unsafe {
+            let opts = rocksdb_ffi::rocksdb_options_create();
+            let rocksdb_ffi::RocksDBOptions(opt_ptr) = opts;
+            if opt_ptr.is_null() {
+                panic!("Could not create rocksdb options".to_string());
+            }
 
-      RocksDBOptions{inner: opts}
+            RocksDBOptions{inner: opts}
+        }
     }
-  }
 
-  pub fn increase_parallelism(&self, parallelism: i32) {
-    unsafe {
-      rocksdb_ffi::rocksdb_options_increase_parallelism(self.inner, parallelism);
+    pub fn increase_parallelism(&self, parallelism: i32) {
+        unsafe {
+            rocksdb_ffi::rocksdb_options_increase_parallelism(
+                self.inner, parallelism);
+        }
     }
-  }
 
-  pub fn optimize_level_style_compaction(&self, memtable_memory_budget: i32) {
-    unsafe {
-      rocksdb_ffi::rocksdb_options_optimize_level_style_compaction(self.inner, memtable_memory_budget);
+    pub fn optimize_level_style_compaction(&self,
+        memtable_memory_budget: i32) {
+        unsafe {
+            rocksdb_ffi::rocksdb_options_optimize_level_style_compaction(
+                self.inner, memtable_memory_budget);
+        }
     }
-  }
 
-  pub fn create_if_missing(&self, create_if_missing: bool) {
-    unsafe {
-      match create_if_missing {
-        true => rocksdb_ffi::rocksdb_options_set_create_if_missing(self.inner, 1),
-        false => rocksdb_ffi::rocksdb_options_set_create_if_missing(self.inner, 0),
-      }
+    pub fn create_if_missing(&self, create_if_missing: bool) {
+        unsafe {
+            match create_if_missing {
+                true => rocksdb_ffi::rocksdb_options_set_create_if_missing(
+                    self.inner, 1),
+                false => rocksdb_ffi::rocksdb_options_set_create_if_missing(
+                    self.inner, 0),
+            }
+        }
     }
-  }
 
-  pub fn set_merge_operator(&self, mo: rocksdb_ffi::RocksDBMergeOperator) {
-    unsafe {
-      rocksdb_ffi::rocksdb_options_set_merge_operator(self.inner, mo);
+    pub fn set_merge_operator(&self, mo: rocksdb_ffi::RocksDBMergeOperator) {
+        unsafe {
+            rocksdb_ffi::rocksdb_options_set_merge_operator(self.inner, mo);
+        }
     }
-  }
 }
 
 pub struct RocksDB {
-  inner: rocksdb_ffi::RocksDBInstance,
+    inner: rocksdb_ffi::RocksDBInstance,
 }
 
 impl RocksDB {
-  pub fn open_default(path: &str) -> Result<RocksDB, String> {
-    let opts = RocksDBOptions::new();
-    opts.create_if_missing(true);
-    RocksDB::open(opts, path)
-  }
+    pub fn open_default(path: &str) -> Result<RocksDB, String> {
+        let opts = RocksDBOptions::new();
+        opts.create_if_missing(true);
+        RocksDB::open(opts, path)
+    }
 
-  pub fn open(opts: RocksDBOptions, path: &str) -> Result<RocksDB, String> {
-    unsafe {
-      let cpath = path.to_c_str();
-      let cpath_ptr = cpath.as_ptr();
+    pub fn open(opts: RocksDBOptions, path: &str) -> Result<RocksDB, String> {
+        unsafe {
+            let cpath = path.to_c_str();
+            let cpath_ptr = cpath.as_ptr();
 
-      //TODO test path here, as if rocksdb fails it will just crash the
-      //     process currently
+            //TODO test path here, as if rocksdb fails it will just crash the
+            //     process currently
 
-      let err = 0 as *mut i8;
-      let db = rocksdb_ffi::rocksdb_open(opts.inner, cpath_ptr, err);
-      let rocksdb_ffi::RocksDBInstance(db_ptr) = db;
-      if err.is_not_null() {
-        let cs = CString::new(err as *const i8, true);
-        match cs.as_str() {
-          Some(error_string) =>
-            return Err(error_string.to_string()),
-          None =>
-            return Err("Could not initialize database.".to_string()),
+            let err = 0 as *mut i8;
+            let db = rocksdb_ffi::rocksdb_open(opts.inner, cpath_ptr, err);
+            let rocksdb_ffi::RocksDBInstance(db_ptr) = db;
+            if err.is_not_null() {
+                let cs = CString::new(err as *const i8, true);
+                match cs.as_str() {
+                    Some(error_string) =>
+                        return Err(error_string.to_string()),
+                    None =>
+                        return Err("Could not initialize database.".to_string()),
+                }
+            }
+            if db_ptr.is_null() {
+                return Err("Could not initialize database.".to_string());
+            }
+            Ok(RocksDB{inner: db})
         }
-      }
-      if db_ptr.is_null() {
-        return Err("Could not initialize database.".to_string());
-      }
-      Ok(RocksDB{inner: db})
     }
-  }
 
-  pub fn put(&self, key: &[u8], value: &[u8]) -> Result<(), String> {
-    unsafe {
-      let writeopts = rocksdb_ffi::rocksdb_writeoptions_create();
-      let err = 0 as *mut i8;
-      rocksdb_ffi::rocksdb_put(self.inner, writeopts, key.as_ptr(),
-            key.len() as size_t, value.as_ptr(),
-            value.len() as size_t, err);
-      if err.is_not_null() {
-        let cs = CString::new(err as *const i8, true);
-        match cs.as_str() {
-          Some(error_string) =>
-            return Err(error_string.to_string()),
-          None => {
-            let ie = IoError::last_error();
-            return Err(format!(
-                "ERROR: desc:{}, details:{}",
-                ie.desc,
-                ie.detail.unwrap_or_else(
-                  || {"none provided by OS".to_string()})))
-          }
+    pub fn put(&self, key: &[u8], value: &[u8]) -> Result<(), String> {
+        unsafe {
+            let writeopts = rocksdb_ffi::rocksdb_writeoptions_create();
+            let err = 0 as *mut i8;
+            rocksdb_ffi::rocksdb_put(self.inner, writeopts, key.as_ptr(),
+                        key.len() as size_t, value.as_ptr(),
+                        value.len() as size_t, err);
+            if err.is_not_null() {
+                let cs = CString::new(err as *const i8, true);
+                match cs.as_str() {
+                    Some(error_string) =>
+                        return Err(error_string.to_string()),
+                    None => {
+                        let ie = IoError::last_error();
+                        return Err(format!(
+                                "ERROR: desc:{}, details:{}",
+                                ie.desc,
+                                ie.detail.unwrap_or_else(
+                                    || {"none provided by OS".to_string()})))
+                    }
+                }
+            }
+            return Ok(())
         }
-      }
-      return Ok(())
     }
-  }
 
-  pub fn get<'a>(&self, key: &[u8]) -> RocksDBResult<'a, RocksDBVector, String> {
-    unsafe {
-      let readopts = rocksdb_ffi::rocksdb_readoptions_create();
-      let rocksdb_ffi::RocksDBReadOptions(read_opts_ptr) = readopts;
-      if read_opts_ptr.is_null() {
-        return RocksDBResult::Error("Unable to create rocksdb read \
-          options.  This is a fairly trivial call, and its failure \
-          may be indicative of a mis-compiled or mis-loaded rocksdb \
-          library.".to_string());
-      }
+    pub fn get<'a>(&self, key: &[u8]) ->
+        RocksDBResult<'a, RocksDBVector, String> {
+        unsafe {
+            let readopts = rocksdb_ffi::rocksdb_readoptions_create();
+            let rocksdb_ffi::RocksDBReadOptions(read_opts_ptr) = readopts;
+            if read_opts_ptr.is_null() {
+                return RocksDBResult::Error("Unable to create rocksdb read \
+                    options.  This is a fairly trivial call, and its failure \
+                    may be indicative of a mis-compiled or mis-loaded rocksdb \
+                    library.".to_string());
+            }
 
-      let val_len: size_t = 0;
-      let val_len_ptr = &val_len as *const size_t;
-      let err = 0 as *mut i8;
-      let val = rocksdb_ffi::rocksdb_get(self.inner, readopts, key.as_ptr(),
-                  key.len() as size_t, val_len_ptr, err) as *mut u8;
-      if err.is_not_null() {
-        let cs = CString::new(err as *const i8, true);
-        match cs.as_str() {
-          Some(error_string) =>
-            return RocksDBResult::Error(error_string.to_string()),
-          None =>
-            return RocksDBResult::Error("Unable to get value from \
-              rocksdb. (non-utf8 error received from underlying \
-              library)".to_string()),
-        }
-      }
-      match val.is_null() {
-        true =>  RocksDBResult::None,
-        false => {
-          RocksDBResult::Some(RocksDBVector::from_c(val, val_len))
+            let val_len: size_t = 0;
+            let val_len_ptr = &val_len as *const size_t;
+            let err = 0 as *mut i8;
+            let val = rocksdb_ffi::rocksdb_get(self.inner, readopts,
+                key.as_ptr(), key.len() as size_t, val_len_ptr, err) as *mut u8;
+            if err.is_not_null() {
+                let cs = CString::new(err as *const i8, true);
+                match cs.as_str() {
+                    Some(error_string) =>
+                        return RocksDBResult::Error(error_string.to_string()),
+                    None =>
+                        return RocksDBResult::Error("Unable to get value from \
+                            rocksdb. (non-utf8 error received from underlying \
+                            library)".to_string()),
+                }
+            }
+            match val.is_null() {
+                true =>    RocksDBResult::None,
+                false => {
+                    RocksDBResult::Some(RocksDBVector::from_c(val, val_len))
+                }
+            }
         }
-      }
     }
-  }
 
-  pub fn delete(&self, key: &[u8]) -> Result<(),String> {
-    unsafe {
-      let writeopts = rocksdb_ffi::rocksdb_writeoptions_create();
-      let err = 0 as *mut i8;
-      rocksdb_ffi::rocksdb_delete(self.inner, writeopts, key.as_ptr(),
-            key.len() as size_t, err);
-      if err.is_not_null() {
-        let cs = CString::new(err as *const i8, true);
-        match cs.as_str() {
-          Some(error_string) =>
-            return Err(error_string.to_string()),
-          None => {
-            let ie = IoError::last_error();
-            return Err(format!(
-                "ERROR: desc:{}, details:{}",
-                ie.desc,
-                ie.detail.unwrap_or_else(
-                  || {"none provided by OS".to_string()})))
-          }
+    pub fn delete(&self, key: &[u8]) -> Result<(),String> {
+        unsafe {
+            let writeopts = rocksdb_ffi::rocksdb_writeoptions_create();
+            let err = 0 as *mut i8;
+            rocksdb_ffi::rocksdb_delete(self.inner, writeopts, key.as_ptr(),
+                        key.len() as size_t, err);
+            if err.is_not_null() {
+                let cs = CString::new(err as *const i8, true);
+                match cs.as_str() {
+                    Some(error_string) =>
+                        return Err(error_string.to_string()),
+                    None => {
+                        let ie = IoError::last_error();
+                        return Err(format!(
+                                "ERROR: desc:{}, details:{}",
+                                ie.desc,
+                                ie.detail.unwrap_or_else(
+                                    || {"none provided by OS".to_string()})))
+                    }
+                }
+            }
+            return Ok(())
         }
-      }
-      return Ok(())
     }
-  }
 
-  pub fn close(&self) {
-    unsafe { rocksdb_ffi::rocksdb_close(self.inner); }
-  }
+    pub fn close(&self) {
+        unsafe { rocksdb_ffi::rocksdb_close(self.inner); }
+    }
 }
 
 pub struct RocksDBVector {
-  inner: CVec<u8>,
+    inner: CVec<u8>,
 }
 
 impl RocksDBVector {
-  pub fn from_c(val: *mut u8, val_len: size_t) -> RocksDBVector {
-    unsafe {
-      RocksDBVector {
-        inner:
-          CVec::new_with_dtor(val, val_len as uint,
-            proc(){ libc::free(val as *mut c_void); })
-      }
+    pub fn from_c(val: *mut u8, val_len: size_t) -> RocksDBVector {
+        unsafe {
+            RocksDBVector {
+                inner:
+                    CVec::new_with_dtor(val, val_len as uint,
+                        proc(){ libc::free(val as *mut c_void); })
+            }
+        }
     }
-  }
 
-  pub fn as_slice<'a>(&'a self) -> &'a [u8] {
-    self.inner.as_slice()
-  }
+    pub fn as_slice<'a>(&'a self) -> &'a [u8] {
+        self.inner.as_slice()
+    }
 
-  pub fn to_utf8<'a>(&'a self) -> Option<&'a str> {
-    from_utf8(self.inner.as_slice())
-  }
+    pub fn to_utf8<'a>(&'a self) -> Option<&'a str> {
+        from_utf8(self.inner.as_slice())
+    }
 }
 
 // RocksDBResult exists because of the inherent difference between
 // an operational failure and the absence of a possible result.
 #[deriving(Clone, PartialEq, PartialOrd, Eq, Ord, Show)]
 pub enum RocksDBResult<'a,T,E> {
-  Some(T),
-  None,
-  Error(E),
+    Some(T),
+    None,
+    Error(E),
 }
 
 impl <'a,T,E> RocksDBResult<'a,T,E> {
-  #[unstable = "waiting for unboxed closures"]
-  pub fn map<U>(self, f: |T| -> U) -> RocksDBResult<U,E> {
-    match self {
-      RocksDBResult::Some(x) => RocksDBResult::Some(f(x)),
-      RocksDBResult::None => RocksDBResult::None,
-      RocksDBResult::Error(e) => RocksDBResult::Error(e),
+    #[unstable = "waiting for unboxed closures"]
+    pub fn map<U>(self, f: |T| -> U) -> RocksDBResult<U,E> {
+        match self {
+            RocksDBResult::Some(x) => RocksDBResult::Some(f(x)),
+            RocksDBResult::None => RocksDBResult::None,
+            RocksDBResult::Error(e) => RocksDBResult::Error(e),
+        }
     }
-  }
 
-  pub fn unwrap(self) -> T {
-    match self {
-      RocksDBResult::Some(x) => x,
-      RocksDBResult::None => panic!("Attempted unwrap on RocksDBResult::None"),
-      RocksDBResult::Error(_) => panic!("Attempted unwrap on RocksDBResult::Error"),
+    pub fn unwrap(self) -> T {
+        match self {
+            RocksDBResult::Some(x) => x,
+            RocksDBResult::None =>
+                panic!("Attempted unwrap on RocksDBResult::None"),
+            RocksDBResult::Error(_) =>
+                panic!("Attempted unwrap on RocksDBResult::Error"),
+        }
     }
-  }
 
-  #[unstable = "waiting for unboxed closures"]
-  pub fn on_error<U>(self, f: |E| -> U) -> RocksDBResult<T,U> {
-    match self {
-      RocksDBResult::Some(x) => RocksDBResult::Some(x),
-      RocksDBResult::None => RocksDBResult::None,
-      RocksDBResult::Error(e) => RocksDBResult::Error(f(e)),
+    #[unstable = "waiting for unboxed closures"]
+    pub fn on_error<U>(self, f: |E| -> U) -> RocksDBResult<T,U> {
+        match self {
+            RocksDBResult::Some(x) => RocksDBResult::Some(x),
+            RocksDBResult::None => RocksDBResult::None,
+            RocksDBResult::Error(e) => RocksDBResult::Error(f(e)),
+        }
     }
-  }
 
-  #[unstable = "waiting for unboxed closures"]
-  pub fn on_absent(self, f: || -> ()) -> RocksDBResult<T,E> {
-    match self {
-      RocksDBResult::Some(x) => RocksDBResult::Some(x),
-      RocksDBResult::None => {
-        f();
-        RocksDBResult::None
-      },
-      RocksDBResult::Error(e) => RocksDBResult::Error(e),
+    #[unstable = "waiting for unboxed closures"]
+    pub fn on_absent(self, f: || -> ()) -> RocksDBResult<T,E> {
+        match self {
+            RocksDBResult::Some(x) => RocksDBResult::Some(x),
+            RocksDBResult::None => {
+                f();
+                RocksDBResult::None
+            },
+            RocksDBResult::Error(e) => RocksDBResult::Error(e),
+        }
     }
-  }
 
-  pub fn is_some(self) -> bool {
-    match self {
-      RocksDBResult::Some(_) => true,
-      RocksDBResult::None => false,
-      RocksDBResult::Error(_) => false,
+    pub fn is_some(self) -> bool {
+        match self {
+            RocksDBResult::Some(_) => true,
+            RocksDBResult::None => false,
+            RocksDBResult::Error(_) => false,
+        }
     }
-  }
-  pub fn is_none(self) -> bool {
-    match self {
-      RocksDBResult::Some(_) => false,
-      RocksDBResult::None => true,
-      RocksDBResult::Error(_) => false,
+    pub fn is_none(self) -> bool {
+        match self {
+            RocksDBResult::Some(_) => false,
+            RocksDBResult::None => true,
+            RocksDBResult::Error(_) => false,
+        }
     }
-  }
-  pub fn is_error(self) -> bool {
-    match self {
-      RocksDBResult::Some(_) => false,
-      RocksDBResult::None => false,
-      RocksDBResult::Error(_) => true,
+    pub fn is_error(self) -> bool {
+        match self {
+            RocksDBResult::Some(_) => false,
+            RocksDBResult::None => false,
+            RocksDBResult::Error(_) => true,
+        }
     }
-  }
 }
 
 #[allow(dead_code)]
 #[test]
 fn external() {
-  let db = RocksDB::open_default("externaltest").unwrap();
-  let p = db.put(b"k1", b"v1111");
-  assert!(p.is_ok());
-  let r: RocksDBResult<RocksDBVector, String> = db.get(b"k1");
-  assert!(r.unwrap().to_utf8().unwrap() == "v1111");
-  assert!(db.delete(b"k1").is_ok());
-  assert!(db.get(b"k1").is_none());
-  db.close();
+    let db = RocksDB::open_default("externaltest").unwrap();
+    let p = db.put(b"k1", b"v1111");
+    assert!(p.is_ok());
+    let r: RocksDBResult<RocksDBVector, String> = db.get(b"k1");
+    assert!(r.unwrap().to_utf8().unwrap() == "v1111");
+    assert!(db.delete(b"k1").is_ok());
+    assert!(db.get(b"k1").is_none());
+    db.close();
 }