From 325476aad867de0247be131b47934f1ad8d4a0c5 Mon Sep 17 00:00:00 2001 From: Tyler Neely Date: Fri, 28 Nov 2014 03:37:59 -0500 Subject: [PATCH] spacing --- rocksdb-sys/build.rs | 76 +++++----- rocksdb-sys/lib.rs | 232 ++++++++++++++--------------- src/lib.rs | 8 +- src/main.rs | 66 ++++----- src/rocksdb.rs | 338 +++++++++++++++++++++---------------------- 5 files changed, 360 insertions(+), 360 deletions(-) diff --git a/rocksdb-sys/build.rs b/rocksdb-sys/build.rs index 7be695f..ad50743 100644 --- a/rocksdb-sys/build.rs +++ b/rocksdb-sys/build.rs @@ -7,49 +7,49 @@ use std::io::process::InheritFd; //TODO windows support fn main() { - // Next, fall back and try to use pkg-config if its available. - match pkg_config::find_library("librocksdb") { - Ok(()) => return, - Err(..) => {} - } - - let src = os::getcwd().unwrap(); - let dst = Path::new(os::getenv("OUT_DIR").unwrap()); - - let _ = fs::mkdir(&dst.join("build"), io::USER_DIR); - - println!("cwd: {}", src.join("rocksdb").as_str()); - run(Command::new(make()) - .arg("shared_lib") - .arg(format!("-j{}", os::getenv("NUM_JOBS").unwrap())) - .cwd(&src.join("rocksdb"))); - - // Don't run `make install` because apparently it's a little buggy on mingw - // for windows. - fs::mkdir_recursive(&dst.join("lib/pkgconfig"), io::USER_DIR).unwrap(); - - let target = os::getenv("TARGET").unwrap(); - if target.contains("apple") { - fs::rename(&src.join("rocksdb/librocksdb.dylib"), &dst.join("lib/librocksdb.dylib")).unwrap(); - } else { - fs::rename(&src.join("rocksdb/librocksdb.so"), &dst.join("lib/librocksdb.so")).unwrap(); - } - - println!("cargo:rustc-flags=-L {}/lib -l rocksdb:dylib", dst.display()); - println!("cargo:root={}", dst.display()); - println!("cargo:include={}/include", src.join("rocksdb").display()); + // Next, fall back and try to use pkg-config if its available. + match pkg_config::find_library("librocksdb") { + Ok(()) => return, + Err(..) => {} + } + + let src = os::getcwd().unwrap(); + let dst = Path::new(os::getenv("OUT_DIR").unwrap()); + + let _ = fs::mkdir(&dst.join("build"), io::USER_DIR); + + println!("cwd: {}", src.join("rocksdb").as_str()); + run(Command::new(make()) + .arg("shared_lib") + .arg(format!("-j{}", os::getenv("NUM_JOBS").unwrap())) + .cwd(&src.join("rocksdb"))); + + // Don't run `make install` because apparently it's a little buggy on mingw + // for windows. + fs::mkdir_recursive(&dst.join("lib/pkgconfig"), io::USER_DIR).unwrap(); + + let target = os::getenv("TARGET").unwrap(); + if target.contains("apple") { + fs::rename(&src.join("rocksdb/librocksdb.dylib"), &dst.join("lib/librocksdb.dylib")).unwrap(); + } else { + fs::rename(&src.join("rocksdb/librocksdb.so"), &dst.join("lib/librocksdb.so")).unwrap(); + } + + println!("cargo:rustc-flags=-L {}/lib -l rocksdb:dylib", dst.display()); + println!("cargo:root={}", dst.display()); + println!("cargo:include={}/include", src.join("rocksdb").display()); } fn run(cmd: &mut Command) { - println!("running: {}", cmd); - assert!(cmd.stdout(InheritFd(1)) - .stderr(InheritFd(2)) - .status() - .unwrap() - .success()); + println!("running: {}", cmd); + assert!(cmd.stdout(InheritFd(1)) + .stderr(InheritFd(2)) + .status() + .unwrap() + .success()); } fn make() -> &'static str { - if cfg!(target_os = "freebsd") {"gmake"} else {"make"} + if cfg!(target_os = "freebsd") {"gmake"} else {"make"} } diff --git a/rocksdb-sys/lib.rs b/rocksdb-sys/lib.rs index 2c4d0e3..945f9ae 100644 --- a/rocksdb-sys/lib.rs +++ b/rocksdb-sys/lib.rs @@ -18,19 +18,19 @@ pub struct RocksdbFilterPolicy(pub *const c_void); #[repr(C)] pub enum RocksdbCompressionType { - RocksdbNoCompression = 0, + RocksdbNoCompression = 0, RocksdbSnappyCompression = 1, RocksdbZlibCompression = 2, - RocksdbBz2Compression = 3, - RocksdbLz4Compression = 4, + RocksdbBz2Compression = 3, + RocksdbLz4Compression = 4, RocksdbLz4hcCompression = 5 } #[repr(C)] pub enum RocksdbCompactionStyle { - RocksdbLevelCompaction = 0, + RocksdbLevelCompaction = 0, RocksdbUniversalCompaction = 1, - RocksdbFifoCompaction = 2 + RocksdbFifoCompaction = 2 } #[repr(C)] @@ -41,76 +41,76 @@ pub enum RocksdbUniversalCompactionStyle { #[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_mergeoperator_create() -> RocksdbMergeOperator; - 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_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_mergeoperator_create() -> RocksdbMergeOperator; + 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_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); } @@ -118,45 +118,45 @@ extern { #[allow(dead_code)] #[test] fn internal() { - 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); - - 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 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"; - - 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 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); - } + 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); + + 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 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"; + + 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 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 4bb7c1a..bd9a1a1 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -5,9 +5,9 @@ extern crate "rocksdb-sys" as rocksdb_ffi; pub use rocksdb::{ - create_or_open, - open, - Rocksdb, - RocksdbResult, + create_or_open, + open, + Rocksdb, + RocksdbResult, }; pub mod rocksdb; diff --git a/src/main.rs b/src/main.rs index f2a2512..d42c612 100644 --- a/src/main.rs +++ b/src/main.rs @@ -5,50 +5,50 @@ use test::Bencher; #[allow(dead_code)] fn main() { - match rocksdb::create_or_open("/tmp/rust-rocksdb".to_string()) { - Ok(db) => { - db.put(b"my key", b"my value"); + match rocksdb::create_or_open("/tmp/rust-rocksdb".to_string()) { + Ok(db) => { + db.put(b"my key", b"my value"); - 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"), - }}); + 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"), + }}); - db.get(b"NOT my key").on_absent(|| { println!("value not found") }); + db.get(b"NOT my key").on_absent(|| { println!("value not found") }); - db.close(); - }, - Err(e) => panic!(e), - } + db.close(); + }, + Err(e) => panic!(e), + } } #[allow(dead_code)] #[bench] fn writes(b: &mut Bencher) { - let db = open("testdb".to_string(), true).unwrap(); - let mut i = 0 as u64; - b.iter(|| { - db.put(i.to_string().as_bytes(), b"v1111"); - i += 1; - }); - db.close(); + let db = open("testdb".to_string(), true).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 = open("testdb".to_string(), true).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 = open("testdb".to_string(), true).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 3d830cc..a9541f0 100644 --- a/src/rocksdb.rs +++ b/src/rocksdb.rs @@ -8,171 +8,171 @@ use std::str::from_utf8; use rocksdb_ffi; pub struct Rocksdb { - inner: rocksdb_ffi::RocksdbInstance, + inner: rocksdb_ffi::RocksdbInstance, } impl Rocksdb { - 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(()) + 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(()) } + } - 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)) - } - } + 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)) + } + } } + } - 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, } + } } pub fn create_or_open(path: String) -> Result { @@ -180,54 +180,54 @@ pub fn create_or_open(path: String) -> Result { } pub fn open(path: String, create_if_missing: bool) -> Result { - unsafe { - let opts = rocksdb_ffi::rocksdb_options_create(); - let rocksdb_ffi::RocksdbOptions(opt_ptr) = opts; - if opt_ptr.is_null() { - return Err("Could not create options".to_string()); - } + unsafe { + let opts = rocksdb_ffi::rocksdb_options_create(); + let rocksdb_ffi::RocksdbOptions(opt_ptr) = opts; + if opt_ptr.is_null() { + return Err("Could not create options".to_string()); + } - //rocksdb_ffi::rocksdb_options_increase_parallelism(opts, 2); - //rocksdb_ffi::rocksdb_options_optimize_level_style_compaction(opts, 0); + //rocksdb_ffi::rocksdb_options_increase_parallelism(opts, 2); + //rocksdb_ffi::rocksdb_options_optimize_level_style_compaction(opts, 0); - match create_if_missing { - true => rocksdb_ffi::rocksdb_options_set_create_if_missing(opts, 1), - false => rocksdb_ffi::rocksdb_options_set_create_if_missing(opts, 0), - } + match create_if_missing { + true => rocksdb_ffi::rocksdb_options_set_create_if_missing(opts, 1), + false => rocksdb_ffi::rocksdb_options_set_create_if_missing(opts, 0), + } - 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 - - let err = 0 as *mut i8; - let db = rocksdb_ffi::rocksdb_open(opts, 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}) + 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 + + let err = 0 as *mut i8; + let db = rocksdb_ffi::rocksdb_open(opts, 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}) + } } #[allow(dead_code)] #[test] fn external() { - let db = open("externaltest".to_string(), true).unwrap(); - let p = db.put(b"k1", b"v1111"); - assert!(p.is_ok()); - let r: RocksdbResult = db.get(b"k1"); - //assert!(r.is_some()); - r.map(|v| { assert!(v.as_slice().len() == 5); } ); - db.close(); + let db = open("externaltest".to_string(), true).unwrap(); + let p = db.put(b"k1", b"v1111"); + assert!(p.is_ok()); + let r: RocksdbResult = db.get(b"k1"); + //assert!(r.is_some()); + r.map(|v| { assert!(v.as_slice().len() == 5); } ); + db.close(); }