From 269c5712a69f8bd9e47add387d1e89ed5cb9a40d Mon Sep 17 00:00:00 2001 From: Tyler Neely Date: Thu, 16 Jul 2015 23:38:33 -0700 Subject: [PATCH] Run rustfmt on the code. --- README.md | 2 +- src/comparator.rs | 12 +++++++----- src/ffi.rs | 16 +++++++-------- src/lib.rs | 24 ++++------------------- src/merge_operator.rs | 44 +++++++++++++++++++++++++++--------------- src/rocksdb.rs | 36 +++++++++++++++++++--------------- src/rocksdb_options.rs | 19 ++++++++---------- 7 files changed, 76 insertions(+), 77 deletions(-) diff --git a/README.md b/README.md index 444c034..6c54bc7 100644 --- a/README.md +++ b/README.md @@ -12,7 +12,7 @@ This library has been tested against RocksDB 3.8.1 on linux and OSX. The 0.0.6 - [x] LRU cache - [x] destroy/repair - [x] iterator - - [ ] comparator + - [x] comparator - [x] snapshot - [ ] column family operations - [ ] slicetransform diff --git a/src/comparator.rs b/src/comparator.rs index 9a466c2..6cf8d0d 100644 --- a/src/comparator.rs +++ b/src/comparator.rs @@ -25,7 +25,7 @@ use rocksdb::RocksDB; pub struct ComparatorCallback { pub name: CString, - pub f: fn (&[u8], &[u8]) -> i32, + pub f: fn(&[u8], &[u8]) -> i32, } pub extern "C" fn destructor_callback(raw_cb: *mut c_void) { @@ -42,10 +42,12 @@ pub extern "C" fn name_callback(raw_cb: *mut c_void) -> *const c_char { } } -pub extern "C" fn compare_callback( - raw_cb: *mut c_void, - a_raw: *const c_char, a_len: size_t, - b_raw: *const c_char, b_len: size_t) -> c_int { +pub extern "C" fn compare_callback(raw_cb: *mut c_void, + a_raw: *const c_char, + a_len: size_t, + b_raw: *const c_char, + b_len: size_t) + -> c_int { unsafe { let cb: &mut ComparatorCallback = &mut *(raw_cb as *mut ComparatorCallback); diff --git a/src/ffi.rs b/src/ffi.rs index fa79285..10c8cc9 100644 --- a/src/ffi.rs +++ b/src/ffi.rs @@ -71,25 +71,25 @@ pub fn new_cache(capacity: size_t) -> RocksDBCache { #[repr(C)] pub enum RocksDBCompressionType { - RocksDBNoCompression = 0, + RocksDBNoCompression = 0, RocksDBSnappyCompression = 1, - RocksDBZlibCompression = 2, - RocksDBBz2Compression = 3, - RocksDBLz4Compression = 4, - RocksDBLz4hcCompression = 5 + RocksDBZlibCompression = 2, + RocksDBBz2Compression = 3, + RocksDBLz4Compression = 4, + RocksDBLz4hcCompression = 5, } #[repr(C)] pub enum RocksDBCompactionStyle { - RocksDBLevelCompaction = 0, + RocksDBLevelCompaction = 0, RocksDBUniversalCompaction = 1, - RocksDBFifoCompaction = 2 + RocksDBFifoCompaction = 2, } #[repr(C)] pub enum RocksDBUniversalCompactionStyle { rocksdb_similar_size_compaction_stop_style = 0, - rocksdb_total_size_compaction_stop_style = 1 + rocksdb_total_size_compaction_stop_style = 1, } //TODO audit the use of boolean arguments, b/c I think they need to be u8 instead... diff --git a/src/lib.rs b/src/lib.rs index 73c7d81..621add8 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -21,26 +21,10 @@ #![feature(raw)] pub use ffi as rocksdb_ffi; -pub use ffi::{ - new_bloom_filter, - RocksDBCompactionStyle, - RocksDBComparator, -}; -pub use rocksdb::{ - RocksDB, - RocksDBResult, - RocksDBVector, - WriteBatch, - Writable, - Direction, -}; -pub use rocksdb_options::{ - Options, - BlockBasedOptions, -}; -pub use merge_operator::{ - MergeOperands, -}; +pub use ffi::{new_bloom_filter, RocksDBCompactionStyle, RocksDBComparator}; +pub use rocksdb::{RocksDB, RocksDBResult, RocksDBVector, WriteBatch, Writable, Direction}; +pub use rocksdb_options::{Options, BlockBasedOptions}; +pub use merge_operator::MergeOperands; pub mod rocksdb; pub mod ffi; pub mod rocksdb_options; diff --git a/src/merge_operator.rs b/src/merge_operator.rs index aa40e32..38766e6 100644 --- a/src/merge_operator.rs +++ b/src/merge_operator.rs @@ -20,12 +20,12 @@ use std::mem; use std::ptr; use std::slice; -use rocksdb_options::{Options}; +use rocksdb_options::Options; use rocksdb::{RocksDB, RocksDBResult, RocksDBVector, Writable}; pub struct MergeOperatorCallback { pub name: CString, - pub merge_fn: fn (&[u8], Option<&[u8]>, &mut MergeOperands) -> Vec, + pub merge_fn: fn(&[u8], Option<&[u8]>, &mut MergeOperands) -> Vec, } pub extern "C" fn destructor_callback(raw_cb: *mut c_void) { @@ -43,12 +43,17 @@ pub extern "C" fn name_callback(raw_cb: *mut c_void) -> *const c_char { } } -pub extern "C" fn full_merge_callback( - raw_cb: *mut c_void, raw_key: *const c_char, key_len: size_t, - existing_value: *const c_char, existing_value_len: size_t, - operands_list: *const *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 { +pub extern "C" fn full_merge_callback(raw_cb: *mut c_void, + raw_key: *const c_char, + key_len: size_t, + existing_value: *const c_char, + existing_value_len: size_t, + operands_list: *const *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 { unsafe { let cb: &mut MergeOperatorCallback = &mut *(raw_cb as *mut MergeOperatorCallback); @@ -72,11 +77,15 @@ pub extern "C" fn full_merge_callback( } } -pub extern "C" fn partial_merge_callback( - raw_cb: *mut c_void, raw_key: *const c_char, key_len: size_t, - operands_list: *const *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 { +pub extern "C" fn partial_merge_callback(raw_cb: *mut c_void, + raw_key: *const c_char, + key_len: size_t, + operands_list: *const *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 { unsafe { let cb: &mut MergeOperatorCallback = &mut *(raw_cb as *mut MergeOperatorCallback); @@ -107,7 +116,8 @@ pub struct MergeOperands { impl MergeOperands { fn new(operands_list: *const *const c_char, operands_list_len: *const size_t, - num_operands: c_int) -> MergeOperands { + num_operands: c_int) + -> MergeOperands { assert!(num_operands >= 0); MergeOperands { operands_list: operands_list, @@ -148,8 +158,10 @@ impl<'a> Iterator for &'a mut MergeOperands { } } -fn test_provided_merge(new_key: &[u8], existing_val: Option<&[u8]>, - mut operands: &mut MergeOperands) -> Vec { +fn test_provided_merge(new_key: &[u8], + existing_val: Option<&[u8]>, + mut operands: &mut MergeOperands) + -> Vec { let nops = operands.size_hint().0; let mut result: Vec = Vec::with_capacity(nops); match existing_val { diff --git a/src/rocksdb.rs b/src/rocksdb.rs index d20a24a..815dfe7 100644 --- a/src/rocksdb.rs +++ b/src/rocksdb.rs @@ -46,14 +46,16 @@ pub struct Snapshot<'a> { } pub struct DBIterator { -//TODO: should have a reference to DB to enforce scope, but it's trickier than I thought to add + // TODO: should have a reference to DB to enforce scope, but it's trickier than I + // thought to add inner: rocksdb_ffi::RocksDBIterator, direction: Direction, - just_seeked: bool + just_seeked: bool, } pub enum Direction { - forward, reverse + forward, + reverse, } pub struct SubDBIterator<'a> { @@ -64,7 +66,7 @@ pub struct SubDBIterator<'a> { impl <'a> Iterator for SubDBIterator<'a> { type Item = (&'a [u8], &'a [u8]); - fn next(&mut self) -> Option<(&'a[u8], &'a[u8])> { + fn next(&mut self) -> Option<(&'a [u8], &'a [u8])> { let native_iter = self.iter.inner; if !self.iter.just_seeked { match self.direction { @@ -91,7 +93,7 @@ impl <'a> Iterator for SubDBIterator<'a> { } impl DBIterator { -//TODO alias db & opts to different lifetimes, and DBIterator to the db's lifetime +//TODO alias db & opts to different lifetimes, and DBIterator to the db's lifetime fn new(db: &RocksDB, readopts: &ReadOptions) -> DBIterator { unsafe { let iterator = rocksdb_ffi::rocksdb_create_iterator(db.inner, readopts.inner); @@ -105,7 +107,7 @@ impl DBIterator { unsafe { rocksdb_ffi::rocksdb_iter_seek_to_first(self.inner); }; - SubDBIterator{ iter: self, direction: Direction::forward, } + SubDBIterator { iter: self, direction: Direction::forward } } pub fn from_end(&mut self) -> SubDBIterator { @@ -113,7 +115,7 @@ impl DBIterator { unsafe { rocksdb_ffi::rocksdb_iter_seek_to_last(self.inner); }; - SubDBIterator{ iter: self, direction: Direction::reverse, } + SubDBIterator { iter: self, direction: Direction::reverse } } pub fn from(&mut self, key: &[u8], dir: Direction) -> SubDBIterator { @@ -121,7 +123,7 @@ impl DBIterator { unsafe { rocksdb_ffi::rocksdb_iter_seek(self.inner, key.as_ptr(), key.len() as size_t); } - SubDBIterator{ iter: self, direction: dir, } + SubDBIterator { iter: self, direction: dir } } } @@ -136,7 +138,7 @@ impl Drop for DBIterator { impl <'a> Snapshot<'a> { pub fn new(db: &RocksDB) -> Snapshot { let snapshot = unsafe { rocksdb_ffi::rocksdb_create_snapshot(db.inner) }; - Snapshot{db: db, inner: snapshot} + Snapshot { db: db, inner: snapshot } } pub fn iterator(&self) -> DBIterator { @@ -179,8 +181,9 @@ impl RocksDB { pub fn open(opts: &Options, path: &str) -> Result { let cpath = match CString::new(path.as_bytes()) { - Ok(c) => c, - Err(_) => return Err("Failed to convert path to CString when opening rocksdb".to_string()), + Ok(c) => c, + Err(_) => + return Err("Failed to convert path to CString when opening rocksdb".to_string()), }; let cpath_ptr = cpath.as_ptr(); @@ -207,7 +210,7 @@ impl RocksDB { if db_ptr.is_null() { return Err("Could not initialize database.".to_string()); } - Ok(RocksDB{inner: db}) + Ok(RocksDB { inner: db }) } pub fn destroy(opts: &Options, path: &str) -> Result<(), String> { @@ -357,7 +360,7 @@ impl WriteBatch { WriteBatch { inner: unsafe { rocksdb_ffi::rocksdb_writebatch_create() - } + }, } } } @@ -418,8 +421,9 @@ impl ReadOptions { ReadOptions{inner: rocksdb_ffi::rocksdb_readoptions_create()} } } -//TODO add snapshot setting here -//TODO add snapshot wrapper structs with proper destructors; that struct needs an "iterator" impl too. +// TODO add snapshot setting here +// TODO add snapshot wrapper structs with proper destructors; +// that struct needs an "iterator" impl too. fn fill_cache(&mut self, v: bool) { unsafe { rocksdb_ffi::rocksdb_readoptions_set_fill_cache(self.inner, v); @@ -504,7 +508,7 @@ impl RocksDBResult { } } - pub fn on_absent()>(self, f: F) -> RocksDBResult { + pub fn on_absent ()>(self, f: F) -> RocksDBResult { match self { RocksDBResult::Some(x) => RocksDBResult::Some(x), RocksDBResult::None => { diff --git a/src/rocksdb_options.rs b/src/rocksdb_options.rs index e5c4b53..08f290c 100644 --- a/src/rocksdb_options.rs +++ b/src/rocksdb_options.rs @@ -19,8 +19,8 @@ use std::ffi::CString; use std::mem; use rocksdb_ffi; -use merge_operator::{self, MergeOperatorCallback, MergeOperands, full_merge_callback, - partial_merge_callback}; +use merge_operator::{self, MergeOperatorCallback, MergeOperands, + full_merge_callback, partial_merge_callback}; use comparator::{self, ComparatorCallback, compare_callback}; pub struct BlockBasedOptions { @@ -54,7 +54,7 @@ impl BlockBasedOptions { if opt_ptr.is_null() { panic!("Could not create rocksdb block based options".to_string()); } - BlockBasedOptions{ inner: block_opts, } + BlockBasedOptions { inner: block_opts } } pub fn set_block_size(&mut self, size: u64) { @@ -107,8 +107,7 @@ impl Options { } } - pub fn optimize_level_style_compaction(&mut self, - memtable_memory_budget: i32) { + pub fn optimize_level_style_compaction(&mut self, memtable_memory_budget: i32) { unsafe { rocksdb_ffi::rocksdb_options_optimize_level_style_compaction( self.inner, memtable_memory_budget); @@ -122,8 +121,9 @@ impl Options { } } - pub fn add_merge_operator<'a>(&mut self, name: &str, - merge_fn: fn (&[u8], Option<&[u8]>, &mut MergeOperands) -> Vec) { + pub fn add_merge_operator<'a>(&mut self, + name: &str, + merge_fn: fn(&[u8], Option<&[u8]>, &mut MergeOperands) -> Vec) { let cb = Box::new(MergeOperatorCallback { name: CString::new(name.as_bytes()).unwrap(), merge_fn: merge_fn, @@ -258,8 +258,7 @@ impl Options { } } - pub fn set_compaction_style(&mut self, style: - rocksdb_ffi::RocksDBCompactionStyle) { + pub fn set_compaction_style(&mut self, style: rocksdb_ffi::RocksDBCompactionStyle) { unsafe { rocksdb_ffi::rocksdb_options_set_compaction_style( self.inner, style); @@ -306,5 +305,3 @@ impl Options { } } } - -