[code cosmetics]

(*) remove using of some deprecated functions
(*) reduce size of unsafe blocks

src/ffi.rs

@@ -15,7 +15,6 @@
 */
 extern crate libc;
 use self::libc::{c_char, c_int, c_void, size_t};
-use std::ffi::CString;
 
 #[repr(C)]
 pub struct RocksDBOptions(pub *const c_void);

src/merge_operator.rs

@@ -13,8 +13,6 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 */
-#![allow(unstable)]
-
 extern crate libc;
 use self::libc::{c_char, c_int, c_void, size_t};
 use std::ffi::CString;
@@ -69,8 +67,7 @@ pub extern "C" fn full_merge_callback(
         assert!(!buf.is_null());
         *new_value_length = result.len() as size_t;
         *success = 1 as u8;
-        ptr::copy_memory(&mut *buf, result.as_ptr()
+        ptr::copy(&mut *buf, result.as_ptr() as *const c_void, result.len());
-                         as *const c_void, result.len());
         buf as *const c_char
     }
 }
@@ -94,8 +91,7 @@ pub extern "C" fn partial_merge_callback(
         assert!(!buf.is_null());
         *new_value_length = 1 as size_t;
         *success = 1 as u8;
-        ptr::copy_memory(&mut *buf, result.as_ptr()
+        ptr::copy(&mut *buf, result.as_ptr() as *const c_void, result.len());
-                         as *const c_void, result.len());
         buf as *const c_char
     }
 }

src/rocksdb.rs

@@ -16,13 +16,12 @@
 
 extern crate libc;
 use self::libc::{c_void, size_t};
-use std::ffi::CString;
+use std::ffi::{CString, CStr};
 use std::fs::{self, PathExt};
 use std::ops::Deref;
 use std::path::Path;
 use std::ptr::Unique;
 use std::slice;
-use std::str::from_c_str;
 use std::str::from_utf8;
 
 use rocksdb_ffi;
@@ -33,6 +32,12 @@ pub struct RocksDB {
     inner: rocksdb_ffi::RocksDBInstance,
 }
 
+fn error_message<'a>(ptr: *const i8) -> &'a str {
+    unsafe {
+        return from_utf8(CStr::from_ptr(ptr).to_bytes()).unwrap();
+    }
+}
+
 impl RocksDB {
     pub fn open_default(path: &str) -> Result<RocksDB, &str> {
         let opts = RocksDBOptions::new();
@@ -41,71 +46,69 @@ impl RocksDB {
     }
 
     pub fn open(opts: RocksDBOptions, path: &str) -> Result<RocksDB, &str> {
-        unsafe {
+        let cpath = CString::new(path.as_bytes()).unwrap();
-            let cpath = CString::from_slice(path.as_bytes());
+        let cpath_ptr = cpath.as_ptr();
-            let cpath_ptr = cpath.as_ptr();
+
-
+        let ospath = Path::new(path);
-            let ospath = Path::new(path);
+        if !ospath.exists() {
-            if !ospath.exists() {
+            match fs::create_dir_all(&ospath) {
-                match fs::create_dir_all(&ospath) {
+                Err(_) => return Err(""),
-                    Err(e) => return Err(""),
+                Ok(_) => (),
-                    Ok(_) => (),
-                }
             }
+        }
 
-            let err = 0 as *mut i8;
+        let err = 0 as *mut i8;
-            let db = rocksdb_ffi::rocksdb_open(opts.inner, cpath_ptr, err);
+        let db: rocksdb_ffi::RocksDBInstance;
-            if !err.is_null() {
+
-                let cs = from_c_str(err as *const i8);
+        unsafe {
-                return Err(cs);
+            db = rocksdb_ffi::rocksdb_open(opts.inner, cpath_ptr, err);
-            }
-            if db.0.is_null() {
-                return Err("Could not initialize database.");
-            }
-            Ok(RocksDB{inner: db})
         }
+
+        if !err.is_null() {
+            return Err(error_message(err));
+        }
+        if db.0.is_null() {
+            return Err("Could not initialize database.");
+        }
+        Ok(RocksDB{inner: db})
     }
 
     pub fn destroy(opts: RocksDBOptions, path: &str) -> Result<(), &str> {
-        unsafe {
+        let cpath = CString::new(path.as_bytes()).unwrap();
-            let cpath = CString::from_slice(path.as_bytes());
+        let cpath_ptr = cpath.as_ptr();
-            let cpath_ptr = cpath.as_ptr();
 
-            let ospath = Path::new(path);
+        let ospath = Path::new(path);
-            if !ospath.exists() {
+        if !ospath.exists() {
-                return Err("path does not exist");
+            return Err("path does not exist");
-            }
+        }
 
-            let err = 0 as *mut i8;
+        let err = 0 as *mut i8;
-            let result = rocksdb_ffi::rocksdb_destroy_db(
+        unsafe {
-                opts.inner, cpath_ptr, err);
+            rocksdb_ffi::rocksdb_destroy_db(opts.inner, cpath_ptr, err);
-            if !err.is_null() {
-                let cs = from_c_str(err as *const i8);
-                return Err(cs);
-            }
-            Ok(())
         }
+        if !err.is_null() {
+            return Err(error_message(err));
+        }
+        Ok(())
     }
 
     pub fn repair(opts: RocksDBOptions, path: &str) -> Result<(), &str> {
-        unsafe {
+        let cpath = CString::new(path.as_bytes()).unwrap();
-            let cpath = CString::from_slice(path.as_bytes());
+        let cpath_ptr = cpath.as_ptr();
-            let cpath_ptr = cpath.as_ptr();
 
-            let ospath = Path::new(path);
+        let ospath = Path::new(path);
-            if !ospath.exists() {
+        if !ospath.exists() {
-                return Err("path does not exist");
+            return Err("path does not exist");
-            }
+        }
 
-            let err = 0 as *mut i8;
+        let err = 0 as *mut i8;
-            let result = rocksdb_ffi::rocksdb_repair_db(
+        unsafe {
-                opts.inner, cpath_ptr, err);
+            rocksdb_ffi::rocksdb_repair_db(opts.inner, cpath_ptr, err);
-            if !err.is_null() {
+        }
-                let cs = from_c_str(err as *const i8);
+        if !err.is_null() {
-                return Err(cs);
+            return Err(error_message(err));
-            }
-            Ok(())
         }
+        Ok(())
     }
 
     pub fn create_snapshot(self) -> RocksDBSnapshot {
@@ -122,8 +125,7 @@ impl RocksDB {
                         key.len() as size_t, value.as_ptr(),
                         value.len() as size_t, err);
             if !err.is_null() {
-                let cs = from_c_str(err as *const i8);
+                return Err(error_message(err));
-                return Err(cs);
             }
             return Ok(())
         }
@@ -137,8 +139,7 @@ impl RocksDB {
                         key.len() as size_t, value.as_ptr(),
                         value.len() as size_t, err);
             if !err.is_null() {
-                let cs = from_c_str(err as *const i8);
+                return Err(error_message(err));
-                return Err(cs);
             }
             return Ok(())
         }
@@ -160,8 +161,7 @@ impl RocksDB {
             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_null() {
-                let cs = from_c_str(err as *const i8);
+                return RocksDBResult::Error(error_message(err));
-                return RocksDBResult::Error(cs);
             }
             match val.is_null() {
                 true => RocksDBResult::None,
@@ -179,8 +179,7 @@ impl RocksDB {
             rocksdb_ffi::rocksdb_delete(self.inner, writeopts, key.as_ptr(),
                         key.len() as size_t, err);
             if !err.is_null() {
-                let cs = from_c_str(err as *const i8);
+                return Err(error_message(err));
-                return Err(cs);
             }
             return Ok(())
         }

src/rocksdb_options.rs

@@ -13,8 +13,6 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 */
-#![allow(unstable)]
-
 extern crate libc;
 use self::libc::{c_int, size_t};
 use std::ffi::CString;
@@ -73,7 +71,7 @@ impl RocksDBOptions {
     pub fn add_merge_operator<'a>( &self, name: &str,
         merge_fn: fn (&[u8], Option<&[u8]>, &mut MergeOperands) -> Vec<u8>) {
         let cb = Box::new(MergeOperatorCallback {
-            name: CString::from_slice(name.as_bytes()),
+            name: CString::new(name.as_bytes()).unwrap(),
             merge_fn: merge_fn,
         });