tiny cleanup (#145)

Cargo.toml

 [package]
-
 name = "rocksdb"
 description = "A Rust wrapper for Facebook's RocksDB embeddable database."
 version = "0.3.0"

librocksdb_sys/Cargo.toml

@@ -17,4 +17,4 @@ portable = []
 sse = []
 
 [build-dependencies]
-gcc = "0.3"
+cc = "1.0"

librocksdb_sys/build.rs

 
-extern crate gcc;
+extern crate cc;
 
-use gcc::Build;
+use cc::Build;
 use std::{env, fs, str};
 use std::path::PathBuf;
 use std::process::Command;

librocksdb_sys/crocksdb/c.cc

@@ -241,7 +241,7 @@ struct crocksdb_comparator_t : public Comparator {
   // No-ops since the C binding does not support key shortening methods.
   virtual void FindShortestSeparator(std::string*,
                                      const Slice&) const override {}
-  virtual void FindShortSuccessor(std::string* key) const override {}
+  virtual void FindShortSuccessor(std::string*) const override {}
 };
 
 struct crocksdb_filterpolicy_t : public FilterPolicy {
@@ -356,7 +356,7 @@ struct crocksdb_mergeoperator_t : public MergeOperator {
   virtual bool PartialMergeMulti(const Slice& key,
                                  const std::deque<Slice>& operand_list,
                                  std::string* new_value,
-                                 Logger* logger) const override {
+                                 Logger*) const override {
     size_t operand_count = operand_list.size();
     std::vector<const char*> operand_pointers(operand_count);
     std::vector<size_t> operand_sizes(operand_count);
@@ -1967,9 +1967,6 @@ void crocksdb_options_set_level0_stop_writes_trigger(
   opt->rep.level0_stop_writes_trigger = n;
 }
 
-void crocksdb_options_set_max_mem_compaction_level(crocksdb_options_t* opt,
-                                                  int n) {}
-
 void crocksdb_options_set_wal_recovery_mode(crocksdb_options_t* opt,int mode) {
   opt->rep.wal_recovery_mode = static_cast<WALRecoveryMode>(mode);
 }
@@ -2077,10 +2074,6 @@ void crocksdb_options_set_manifest_preallocation_size(
   opt->rep.manifest_preallocation_size = v;
 }
 
-// noop
-void crocksdb_options_set_purge_redundant_kvs_while_flush(crocksdb_options_t* opt,
-                                                         unsigned char v) {}
-
 void crocksdb_options_set_allow_mmap_reads(
     crocksdb_options_t* opt, unsigned char v) {
   opt->rep.allow_mmap_reads = v;
@@ -2233,11 +2226,6 @@ void crocksdb_options_set_writable_file_max_buffer_size(
   opt->rep.writable_file_max_buffer_size = v;
 }
 
-void crocksdb_options_set_table_cache_remove_scan_count_limit(
-    crocksdb_options_t* opt, int v) {
-  // this option is deprecated
-}
-
 void crocksdb_options_set_arena_block_size(
     crocksdb_options_t* opt, size_t v) {
   opt->rep.arena_block_size = v;
@@ -2850,12 +2838,6 @@ void crocksdb_sstfilewriter_open(crocksdb_sstfilewriter_t* writer,
   SaveError(errptr, writer->rep->Open(std::string(name)));
 }
 
-void crocksdb_sstfilewriter_add(crocksdb_sstfilewriter_t *writer,
-                                const char *key, size_t keylen, const char *val,
-                                size_t vallen, char **errptr) {
-  SaveError(errptr, writer->rep->Add(Slice(key, keylen), Slice(val, vallen)));
-}
-
 void crocksdb_sstfilewriter_put(crocksdb_sstfilewriter_t *writer,
                                 const char *key, size_t keylen, const char *val,
                                 size_t vallen, char **errptr) {
@@ -3314,8 +3296,8 @@ uint64_t crocksdb_table_properties_get_u64(
       return rep.data_size;
     case kColumnFamilyID:
       return rep.column_family_id;
+    default: return 0;
   }
-  return 0;
 }
 
 const char* crocksdb_table_properties_get_str(
@@ -3344,8 +3326,9 @@ const char* crocksdb_table_properties_get_str(
   case kCompressionName:
     *slen = rep.compression_name.size();
     return rep.compression_name.data();
+  default:
+    return nullptr;
   }
-  return nullptr;
 }
 
 const crocksdb_user_collected_properties_t*

librocksdb_sys/crocksdb/crocksdb/c.h

@@ -766,8 +766,6 @@ extern C_ROCKSDB_LIBRARY_API void
 crocksdb_options_set_level0_slowdown_writes_trigger(crocksdb_options_t*, int);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_level0_stop_writes_trigger(
     crocksdb_options_t*, int);
-extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_max_mem_compaction_level(
-    crocksdb_options_t*, int);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_target_file_size_base(
     crocksdb_options_t*, uint64_t);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_target_file_size_multiplier(
@@ -841,9 +839,6 @@ extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_table_cache_numshardbits(
     crocksdb_options_t*, int);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_writable_file_max_buffer_size(
     crocksdb_options_t*, int);
-extern C_ROCKSDB_LIBRARY_API void
-crocksdb_options_set_table_cache_remove_scan_count_limit(crocksdb_options_t*,
-                                                        int);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_arena_block_size(
     crocksdb_options_t*, size_t);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_use_fsync(
@@ -862,9 +857,6 @@ extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_wal_size_limit_mb(
     crocksdb_options_t*, uint64_t);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_manifest_preallocation_size(
     crocksdb_options_t*, size_t);
-extern C_ROCKSDB_LIBRARY_API void
-crocksdb_options_set_purge_redundant_kvs_while_flush(crocksdb_options_t*,
-                                                    unsigned char);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_allow_mmap_reads(
     crocksdb_options_t*, unsigned char);
 extern C_ROCKSDB_LIBRARY_API void crocksdb_options_set_allow_mmap_writes(
@@ -1194,10 +1186,6 @@ crocksdb_sstfilewriter_create_cf(const crocksdb_envoptions_t* env,
 extern C_ROCKSDB_LIBRARY_API void crocksdb_sstfilewriter_open(
     crocksdb_sstfilewriter_t* writer, const char* name, char** errptr);
 extern C_ROCKSDB_LIBRARY_API void
-crocksdb_sstfilewriter_add(crocksdb_sstfilewriter_t *writer, const char *key,
-                           size_t keylen, const char *val, size_t vallen,
-                           char **errptr);
-extern C_ROCKSDB_LIBRARY_API void
 crocksdb_sstfilewriter_put(crocksdb_sstfilewriter_t *writer, const char *key,
                            size_t keylen, const char *val, size_t vallen,
                            char **errptr);

rustfmt.toml

 reorder_imports = true
+use_try_shorthand = true

src/rocksdb.rs

@@ -391,15 +391,16 @@ impl DB {
         const ERR_NULL_DB_ONINIT: &str = "Could not initialize database";
         const ERR_NULL_CF_HANDLE: &str = "Received null column family handle from DB";
 
-        let cpath = try!(CString::new(path.as_bytes()).map_err(|_| ERR_CONVERT_PATH.to_owned()));
-        try!(fs::create_dir_all(&Path::new(path)).map_err(|e| {
+        let cpath = CString::new(path.as_bytes())
+            .map_err(|_| ERR_CONVERT_PATH.to_owned())?;
+        fs::create_dir_all(&Path::new(path)).map_err(|e| {
             format!(
                 "Failed to create rocksdb directory: \
                  src/rocksdb.rs:                              \
                  {:?}",
                 e
             )
-        }));
+        })?;
 
         let mut descs = cfds.into_iter().map(|t| t.into()).collect();
         ensure_default_cf_exists(&mut descs);
@@ -606,7 +607,9 @@ impl DB {
         let cname = match CString::new(name.as_bytes()) {
             Ok(c) => c,
             Err(_) => {
-                return Err("Failed to convert path to CString when opening rocksdb".to_owned())
+                return Err(
+                    "Failed to convert path to CString when opening rocksdb".to_owned(),
+                )
             }
         };
         let cname_ptr = cname.as_ptr();
@@ -1700,19 +1703,6 @@ impl SstFileWriter {
 
     /// Add key, value to currently opened file
     /// REQUIRES: key is after any previously added key according to comparator.
-    pub fn add(&mut self, key: &[u8], val: &[u8]) -> Result<(), String> {
-        unsafe {
-            ffi_try!(crocksdb_sstfilewriter_add(
-                self.inner,
-                key.as_ptr(),
-                key.len(),
-                val.as_ptr(),
-                val.len()
-            ));
-            Ok(())
-        }
-    }
-
     pub fn put(&mut self, key: &[u8], val: &[u8]) -> Result<(), String> {
         unsafe {
             ffi_try!(crocksdb_sstfilewriter_put(

src/rocksdb_options.rs

@@ -859,9 +859,7 @@ impl ColumnFamilyOptions {
                 Ok(s) => s,
                 Err(e) => return Err(format!("failed to convert to cstring: {:?}", e)),
             };
-            self.filter = Some(try!(
-                new_compaction_filter(c_name, ignore_snapshots, filter)
-            ));
+            self.filter = Some(new_compaction_filter(c_name, ignore_snapshots, filter)?);
             crocksdb_ffi::crocksdb_options_set_compaction_filter(
                 self.inner,
                 self.filter.as_ref().unwrap().inner,
@@ -1115,7 +1113,7 @@ impl ColumnFamilyOptions {
                 Ok(s) => s,
                 Err(e) => return Err(format!("failed to convert to cstring: {:?}", e)),
             };
-            let transform = try!(new_slice_transform(c_name, transform));
+            let transform = new_slice_transform(c_name, transform)?;
             crocksdb_ffi::crocksdb_options_set_prefix_extractor(self.inner, transform);
             Ok(())
         }
@@ -1140,7 +1138,7 @@ impl ColumnFamilyOptions {
                 Ok(s) => s,
                 Err(e) => return Err(format!("failed to convert to cstring: {:?}", e)),
             };
-            let transform = try!(new_slice_transform(c_name, transform));
+            let transform = new_slice_transform(c_name, transform)?;
             crocksdb_ffi::crocksdb_options_set_memtable_insert_with_hint_prefix_extractor(
                 self.inner,
                 transform,

tests/test_delete_range.rs

@@ -25,10 +25,10 @@ fn gen_sst(opt: ColumnFamilyOptions, cf: Option<&CFHandle>, path: &str) {
         SstFileWriter::new(env_opt, opt)
     };
     writer.open(path).unwrap();
-    writer.add(b"key1", b"value1").unwrap();
-    writer.add(b"key2", b"value2").unwrap();
-    writer.add(b"key3", b"value3").unwrap();
-    writer.add(b"key4", b"value4").unwrap();
+    writer.put(b"key1", b"value1").unwrap();
+    writer.put(b"key2", b"value2").unwrap();
+    writer.put(b"key3", b"value3").unwrap();
+    writer.put(b"key4", b"value4").unwrap();
     writer.finish().unwrap();
 }
 
@@ -44,7 +44,7 @@ fn gen_sst_from_db(opt: ColumnFamilyOptions, cf: Option<&CFHandle>, path: &str,
     let mut iter = db.iter();
     iter.seek(SeekKey::Start);
     while iter.valid() {
-        writer.add(iter.key(), iter.value()).unwrap();
+        writer.put(iter.key(), iter.value()).unwrap();
         iter.next();
     }
     writer.finish().unwrap();

tests/test_ingest_external_file.rs

@@ -30,7 +30,7 @@ pub fn gen_sst(
     };
     writer.open(path).unwrap();
     for &(k, v) in data {
-        writer.add(k, v).unwrap();
+        writer.put(k, v).unwrap();
     }
 
     writer.finish().unwrap();
@@ -279,7 +279,7 @@ fn gen_sst_from_cf(opt: ColumnFamilyOptions, db: &DB, cf: &CFHandle, path: &str)
     let mut iter = db.iter_cf(cf);
     iter.seek(SeekKey::Start);
     while iter.valid() {
-        writer.add(iter.key(), iter.value()).unwrap();
+        writer.put(iter.key(), iter.value()).unwrap();
         iter.next();
     }
     writer.finish().unwrap();