From e728a14a97f0dc1206e8d48ba7ef91551696bc89 Mon Sep 17 00:00:00 2001 From: siddontang Date: Tue, 16 Feb 2016 10:41:25 +0800 Subject: [PATCH] src: format codes. --- src/comparator.rs | 1 - src/ffi.rs | 23 ++++++------ src/lib.rs | 4 +-- src/merge_operator.rs | 31 +++++++--------- src/rocksdb.rs | 80 ++++++++++++++++++++++++++---------------- src/rocksdb_options.rs | 16 +++++---- 6 files changed, 86 insertions(+), 69 deletions(-) diff --git a/src/comparator.rs b/src/comparator.rs index 27affa6..1e59ec4 100644 --- a/src/comparator.rs +++ b/src/comparator.rs @@ -1,4 +1,3 @@ -// // Copyright 2014 Tyler Neely // // Licensed under the Apache License, Version 2.0 (the "License"); diff --git a/src/ffi.rs b/src/ffi.rs index 6318dde..62712d0 100644 --- a/src/ffi.rs +++ b/src/ffi.rs @@ -1,4 +1,3 @@ -// // Copyright 2014 Tyler Neely // // Licensed under the Apache License, Version 2.0 (the "License"); @@ -101,7 +100,7 @@ pub fn error_message(ptr: *const i8) -> String { // TODO audit the use of boolean arguments, b/c I think they need to be u8 // instead... #[link(name = "rocksdb")] -extern { +extern "C" { pub fn rocksdb_options_create() -> DBOptions; pub fn rocksdb_options_destroy(opts: DBOptions); pub fn rocksdb_cache_create_lru(capacity: size_t) -> DBCache; @@ -376,15 +375,17 @@ extern { // Comparator pub fn rocksdb_options_set_comparator(options: DBOptions, cb: DBComparator); - pub fn rocksdb_comparator_create( - state: *mut c_void, - destroy: extern fn(*mut c_void) -> (), - compare: extern fn (arg: *mut c_void, - a: *const c_char, alen: size_t, - b: *const c_char, blen: size_t - ) -> c_int, - name_fn: extern fn(*mut c_void) -> *const c_char - ) -> DBComparator; + pub fn rocksdb_comparator_create(state: *mut c_void, + destroy: extern "C" fn(*mut c_void) -> (), + compare: extern "C" fn(arg: *mut c_void, + a: *const c_char, + alen: size_t, + b: *const c_char, + blen: size_t) + -> c_int, + name_fn: extern "C" fn(*mut c_void) + -> *const c_char) + -> DBComparator; pub fn rocksdb_comparator_destroy(cmp: DBComparator); // Column Family diff --git a/src/lib.rs b/src/lib.rs index b2233b3..9d27965 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,4 +1,3 @@ -// // Copyright 2014 Tyler Neely // // Licensed under the Apache License, Version 2.0 (the "License"); @@ -15,7 +14,8 @@ // pub use ffi as rocksdb_ffi; pub use ffi::{DBCompactionStyle, DBComparator, new_bloom_filter}; -pub use rocksdb::{DB, DBIterator, DBVector, Direction, Writable, WriteBatch, IteratorMode}; +pub use rocksdb::{DB, DBIterator, DBVector, Direction, IteratorMode, Writable, + WriteBatch}; pub use rocksdb_options::{BlockBasedOptions, Options}; pub use merge_operator::MergeOperands; pub mod rocksdb; diff --git a/src/merge_operator.rs b/src/merge_operator.rs index 972bc9a..1beed45 100644 --- a/src/merge_operator.rs +++ b/src/merge_operator.rs @@ -1,4 +1,3 @@ -// // Copyright 2014 Tyler Neely // // Licensed under the Apache License, Version 2.0 (the "License"); @@ -133,21 +132,19 @@ impl<'a> Iterator for &'a mut MergeOperands { fn next(&mut self) -> Option<&'a [u8]> { match self.cursor == self.num_operands { true => None, - false => { - unsafe { - let base = self.operands_list as usize; - let base_len = self.operands_list_len as usize; - let spacing = mem::size_of::<*const *const u8>(); - let spacing_len = mem::size_of::<*const size_t>(); - let len_ptr = (base_len + (spacing_len * self.cursor)) - as *const size_t; - let len = *len_ptr as usize; - let ptr = base + (spacing * self.cursor); - self.cursor += 1; - Some(mem::transmute(slice::from_raw_parts(*(ptr as *const *const u8) + false => unsafe { + let base = self.operands_list as usize; + let base_len = self.operands_list_len as usize; + let spacing = mem::size_of::<*const *const u8>(); + let spacing_len = mem::size_of::<*const size_t>(); + let len_ptr = + (base_len + (spacing_len * self.cursor)) as *const size_t; + let len = *len_ptr as usize; + let ptr = base + (spacing * self.cursor); + self.cursor += 1; + Some(mem::transmute(slice::from_raw_parts(*(ptr as *const *const u8) as *const u8, len))) - } - } + }, } } @@ -203,9 +200,7 @@ fn mergetest() { None => println!("did not read valid utf-8 out of the db"), } } - Err(e) => { - println!("error reading value") - } + Err(e) => println!("error reading value"), _ => panic!("value not present"), } diff --git a/src/rocksdb.rs b/src/rocksdb.rs index 3ecbb12..cbb5bf6 100644 --- a/src/rocksdb.rs +++ b/src/rocksdb.rs @@ -1,4 +1,3 @@ -// // Copyright 2014 Tyler Neely // // Licensed under the Apache License, Version 2.0 (the "License"); @@ -70,8 +69,12 @@ impl<'a> Iterator for DBIterator<'a> { let native_iter = self.inner; if !self.just_seeked { match self.direction { - Direction::forward => unsafe { rocksdb_ffi::rocksdb_iter_next(native_iter) }, - Direction::reverse => unsafe { rocksdb_ffi::rocksdb_iter_prev(native_iter) }, + Direction::forward => unsafe { + rocksdb_ffi::rocksdb_iter_next(native_iter) + }, + Direction::reverse => unsafe { + rocksdb_ffi::rocksdb_iter_prev(native_iter) + }, } } else { self.just_seeked = false; @@ -110,7 +113,10 @@ pub enum IteratorMode<'a> { impl<'a> DBIterator<'a> { - fn new<'b>(db: &'a DB, readopts: &'b ReadOptions, mode: IteratorMode) -> DBIterator<'a> { + fn new<'b>(db: &'a DB, + readopts: &'b ReadOptions, + mode: IteratorMode) + -> DBIterator<'a> { unsafe { let iterator = rocksdb_ffi::rocksdb_create_iterator(db.inner, readopts.inner); @@ -134,11 +140,11 @@ impl<'a> DBIterator<'a> { IteratorMode::Start => { rocksdb_ffi::rocksdb_iter_seek_to_first(self.inner); self.direction = Direction::forward; - }, + } IteratorMode::End => { rocksdb_ffi::rocksdb_iter_seek_to_last(self.inner); self.direction = Direction::reverse; - }, + } IteratorMode::From(key, dir) => { rocksdb_ffi::rocksdb_iter_seek(self.inner, key.as_ptr(), @@ -183,7 +189,7 @@ impl<'a> Drop for DBIterator<'a> { } } -impl <'a> Snapshot<'a> { +impl<'a> Snapshot<'a> { pub fn new(db: &DB) -> Snapshot { let snapshot = unsafe { rocksdb_ffi::rocksdb_create_snapshot(db.inner) @@ -201,7 +207,7 @@ impl <'a> Snapshot<'a> { } } -impl <'a> Drop for Snapshot<'a> { +impl<'a> Drop for Snapshot<'a> { fn drop(&mut self) { unsafe { rocksdb_ffi::rocksdb_release_snapshot(self.db.inner, self.inner); @@ -244,16 +250,19 @@ impl DB { -> 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()), + Err(_) => { + return Err("Failed to convert path to CString when opening \ + rocksdb" + .to_string()) + } }; let cpath_ptr = cpath.as_ptr(); let ospath = Path::new(path); match fs::create_dir_all(&ospath) { - Err(e) => - return Err("Failed to create rocksdb directory.".to_string()), + Err(e) => { + return Err("Failed to create rocksdb directory.".to_string()) + } Ok(_) => (), } @@ -264,7 +273,9 @@ impl DB { if cfs.len() == 0 { unsafe { - db = rocksdb_ffi::rocksdb_open(opts.inner, cpath_ptr as *const _, err_ptr); + db = rocksdb_ffi::rocksdb_open(opts.inner, + cpath_ptr as *const _, + err_ptr); } } else { let mut cfs_v = cfs.to_vec(); @@ -283,8 +294,8 @@ impl DB { .collect(); let cfnames: Vec<*const _> = c_cfs.iter() - .map(|cf| cf.as_ptr()) - .collect(); + .map(|cf| cf.as_ptr()) + .collect(); // These handles will be populated by DB. let mut cfhandles: Vec = @@ -342,7 +353,9 @@ impl DB { let mut err: *const i8 = 0 as *const i8; let err_ptr: *mut *const i8 = &mut err; unsafe { - rocksdb_ffi::rocksdb_destroy_db(opts.inner, cpath_ptr as *const _, err_ptr); + rocksdb_ffi::rocksdb_destroy_db(opts.inner, + cpath_ptr as *const _, + err_ptr); } if !err.is_null() { return Err(error_message(err)); @@ -358,7 +371,9 @@ impl DB { let mut err: *const i8 = 0 as *const i8; let err_ptr: *mut *const i8 = &mut err; unsafe { - rocksdb_ffi::rocksdb_repair_db(opts.inner, cpath_ptr as *const _, err_ptr); + rocksdb_ffi::rocksdb_repair_db(opts.inner, + cpath_ptr as *const _, + err_ptr); } if !err.is_null() { return Err(error_message(err)); @@ -411,9 +426,7 @@ impl DB { } match val.is_null() { true => Ok(None), - false => { - Ok(Some(DBVector::from_c(val, val_len))) - } + false => Ok(Some(DBVector::from_c(val, val_len))), } } } @@ -450,9 +463,7 @@ impl DB { } match val.is_null() { true => Ok(None), - false => { - Ok(Some(DBVector::from_c(val, val_len))) - } + false => Ok(Some(DBVector::from_c(val, val_len))), } } } @@ -463,9 +474,11 @@ impl DB { -> Result { let cname = match CString::new(name.as_bytes()) { Ok(c) => c, - Err(_) => return Err("Failed to convert path to CString when \ - opening rocksdb" - .to_string()), + Err(_) => { + return Err("Failed to convert path to CString when opening \ + rocksdb" + .to_string()) + } }; let cname_ptr = cname.as_ptr(); let mut err: *const i8 = 0 as *const i8; @@ -514,7 +527,10 @@ impl DB { DBIterator::new(&self, &opts, mode) } - pub fn iterator_cf(&self, cf_handle: DBCFHandle, mode: IteratorMode) -> Result { + pub fn iterator_cf(&self, + cf_handle: DBCFHandle, + mode: IteratorMode) + -> Result { let opts = ReadOptions::new(); DBIterator::new_cf(&self, cf_handle, &opts, mode) } @@ -841,9 +857,11 @@ fn errors_do_stuff() { let opts = Options::new(); // The DB will still be open when we try to destroy and the lock should fail match DB::destroy(&opts, path) { - Err(ref s) => assert!(s == - "IO error: lock _rust_rocksdb_error/LOCK: No \ - locks available"), + Err(ref s) => { + assert!(s == + "IO error: lock _rust_rocksdb_error/LOCK: No locks \ + available") + } Ok(_) => panic!("should fail"), } } diff --git a/src/rocksdb_options.rs b/src/rocksdb_options.rs index e53bd27..f561cb5 100644 --- a/src/rocksdb_options.rs +++ b/src/rocksdb_options.rs @@ -1,4 +1,3 @@ -// // Copyright 2014 Tyler Neely // // Licensed under the Apache License, Version 2.0 (the "License"); @@ -127,7 +126,10 @@ impl Options { pub fn add_merge_operator<'a>(&mut self, name: &str, - merge_fn: fn(&[u8], Option<&[u8]>, &mut MergeOperands) -> Vec) { + 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, @@ -180,10 +182,12 @@ impl Options { pub fn set_use_fsync(&mut self, useit: bool) { unsafe { match useit { - true => - rocksdb_ffi::rocksdb_options_set_use_fsync(self.inner, 1), - false => - rocksdb_ffi::rocksdb_options_set_use_fsync(self.inner, 0), + true => { + rocksdb_ffi::rocksdb_options_set_use_fsync(self.inner, 1) + } + false => { + rocksdb_ffi::rocksdb_options_set_use_fsync(self.inner, 0) + } } } }