From 45d6436f0ea43ee2d4b4ee050364693c15f7d4dc Mon Sep 17 00:00:00 2001 From: Ceri Storey Date: Mon, 29 Feb 2016 10:13:54 +0000 Subject: [PATCH] Format with rustfmt. --- src/comparator.rs | 1 - src/ffi.rs | 26 +++++---- src/lib.rs | 4 +- src/merge_operator.rs | 31 +++++----- src/rocksdb.rs | 130 ++++++++++++++++++++++++++--------------- src/rocksdb_options.rs | 16 +++-- 6 files changed, 122 insertions(+), 86 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 8b0f86d..f2728f2 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; @@ -191,7 +190,8 @@ extern { pub fn rocksdb_writeoptions_create() -> DBWriteOptions; pub fn rocksdb_writeoptions_destroy(writeopts: DBWriteOptions); pub fn rocksdb_writeoptions_set_sync(writeopts: DBWriteOptions, v: bool); - pub fn rocksdb_writeoptions_disable_WAL(writeopts: DBWriteOptions, v: c_int); + pub fn rocksdb_writeoptions_disable_WAL(writeopts: DBWriteOptions, + v: c_int); pub fn rocksdb_put(db: DBInstance, writeopts: DBWriteOptions, k: *const u8, @@ -378,15 +378,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 0e013aa..8b774f4 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, WriteOptions}; 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 5c9b771..82932fc 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"); @@ -28,7 +27,7 @@ use std::str::from_utf8; use self::libc::{c_void, size_t}; use rocksdb_ffi::{self, DBCFHandle, error_message}; -use rocksdb_options::{Options,WriteOptions}; +use rocksdb_options::{Options, WriteOptions}; pub struct DB { inner: rocksdb_ffi::DBInstance, @@ -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)); @@ -366,7 +381,10 @@ impl DB { Ok(()) } - pub fn write_opt(&self, batch: WriteBatch, writeopts: &WriteOptions) -> Result<(), String> { + pub fn write_opt(&self, + batch: WriteBatch, + writeopts: &WriteOptions) + -> Result<(), String> { let mut err: *const i8 = 0 as *const i8; let err_ptr: *mut *const i8 = &mut err; unsafe { @@ -413,9 +431,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))), } } } @@ -452,9 +468,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))), } } } @@ -465,9 +479,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; @@ -516,7 +532,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) } @@ -525,7 +544,11 @@ impl DB { Snapshot::new(self) } - pub fn put_opt(&self, key: &[u8], value: &[u8], writeopts: &WriteOptions) -> Result<(), String> { + pub fn put_opt(&self, + key: &[u8], + value: &[u8], + writeopts: &WriteOptions) + -> Result<(), String> { unsafe { let mut err: *const i8 = 0 as *const i8; let err_ptr: *mut *const i8 = &mut err; @@ -544,11 +567,11 @@ impl DB { } pub fn put_cf_opt(&self, - cf: DBCFHandle, - key: &[u8], - value: &[u8], - writeopts: &WriteOptions) - -> Result<(), String> { + cf: DBCFHandle, + key: &[u8], + value: &[u8], + writeopts: &WriteOptions) + -> Result<(), String> { unsafe { let mut err: *const i8 = 0 as *const i8; let err_ptr: *mut *const i8 = &mut err; @@ -566,7 +589,11 @@ impl DB { Ok(()) } } - pub fn merge_opt(&self, key: &[u8], value: &[u8], writeopts: &WriteOptions) -> Result<(), String> { + pub fn merge_opt(&self, + key: &[u8], + value: &[u8], + writeopts: &WriteOptions) + -> Result<(), String> { unsafe { let mut err: *const i8 = 0 as *const i8; let err_ptr: *mut *const i8 = &mut err; @@ -584,11 +611,11 @@ impl DB { } } fn merge_cf_opt(&self, - cf: DBCFHandle, - key: &[u8], - value: &[u8], - writeopts: &WriteOptions) - -> Result<(), String> { + cf: DBCFHandle, + key: &[u8], + value: &[u8], + writeopts: &WriteOptions) + -> Result<(), String> { unsafe { let mut err: *const i8 = 0 as *const i8; let err_ptr: *mut *const i8 = &mut err; @@ -606,7 +633,10 @@ impl DB { Ok(()) } } - fn delete_opt(&self, key: &[u8], writeopts: &WriteOptions) -> Result<(), String> { + fn delete_opt(&self, + key: &[u8], + writeopts: &WriteOptions) + -> Result<(), String> { unsafe { let mut err: *const i8 = 0 as *const i8; let err_ptr: *mut *const i8 = &mut err; @@ -621,7 +651,11 @@ impl DB { Ok(()) } } - fn delete_cf_opt(&self, cf: DBCFHandle, key: &[u8], writeopts: &WriteOptions) -> Result<(), String> { + fn delete_cf_opt(&self, + cf: DBCFHandle, + key: &[u8], + writeopts: &WriteOptions) + -> Result<(), String> { unsafe { let mut err: *const i8 = 0 as *const i8; let err_ptr: *mut *const i8 = &mut err; @@ -861,9 +895,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 7210061..35d9f6d 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"); @@ -139,7 +138,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, @@ -192,10 +194,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) + } } } }