Rocksdb -> RocksDB

README.md

@@ -11,10 +11,10 @@ RocksDB 3.8.1 will be pulled in and compiled automatically.
 ###### Code
 ```rust
 extern crate rocksdb;
-use rocksdb::Rocksdb;
+use rocksdb::RocksDB;
 
 fn main() {
-  match Rocksdb::open_default("/path/for/rocksdb/storage") {
+  match RocksDB::open_default("/path/for/rocksdb/storage") {
     Ok(db) => {
       db.put(b"my key", b"my value");
 

rocksdb-sys/lib.rs

@@ -2,116 +2,116 @@ extern crate libc;
 use self::libc::{c_char, c_int, c_void, size_t};
 
 #[repr(C)]
-pub struct RocksdbOptions(pub *const c_void);
+pub struct RocksDBOptions(pub *const c_void);
 #[repr(C)]
-pub struct RocksdbInstance(pub *const c_void);
+pub struct RocksDBInstance(pub *const c_void);
 #[repr(C)]
-pub struct RocksdbWriteOptions(pub *const c_void);
+pub struct RocksDBWriteOptions(pub *const c_void);
 #[repr(C)]
-pub struct RocksdbReadOptions(pub *const c_void);
+pub struct RocksDBReadOptions(pub *const c_void);
 #[repr(C)]
-pub struct RocksdbCompactionFilter(pub *const c_void);
+pub struct RocksDBCompactionFilter(pub *const c_void);
 #[repr(C)]
-pub struct RocksdbMergeOperator(pub *const c_void);
+pub struct RocksDBMergeOperator(pub *const c_void);
 #[repr(C)]
-pub struct RocksdbFilterPolicy(pub *const c_void);
+pub struct RocksDBFilterPolicy(pub *const c_void);
 
 #[repr(C)]
-pub enum RocksdbCompressionType {
-  RocksdbNoCompression   = 0,
-  RocksdbSnappyCompression = 1,
-  RocksdbZlibCompression   = 2,
-  RocksdbBz2Compression  = 3,
-  RocksdbLz4Compression  = 4,
-  RocksdbLz4hcCompression  = 5
+pub enum RocksDBCompressionType {
+  RocksDBNoCompression   = 0,
+  RocksDBSnappyCompression = 1,
+  RocksDBZlibCompression   = 2,
+  RocksDBBz2Compression  = 3,
+  RocksDBLz4Compression  = 4,
+  RocksDBLz4hcCompression  = 5
 }
 
 #[repr(C)]
-pub enum RocksdbCompactionStyle {
-  RocksdbLevelCompaction   = 0,
-  RocksdbUniversalCompaction = 1,
-  RocksdbFifoCompaction    = 2
+pub enum RocksDBCompactionStyle {
+  RocksDBLevelCompaction   = 0,
+  RocksDBUniversalCompaction = 1,
+  RocksDBFifoCompaction    = 2
 }
 
 #[repr(C)]
-pub enum RocksdbUniversalCompactionStyle {
+pub enum RocksDBUniversalCompactionStyle {
   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_create() -> RocksDBOptions;
   pub fn rocksdb_options_increase_parallelism(
-    options: RocksdbOptions, threads: c_int);
+    options: RocksDBOptions, threads: c_int);
   pub fn rocksdb_options_optimize_level_style_compaction(
-    options: RocksdbOptions, memtable_memory_budget: c_int);
+    options: RocksDBOptions, memtable_memory_budget: c_int);
   pub fn rocksdb_options_set_create_if_missing(
-    options: RocksdbOptions, v: c_int);
+    options: RocksDBOptions, v: c_int);
   pub fn rocksdb_options_set_max_open_files(
-    options: RocksdbOptions, files: c_int);
+    options: RocksDBOptions, files: c_int);
   pub fn rocksdb_options_set_use_fsync(
-    options: RocksdbOptions, v: c_int);
+    options: RocksDBOptions, v: c_int);
   pub fn rocksdb_options_set_bytes_per_sync(
-    options: RocksdbOptions, bytes: u64);
+    options: RocksDBOptions, bytes: u64);
   pub fn rocksdb_options_set_disable_data_sync(
-    options: RocksdbOptions, v: c_int);
+    options: RocksDBOptions, v: c_int);
   pub fn rocksdb_options_optimize_for_point_lookup(
-    options: RocksdbOptions, block_cache_size_mb: u64);
+    options: RocksDBOptions, block_cache_size_mb: u64);
   pub fn rocksdb_options_set_table_cache_numshardbits(
-    options: RocksdbOptions, bits: u64);
+    options: RocksDBOptions, bits: u64);
   pub fn rocksdb_options_set_max_write_buffer_number(
-    options: RocksdbOptions, bufno: c_int);
+    options: RocksDBOptions, bufno: c_int);
   pub fn rocksdb_options_set_min_write_buffer_number_to_merge(
-    options: RocksdbOptions, bufno: c_int);
+    options: RocksDBOptions, bufno: c_int);
   pub fn rocksdb_options_set_level0_file_num_compaction_trigger(
-    options: RocksdbOptions, no: c_int);
+    options: RocksDBOptions, no: c_int);
   pub fn rocksdb_options_set_level0_slowdown_writes_trigger(
-    options: RocksdbOptions, no: c_int);
+    options: RocksDBOptions, no: c_int);
   pub fn rocksdb_options_set_level0_stop_writes_trigger(
-    options: RocksdbOptions, no: c_int);
+    options: RocksDBOptions, no: c_int);
   pub fn rocksdb_options_set_write_buffer_size(
-    options: RocksdbOptions, bytes: u64);
+    options: RocksDBOptions, bytes: u64);
   pub fn rocksdb_options_set_target_file_size_base(
-    options: RocksdbOptions, bytes: u64);
+    options: RocksDBOptions, bytes: u64);
   pub fn rocksdb_options_set_target_file_size_multiplier(
-    options: RocksdbOptions, mul: c_int);
+    options: RocksDBOptions, mul: c_int);
   pub fn rocksdb_options_set_max_log_file_size(
-    options: RocksdbOptions, bytes: u64);
+    options: RocksDBOptions, bytes: u64);
   pub fn rocksdb_options_set_max_manifest_file_size(
-    options: RocksdbOptions, bytes: u64);
+    options: RocksDBOptions, bytes: u64);
   pub fn rocksdb_options_set_hash_skip_list_rep(
-    options: RocksdbOptions, bytes: u64, a1: i32, a2: i32);
+    options: RocksDBOptions, bytes: u64, a1: i32, a2: i32);
   pub fn rocksdb_options_set_compaction_style(
-    options: RocksdbOptions, cs: RocksdbCompactionStyle);
+    options: RocksDBOptions, cs: RocksDBCompactionStyle);
   pub fn rocksdb_options_set_compression(
-    options: RocksdbOptions, compression_style_no: c_int);
+    options: RocksDBOptions, compression_style_no: c_int);
   pub fn rocksdb_options_set_max_background_compactions(
-    options: RocksdbOptions, max_bg_compactions: c_int);
+    options: RocksDBOptions, max_bg_compactions: c_int);
   pub fn rocksdb_options_set_max_background_flushes(
-    options: RocksdbOptions, max_bg_flushes: c_int);
+    options: RocksDBOptions, max_bg_flushes: c_int);
   pub fn rocksdb_options_set_filter_deletes(
-    options: RocksdbOptions, v: u8);
-  //pub fn rocksdb_compactionfilter_create() -> RocksdbCompactionFilter;
+    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,
+    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,
+  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,
+  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_close(db: RocksDBInstance);
   pub fn rocksdb_destroy_db(
-    options: RocksdbOptions, path: *const i8, err: *mut i8);
+    options: RocksDBOptions, path: *const i8, err: *mut i8);
   pub fn rocksdb_repair_db(
-    options: RocksdbOptions, path: *const i8, err: *mut i8);
+    options: RocksDBOptions, path: *const i8, err: *mut i8);
 
   // Merge Operator
   pub fn rocksdb_mergeoperator_create(
@@ -132,11 +132,11 @@ extern {
     ) -> *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);
+  ) -> RocksDBMergeOperator;
+  pub fn rocksdb_mergeoperator_destroy(mo: RocksDBMergeOperator);
   pub fn rocksdb_options_set_merge_operator(
-    options: RocksdbOptions,
-    mo: RocksdbMergeOperator);
+    options: RocksDBOptions,
+    mo: RocksDBMergeOperator);
 }
 
 #[allow(dead_code)]
@@ -144,7 +144,7 @@ extern {
 fn internal() {
   unsafe {
     let opts = rocksdb_options_create();
-    let RocksdbOptions(opt_ptr) = opts;
+    let RocksDBOptions(opt_ptr) = opts;
     assert!(opt_ptr.is_not_null());
 
     rocksdb_options_increase_parallelism(opts, 0);
@@ -161,7 +161,7 @@ fn internal() {
     libc::free(err as *mut c_void);
 
     let writeopts = rocksdb_writeoptions_create();
-    let RocksdbWriteOptions(write_opt_ptr) = writeopts;
+    let RocksDBWriteOptions(write_opt_ptr) = writeopts;
     assert!(write_opt_ptr.is_not_null());
 
     let key = b"name\x00";
@@ -172,7 +172,7 @@ fn internal() {
     libc::free(err as *mut c_void);
 
     let readopts = rocksdb_readoptions_create();
-    let RocksdbReadOptions(read_opts_ptr) = readopts;
+    let RocksDBReadOptions(read_opts_ptr) = readopts;
     assert!(read_opts_ptr.is_not_null());
     libc::free(err as *mut c_void);
 

src/lib.rs

@@ -5,7 +5,7 @@
 extern crate "rocksdb-sys" as rocksdb_ffi;
 
 pub use rocksdb::{
-  Rocksdb,
-  RocksdbResult,
+  RocksDB,
+  RocksDBResult,
 };
 pub mod rocksdb;

src/main.rs

@@ -1,11 +1,11 @@
 extern crate rocksdb;
 extern crate test;
-use rocksdb::Rocksdb;
+use rocksdb::RocksDB;
 use test::Bencher;
 
 #[allow(dead_code)]
 fn main() {
-  match Rocksdb::open_default("/tmp/rust-rocksdb") {
+  match RocksDB::open_default("/tmp/rust-rocksdb") {
     Ok(db) => {
       assert!(db.put(b"my key", b"my value").is_ok());
 
@@ -31,7 +31,7 @@ fn main() {
 #[allow(dead_code)]
 #[bench]
 fn writes(b: &mut Bencher) {
-  let db = Rocksdb::open_default("testdb").unwrap();
+  let db = RocksDB::open_default("testdb").unwrap();
   let mut i = 0 as u64;
   b.iter(|| {
     db.put(i.to_string().as_bytes(), b"v1111");
@@ -43,7 +43,7 @@ fn writes(b: &mut Bencher) {
 #[allow(dead_code)]
 #[bench]
 fn reads(b: &mut Bencher) {
-  let db = Rocksdb::open_default("testdb").unwrap();
+  let db = RocksDB::open_default("testdb").unwrap();
   let mut i = 0 as u64;
   b.iter(|| {
     db.get(i.to_string().as_bytes()).on_error(

src/rocksdb.rs

@@ -7,20 +7,20 @@ use std::str::from_utf8;
 
 use rocksdb_ffi;
 
-pub struct RocksdbOptions {
-  inner: rocksdb_ffi::RocksdbOptions,
+pub struct RocksDBOptions {
+  inner: rocksdb_ffi::RocksDBOptions,
 }
 
-impl RocksdbOptions {
-  pub fn new() -> RocksdbOptions {
+impl RocksDBOptions {
+  pub fn new() -> RocksDBOptions {
     unsafe {
       let opts = rocksdb_ffi::rocksdb_options_create();
-      let rocksdb_ffi::RocksdbOptions(opt_ptr) = opts;
+      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}
     }
   }
 
@@ -45,25 +45,25 @@ impl RocksdbOptions {
     }
   }
 
-  pub fn set_merge_operator(&self, mo: rocksdb_ffi::RocksdbMergeOperator) {
+  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,
+pub struct RocksDB {
+  inner: rocksdb_ffi::RocksDBInstance,
 }
 
-impl Rocksdb {
-  pub fn open_default(path: &str) -> Result<Rocksdb, String> {
-    let opts = RocksdbOptions::new();
+impl RocksDB {
+  pub fn open_default(path: &str) -> Result<RocksDB, String> {
+    let opts = RocksDBOptions::new();
     opts.create_if_missing(true);
-    Rocksdb::open(opts, path)
+    RocksDB::open(opts, path)
   }
 
-  pub fn open(opts: RocksdbOptions, path: &str) -> Result<Rocksdb, String> {
+  pub fn open(opts: RocksDBOptions, path: &str) -> Result<RocksDB, String> {
     unsafe {
       let cpath = path.to_c_str();
       let cpath_ptr = cpath.as_ptr();
@@ -73,7 +73,7 @@ impl Rocksdb {
 
       let err = 0 as *mut i8;
       let db = rocksdb_ffi::rocksdb_open(opts.inner, cpath_ptr, err);
-      let rocksdb_ffi::RocksdbInstance(db_ptr) = db;
+      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() {
@@ -86,7 +86,7 @@ impl Rocksdb {
       if db_ptr.is_null() {
         return Err("Could not initialize database.".to_string());
       }
-      Ok(Rocksdb{inner: db})
+      Ok(RocksDB{inner: db})
     }
   }
 
@@ -116,12 +116,12 @@ impl Rocksdb {
     }
   }
 
-  pub fn get<'a>(&self, key: &[u8]) -> RocksdbResult<'a, RocksdbVector, 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;
+      let rocksdb_ffi::RocksDBReadOptions(read_opts_ptr) = readopts;
       if read_opts_ptr.is_null() {
-        return RocksdbResult::Error("Unable to create rocksdb read \
+        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());
@@ -136,17 +136,17 @@ impl Rocksdb {
         let cs = CString::new(err as *const i8, true);
         match cs.as_str() {
           Some(error_string) =>
-            return RocksdbResult::Error(error_string.to_string()),
+            return RocksDBResult::Error(error_string.to_string()),
           None =>
-            return RocksdbResult::Error("Unable to get value from \
+            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,
+        true =>  RocksDBResult::None,
         false => {
-          RocksdbResult::Some(RocksdbVector::from_c(val, val_len))
+          RocksDBResult::Some(RocksDBVector::from_c(val, val_len))
         }
       }
     }
@@ -182,14 +182,14 @@ impl Rocksdb {
   }
 }
 
-pub struct RocksdbVector {
+pub struct RocksDBVector {
   inner: CVec<u8>,
 }
 
-impl RocksdbVector {
-  pub fn from_c(val: *mut u8, val_len: size_t) -> RocksdbVector {
+impl RocksDBVector {
+  pub fn from_c(val: *mut u8, val_len: size_t) -> RocksDBVector {
     unsafe {
-      RocksdbVector {
+      RocksDBVector {
         inner:
           CVec::new_with_dtor(val, val_len as uint,
             proc(){ libc::free(val as *mut c_void); })
@@ -206,73 +206,73 @@ impl RocksdbVector {
   }
 }
 
-// RocksdbResult exists because of the inherent difference between
+// 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> {
+pub enum RocksDBResult<'a,T,E> {
   Some(T),
   None,
   Error(E),
 }
 
-impl <'a,T,E> RocksdbResult<'a,T,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> {
+  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),
+      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"),
+      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> {
+  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)),
+      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> {
+  pub fn on_absent(self, f: || -> ()) -> RocksDBResult<T,E> {
     match self {
-      RocksdbResult::Some(x) => RocksdbResult::Some(x),
-      RocksdbResult::None => {
+      RocksDBResult::Some(x) => RocksDBResult::Some(x),
+      RocksDBResult::None => {
         f();
-        RocksdbResult::None
+        RocksDBResult::None
       },
-      RocksdbResult::Error(e) => RocksdbResult::Error(e),
+      RocksDBResult::Error(e) => RocksDBResult::Error(e),
     }
   }
 
   pub fn is_some(self) -> bool {
     match self {
-      RocksdbResult::Some(_) => true,
-      RocksdbResult::None => false,
-      RocksdbResult::Error(_) => false,
+      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,
+      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,
+      RocksDBResult::Some(_) => false,
+      RocksDBResult::None => false,
+      RocksDBResult::Error(_) => true,
     }
   }
 }
@@ -280,10 +280,10 @@ impl <'a,T,E> RocksdbResult<'a,T,E> {
 #[allow(dead_code)]
 #[test]
 fn external() {
-  let db = Rocksdb::open_default("externaltest").unwrap();
+  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");
+  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());