Updated to compile with rustc 1.0.0.alpha.2

src/lib.rs

@@ -15,7 +15,13 @@
 */
 #![crate_id = "rocksdb"]
 #![crate_type = "lib"]
-#![allow(dead_code)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(fs)]
+#![feature(io)]
+#![feature(libc)]
+#![feature(path)]
+#![feature(std_misc)]
 
 pub use ffi as rocksdb_ffi;
 pub use ffi::{

src/main.rs

@@ -13,7 +13,8 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 */
-#![allow(unstable)]
+#![feature(collections)]
+#![feature(test)]
 
 extern crate rocksdb;
 extern crate test;

src/merge_operator.rs

@@ -101,17 +101,17 @@ pub extern "C" fn partial_merge_callback(
 }
 
 
-pub struct MergeOperands<'a> {
+pub struct MergeOperands {
     operands_list: *const *const c_char,
     operands_list_len: *const size_t,
     num_operands: usize,
     cursor: usize,
 }
 
-impl <'a> MergeOperands<'a> {
+impl MergeOperands {
     fn new(operands_list: *const *const c_char,
            operands_list_len: *const size_t,
-           num_operands: c_int) -> MergeOperands<'a> {
+           num_operands: c_int) -> MergeOperands {
         assert!(num_operands >= 0);
         MergeOperands {
             operands_list: operands_list,
@@ -122,7 +122,7 @@ impl <'a> MergeOperands<'a> {
     }
 }
 
-impl<'a> Iterator for &'a mut MergeOperands<'a> {
+impl<'a> Iterator for &'a mut MergeOperands {
     type Item = &'a [u8];
     fn next(&mut self) -> Option<&'a [u8]> {
         use std::raw::Slice;

src/rocksdb.rs

@@ -13,19 +13,17 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 */
-#![allow(unstable)]
 
 extern crate libc;
 use self::libc::{c_void, size_t};
+use std::ffi::CString;
+use std::fs::{self, PathExt};
 use std::ops::Deref;
+use std::path::Path;
 use std::ptr::Unique;
-use std::ffi::CString;
-use std::str::from_utf8;
 use std::slice;
 use std::str::from_c_str;
-use std::io::fs::PathExtensions;
+use std::str::from_utf8;
-use std::io;
-use std::io::fs;
 
 use rocksdb_ffi;
 use rocksdb_ffi::RocksDBSnapshot;
@@ -49,8 +47,8 @@ impl RocksDB {
 
             let ospath = Path::new(path);
             if !ospath.exists() {
-                match fs::mkdir_recursive(&ospath, io::USER_DIR) {
+                match fs::create_dir_all(&ospath) {
-                    Err(e) => return Err(e.desc),
+                    Err(e) => return Err(""),
                     Ok(_) => (),
                 }
             }
@@ -146,8 +144,7 @@ impl RocksDB {
         }
     }
 
-    pub fn get<'a>(&self, key: &[u8]) ->
+    pub fn get(&self, key: &[u8]) -> RocksDBResult<RocksDBVector, &str> {
-        RocksDBResult<'a, RocksDBVector, &str> {
         unsafe {
             let readopts = rocksdb_ffi::rocksdb_readoptions_create();
             if readopts.0.is_null() {
@@ -202,14 +199,14 @@ pub struct RocksDBVector {
 impl Deref for RocksDBVector {
     type Target = [u8];
     fn deref(&self) -> &[u8] {
-        unsafe { slice::from_raw_mut_buf(&self.base.0, self.len) }
+        unsafe { slice::from_raw_mut_buf(self.base.deref(), self.len) }
     }
 }
 
 impl Drop for RocksDBVector {
     fn drop(&mut self) {
         unsafe {
-            libc::free(self.base.0 as *mut libc::c_void);
+            libc::free(*self.base.deref() as *mut libc::c_void);
         }
     }
 }
@@ -217,7 +214,7 @@ impl Drop for RocksDBVector {
 impl RocksDBVector {
     pub fn from_c(val: *mut u8, val_len: size_t) -> RocksDBVector {
         unsafe {
-            let base = Unique(val);
+            let base = Unique::new(val);
             RocksDBVector {
                 base: base,
                 len: val_len as usize,
@@ -232,15 +229,15 @@ impl RocksDBVector {
 
 // RocksDBResult exists because of the inherent difference between
 // an operational failure and the absence of a possible result.
-#[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Show)]
+#[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Debug)]
-pub enum RocksDBResult<'a,T,E> {
+pub enum RocksDBResult<T, E> {
     Some(T),
     None,
     Error(E),
 }
 
-impl <'a,T,E> RocksDBResult<'a,T,E> {
+impl <T, E> RocksDBResult<T, E> {
-    pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> RocksDBResult<'a,U,E> {
+    pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> RocksDBResult<U, E> {
         match self {
             RocksDBResult::Some(x) => RocksDBResult::Some(f(x)),
             RocksDBResult::None => RocksDBResult::None,
@@ -258,7 +255,7 @@ impl <'a,T,E> RocksDBResult<'a,T,E> {
         }
     }
 
-    pub fn on_error<U, F: FnOnce(E) -> U>(self, f: F) -> RocksDBResult<'a,T,U> {
+    pub fn on_error<U, F: FnOnce(E) -> U>(self, f: F) -> RocksDBResult<T, U> {
         match self {
             RocksDBResult::Some(x) => RocksDBResult::Some(x),
             RocksDBResult::None => RocksDBResult::None,
@@ -266,7 +263,7 @@ impl <'a,T,E> RocksDBResult<'a,T,E> {
         }
     }
 
-    pub fn on_absent<F: FnOnce()->()>(self, f: F) -> RocksDBResult<'a,T,E> {
+    pub fn on_absent<F: FnOnce()->()>(self, f: F) -> RocksDBResult<T, E> {
         match self {
             RocksDBResult::Some(x) => RocksDBResult::Some(x),
             RocksDBResult::None => {