spacing

rocksdb-sys/build.rs

@@ -7,49 +7,49 @@ use std::io::process::InheritFd;
 //TODO windows support
 
 fn main() {
-    // Next, fall back and try to use pkg-config if its available.
-    match pkg_config::find_library("librocksdb") {
-        Ok(()) => return,
-        Err(..) => {}
-    }
-
-    let src = os::getcwd().unwrap();
-    let dst = Path::new(os::getenv("OUT_DIR").unwrap());
-
-    let _ = fs::mkdir(&dst.join("build"), io::USER_DIR);
-
-    println!("cwd: {}", src.join("rocksdb").as_str());
-    run(Command::new(make())
-                .arg("shared_lib")
-                .arg(format!("-j{}", os::getenv("NUM_JOBS").unwrap()))
-                .cwd(&src.join("rocksdb")));
-
-    // Don't run `make install` because apparently it's a little buggy on mingw
-    // for windows.
-    fs::mkdir_recursive(&dst.join("lib/pkgconfig"), io::USER_DIR).unwrap();
-
-    let target = os::getenv("TARGET").unwrap();
-    if target.contains("apple") {
-        fs::rename(&src.join("rocksdb/librocksdb.dylib"), &dst.join("lib/librocksdb.dylib")).unwrap();
-    } else {
-        fs::rename(&src.join("rocksdb/librocksdb.so"), &dst.join("lib/librocksdb.so")).unwrap();
-    }
-
-    println!("cargo:rustc-flags=-L {}/lib -l rocksdb:dylib", dst.display());
-    println!("cargo:root={}", dst.display());
-    println!("cargo:include={}/include", src.join("rocksdb").display());
+  // Next, fall back and try to use pkg-config if its available.
+  match pkg_config::find_library("librocksdb") {
+    Ok(()) => return,
+    Err(..) => {}
+  }
+
+  let src = os::getcwd().unwrap();
+  let dst = Path::new(os::getenv("OUT_DIR").unwrap());
+
+  let _ = fs::mkdir(&dst.join("build"), io::USER_DIR);
+
+  println!("cwd: {}", src.join("rocksdb").as_str());
+  run(Command::new(make())
+        .arg("shared_lib")
+        .arg(format!("-j{}", os::getenv("NUM_JOBS").unwrap()))
+        .cwd(&src.join("rocksdb")));
+
+  // Don't run `make install` because apparently it's a little buggy on mingw
+  // for windows.
+  fs::mkdir_recursive(&dst.join("lib/pkgconfig"), io::USER_DIR).unwrap();
+
+  let target = os::getenv("TARGET").unwrap();
+  if target.contains("apple") {
+    fs::rename(&src.join("rocksdb/librocksdb.dylib"), &dst.join("lib/librocksdb.dylib")).unwrap();
+  } else {
+    fs::rename(&src.join("rocksdb/librocksdb.so"), &dst.join("lib/librocksdb.so")).unwrap();
+  }
+
+  println!("cargo:rustc-flags=-L {}/lib -l rocksdb:dylib", dst.display());
+  println!("cargo:root={}", dst.display());
+  println!("cargo:include={}/include", src.join("rocksdb").display());
 }
 
 fn run(cmd: &mut Command) {
-    println!("running: {}", cmd);
-    assert!(cmd.stdout(InheritFd(1))
-               .stderr(InheritFd(2))
-               .status()
-               .unwrap()
-               .success());
+  println!("running: {}", cmd);
+  assert!(cmd.stdout(InheritFd(1))
+         .stderr(InheritFd(2))
+         .status()
+         .unwrap()
+         .success());
 
 }
 
 fn make() -> &'static str {
-    if cfg!(target_os = "freebsd") {"gmake"} else {"make"}
+  if cfg!(target_os = "freebsd") {"gmake"} else {"make"}
 }

rocksdb-sys/lib.rs

@@ -18,19 +18,19 @@ pub struct RocksdbFilterPolicy(pub *const c_void);
 
 #[repr(C)]
 pub enum RocksdbCompressionType {
-  RocksdbNoCompression     = 0,
+  RocksdbNoCompression   = 0,
   RocksdbSnappyCompression = 1,
   RocksdbZlibCompression   = 2,
-  RocksdbBz2Compression    = 3,
-  RocksdbLz4Compression    = 4,
+  RocksdbBz2Compression  = 3,
+  RocksdbLz4Compression  = 4,
   RocksdbLz4hcCompression  = 5
 }
 
 #[repr(C)]
 pub enum RocksdbCompactionStyle {
-  RocksdbLevelCompaction     = 0,
+  RocksdbLevelCompaction   = 0,
   RocksdbUniversalCompaction = 1,
-  RocksdbFifoCompaction      = 2
+  RocksdbFifoCompaction    = 2
 }
 
 #[repr(C)]
@@ -41,76 +41,76 @@ pub enum RocksdbUniversalCompactionStyle {
 
 #[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_mergeoperator_create() -> RocksdbMergeOperator;
-    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_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_mergeoperator_create() -> RocksdbMergeOperator;
+  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_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);
 
 
 }
@@ -118,45 +118,45 @@ extern {
 #[allow(dead_code)]
 #[test]
 fn internal() {
-    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);
-
-        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 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";
-
-        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 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);
-    }
+  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);
+
+    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 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";
+
+    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 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

@@ -5,9 +5,9 @@
 extern crate "rocksdb-sys" as rocksdb_ffi;
 
 pub use rocksdb::{
-    create_or_open,
-    open,
-    Rocksdb,
-    RocksdbResult,
+  create_or_open,
+  open,
+  Rocksdb,
+  RocksdbResult,
 };
 pub mod rocksdb;

src/main.rs

@@ -5,50 +5,50 @@ use test::Bencher;
 
 #[allow(dead_code)]
 fn main() {
-    match rocksdb::create_or_open("/tmp/rust-rocksdb".to_string()) {
-        Ok(db) => {
-            db.put(b"my key", b"my value");
+  match rocksdb::create_or_open("/tmp/rust-rocksdb".to_string()) {
+    Ok(db) => {
+      db.put(b"my key", b"my value");
 
-            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"),
-                }});
+      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"),
+        }});
 
-            db.get(b"NOT my key").on_absent(|| { println!("value not found") });
+      db.get(b"NOT my key").on_absent(|| { println!("value not found") });
 
-            db.close();
-        },
-        Err(e) => panic!(e),
-    }
+      db.close();
+    },
+    Err(e) => panic!(e),
+  }
 }
 
 #[allow(dead_code)]
 #[bench]
 fn writes(b: &mut Bencher) {
-    let db = open("testdb".to_string(), true).unwrap();
-    let mut i = 0 as u64;
-    b.iter(|| {
-        db.put(i.to_string().as_bytes(), b"v1111");
-        i += 1;
-    });
-    db.close();
+  let db = open("testdb".to_string(), true).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 = open("testdb".to_string(), true).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 = open("testdb".to_string(), true).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,171 +8,171 @@ use std::str::from_utf8;
 use rocksdb_ffi;
 
 pub struct Rocksdb {
-    inner: rocksdb_ffi::RocksdbInstance,
+  inner: rocksdb_ffi::RocksdbInstance,
 }
 
 impl Rocksdb {
-    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(())
+  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(())
     }
+  }
 
-    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))
-                }
-            }
+  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))
+        }
+      }
     }
+  }
 
-    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,
     }
+  }
 }
 
 pub fn create_or_open(path: String) -> Result<Rocksdb, String> {
@@ -180,54 +180,54 @@ pub fn create_or_open(path: String) -> Result<Rocksdb, String> {
 }
 
 pub fn open(path: String, create_if_missing: bool) -> Result<Rocksdb, String> {
-    unsafe {
-        let opts = rocksdb_ffi::rocksdb_options_create();
-        let rocksdb_ffi::RocksdbOptions(opt_ptr) = opts;
-        if opt_ptr.is_null() {
-            return Err("Could not create options".to_string());
-        }
+  unsafe {
+    let opts = rocksdb_ffi::rocksdb_options_create();
+    let rocksdb_ffi::RocksdbOptions(opt_ptr) = opts;
+    if opt_ptr.is_null() {
+      return Err("Could not create options".to_string());
+    }
 
-        //rocksdb_ffi::rocksdb_options_increase_parallelism(opts, 2);
-        //rocksdb_ffi::rocksdb_options_optimize_level_style_compaction(opts, 0);
+    //rocksdb_ffi::rocksdb_options_increase_parallelism(opts, 2);
+    //rocksdb_ffi::rocksdb_options_optimize_level_style_compaction(opts, 0);
 
-        match create_if_missing {
-            true => rocksdb_ffi::rocksdb_options_set_create_if_missing(opts, 1),
-            false => rocksdb_ffi::rocksdb_options_set_create_if_missing(opts, 0),
-        }
+    match create_if_missing {
+      true => rocksdb_ffi::rocksdb_options_set_create_if_missing(opts, 1),
+      false => rocksdb_ffi::rocksdb_options_set_create_if_missing(opts, 0),
+    }
 
-        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
-
-        let err = 0 as *mut i8;
-        let db = rocksdb_ffi::rocksdb_open(opts, 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})
+    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
+
+    let err = 0 as *mut i8;
+    let db = rocksdb_ffi::rocksdb_open(opts, 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})
+  }
 }
 
 #[allow(dead_code)]
 #[test]
 fn external() {
-    let db = open("externaltest".to_string(), true).unwrap();
-    let p = db.put(b"k1", b"v1111");
-    assert!(p.is_ok());
-    let r: RocksdbResult<RocksdbVector, String> = db.get(b"k1");
-    //assert!(r.is_some());
-    r.map(|v| { assert!(v.as_slice().len() == 5); } );
-    db.close();
+  let db = open("externaltest".to_string(), true).unwrap();
+  let p = db.put(b"k1", b"v1111");
+  assert!(p.is_ok());
+  let r: RocksdbResult<RocksdbVector, String> = db.get(b"k1");
+  //assert!(r.is_some());
+  r.map(|v| { assert!(v.as_slice().len() == 5); } );
+  db.close();
 }