From e585d23e27c265d1034b79478612658459b93fe1 Mon Sep 17 00:00:00 2001 From: Tyler Neely Date: Sat, 29 Nov 2014 02:49:10 -0500 Subject: [PATCH] 2->4 spacing --- src/ffi.rs | 279 ++++++++++++++++---------------- src/lib.rs | 4 +- src/main.rs | 71 ++++---- src/rocksdb.rs | 430 +++++++++++++++++++++++++------------------------ 4 files changed, 396 insertions(+), 388 deletions(-) diff --git a/src/ffi.rs b/src/ffi.rs index 0fd69ca..d727556 100644 --- a/src/ffi.rs +++ b/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); + } } diff --git a/src/lib.rs b/src/lib.rs index a9694b6..7e150ff 100644 --- a/src/lib.rs +++ b/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; diff --git a/src/main.rs b/src/main.rs index 2411ba5..86d04dd 100644 --- a/src/main.rs +++ b/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(); } diff --git a/src/rocksdb.rs b/src/rocksdb.rs index 36ab86d..fb3006b 100644 --- a/src/rocksdb.rs +++ b/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 { - let opts = RocksDBOptions::new(); - opts.create_if_missing(true); - RocksDB::open(opts, path) - } + pub fn open_default(path: &str) -> Result { + let opts = RocksDBOptions::new(); + opts.create_if_missing(true); + RocksDB::open(opts, path) + } - pub fn open(opts: RocksDBOptions, path: &str) -> Result { - unsafe { - let cpath = path.to_c_str(); - let cpath_ptr = cpath.as_ptr(); + pub fn open(opts: RocksDBOptions, path: &str) -> Result { + 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, + inner: CVec, } 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(self, f: |T| -> U) -> RocksDBResult { - 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(self, f: |T| -> U) -> RocksDBResult { + 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(self, f: |E| -> U) -> RocksDBResult { - 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(self, f: |E| -> U) -> RocksDBResult { + 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 { - 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 { + 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 = 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 = 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(); }