Now friendly with 1.1 stable!

Cargo.toml

@@ -20,3 +20,6 @@ valgrind=[]
 
 name = "test"
 path = "test/test.rs"
+
+[dependencies]
+libc = "0.1.8"

src/lib.rs

@@ -15,10 +15,6 @@
 */
 #![crate_id = "rocksdb"]
 #![crate_type = "lib"]
-#![feature(libc)]
-#![feature(unique)]
-#![feature(path_ext)]
-#![feature(raw)]
 
 pub use ffi as rocksdb_ffi;
 pub use ffi::{new_bloom_filter, RocksDBCompactionStyle, RocksDBComparator};

src/main.rs

@@ -13,10 +13,7 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 */
-#![feature(test)]
-
 extern crate rocksdb;
-extern crate test;
 use rocksdb::{Options, RocksDB, MergeOperands, new_bloom_filter, Writable, };
 use rocksdb::RocksDBCompactionStyle::RocksDBUniversalCompaction;
 
@@ -72,11 +69,15 @@ fn concat_merge(new_key: &[u8], existing_val: Option<&[u8]>,
     mut operands: &mut MergeOperands) -> Vec<u8> {
     let mut result: Vec<u8> = Vec::with_capacity(operands.size_hint().0);
     match existing_val {
-        Some(v) => result.extend(v),
+        Some(v) => for e in v {
+            result.push(*e)
+        },
         None => (),
     }
     for op in operands {
-        result.extend(op);
+        for e in op {
+            result.push(*e);
+        }
     }
     result
 }
@@ -138,7 +139,6 @@ fn main() {
 
 #[cfg(test)]
 mod tests  {
-    use test::Bencher;
     use std::thread::sleep_ms;
 
     use rocksdb::{BlockBasedOptions, Options, RocksDB, MergeOperands, new_bloom_filter, Writable };
@@ -172,6 +172,7 @@ mod tests  {
         RocksDB::open(&opts, path).unwrap()
     }
     
+    /* TODO(tyler) unstable
     #[bench]
     fn a_writes(b: &mut Bencher) {
         // dirty hack due to parallel tests causing contention.
@@ -205,4 +206,5 @@ mod tests  {
         }
         RocksDB::destroy(&opts, path).is_ok();
     }
+    */
 }

src/merge_operator.rs

@@ -131,7 +131,6 @@ impl MergeOperands {
 impl<'a> Iterator for &'a mut MergeOperands {
     type Item = &'a [u8];
     fn next(&mut self) -> Option<&'a [u8]> {
-        use std::raw::Slice;
         match self.cursor == self.num_operands {
             true => None,
             false => {
@@ -145,8 +144,8 @@ impl<'a> Iterator for &'a mut MergeOperands {
                     let len = *len_ptr as usize;
                     let ptr = base + (spacing * self.cursor);
                     self.cursor += 1;
-                    Some(mem::transmute(Slice{data:*(ptr as *const *const u8)
+                    Some(mem::transmute(slice::from_raw_parts(*(ptr as *const *const u8)
-                        as *const u8, len: len}))
+                        as *const u8, len)))
                 }
             }
         }
@@ -165,11 +164,17 @@ fn test_provided_merge(new_key: &[u8],
     let nops = operands.size_hint().0;
     let mut result: Vec<u8> = Vec::with_capacity(nops);
     match existing_val {
-        Some(v) => result.extend(v),
+        Some(v) => {
+            for e in v {
+                result.push(*e);
+            }
+        },
         None => (),
     }
     for op in operands {
-        result.extend(op);
+        for e in op {
+            result.push(*e);
+        }
     }
     result
 }

src/rocksdb.rs

@@ -17,10 +17,9 @@
 extern crate libc;
 use self::libc::{c_void, size_t};
 use std::ffi::{CString, CStr};
-use std::fs::{self, PathExt};
+use std::fs;
 use std::ops::Deref;
 use std::path::Path;
-use std::ptr::Unique;
 use std::slice;
 use std::str::from_utf8;
 use std::marker::PhantomData;
@@ -192,12 +191,10 @@ impl RocksDB {
         let cpath_ptr = cpath.as_ptr();
 
         let ospath = Path::new(path);
-        if !ospath.exists() {
         match fs::create_dir_all(&ospath) {
             Err(e) => return Err("Failed to create rocksdb directory.".to_string()),
             Ok(_) => (),
         }
-        }
 
         let mut err: *const i8 = 0 as *const i8;
         let err_ptr: *mut *const i8 = &mut err;
@@ -222,10 +219,6 @@ impl RocksDB {
         let cpath_ptr = cpath.as_ptr();
 
         let ospath = Path::new(path);
-        if !ospath.exists() {
-            return Err("path does not exist".to_string());
-        }
-
         let mut err: *const i8 = 0 as *const i8;
         let err_ptr: *mut *const i8 = &mut err;
         unsafe {
@@ -242,10 +235,6 @@ impl RocksDB {
         let cpath_ptr = cpath.as_ptr();
 
         let ospath = Path::new(path);
-        if !ospath.exists() {
-            return Err("path does not exist".to_string());
-        }
-
         let mut err: *const i8 = 0 as *const i8;
         let err_ptr: *mut *const i8 = &mut err;
         unsafe {
@@ -442,21 +431,21 @@ impl ReadOptions {
 }
 
 pub struct RocksDBVector {
-    base: Unique<u8>,
+    base: *mut u8,
     len: usize,
 }
 
 impl Deref for RocksDBVector {
     type Target = [u8];
     fn deref(&self) -> &[u8] {
-        unsafe { slice::from_raw_parts(self.base.get(), self.len) }
+        unsafe { slice::from_raw_parts(self.base, self.len) }
     }
 }
 
 impl Drop for RocksDBVector {
     fn drop(&mut self) {
         unsafe {
-            libc::free(*self.base.deref() as *mut libc::c_void);
+            libc::free(self.base as *mut libc::c_void);
         }
     }
 }
@@ -465,7 +454,7 @@ impl RocksDBVector {
     pub fn from_c(val: *mut u8, val_len: size_t) -> RocksDBVector {
         unsafe {
             RocksDBVector {
-                base: Unique::new(val),
+                base: val,
                 len: val_len as usize,
             }
         }