Add support for hash_get/hash_set and Sring operations (#58)

* Add support for hash_get/hash_set
* Add RedisString methods

Author: gkorland

src/context.rs

@@ -176,4 +176,8 @@ impl Context {
     pub fn replicate_verbatim(&self) {
         raw::replicate_verbatim(self.ctx);
     }
+
+    pub fn create_string(&self, s: &str) -> RedisString{
+        RedisString::create(self.ctx, s)
+    }
 }

src/key.rs

@@ -2,7 +2,7 @@ use libc::size_t;
 use std::convert::TryFrom;
 use std::os::raw::c_void;
 use std::ptr;
-use std::string;
+use std::str::Utf8Error;
 use std::time::Duration;
 
 use crate::from_byte_string;
@@ -74,6 +74,15 @@ impl RedisKey {
         };
         Ok(val)
     }
+
+    pub fn hash_get(&self, field: &str) -> Result<Option<RedisString>, RedisError> {
+        let val = if self.is_null() {
+            None
+        } else {
+            hash_get_key(self.ctx, self.key_inner, field)
+        };
+        Ok(val)
+    }
 }
 
 impl Drop for RedisKey {
@@ -130,6 +139,14 @@ impl RedisKeyWritable {
         Ok(Some(read_key(self.key_inner)?))
     }
 
+    pub fn hash_set(&self, field: &str, value: RedisString) -> raw::Status {
+        raw::hash_set(self.key_inner, field, value.inner)
+    }
+
+    pub fn hash_get(&self, field: &str) -> Result<Option<RedisString>, RedisError> {
+        Ok(hash_get_key(self.ctx, self.key_inner, field))
+    }
+
     pub fn set_expire(&self, expire: Duration) -> RedisResult {
         let exp_millis = expire.as_millis();
 
@@ -215,14 +232,23 @@ impl Drop for RedisKeyWritable {
     }
 }
 
-fn read_key(key: *mut raw::RedisModuleKey) -> Result<String, string::FromUtf8Error> {
+fn read_key(key: *mut raw::RedisModuleKey) -> Result<String, Utf8Error> {
     let mut length: size_t = 0;
     from_byte_string(
         raw::string_dma(key, &mut length, raw::KeyMode::READ),
         length,
     )
 }
 
+fn hash_get_key(ctx: *mut raw::RedisModuleCtx, key: *mut raw::RedisModuleKey, field: &str) -> Option<RedisString> {
+    let res = raw::hash_get(key, field);
+    if res.is_null() {
+        None
+    } else {
+        Some(RedisString::new(ctx, res))
+    }
+}
+
 fn to_raw_mode(mode: KeyMode) -> raw::KeyMode {
     match mode {
         KeyMode::Read => raw::KeyMode::READ,

src/lib.rs

@@ -1,7 +1,7 @@
 //#![allow(dead_code)]
 
 use std::os::raw::c_char;
-use std::string;
+use std::str::Utf8Error;
 
 #[macro_use]
 extern crate bitflags;
@@ -40,15 +40,12 @@ pub enum LogLevel {
     Warning,
 }
 
-fn from_byte_string(
-    byte_str: *const c_char,
-    length: size_t,
-) -> Result<String, string::FromUtf8Error> {
+fn from_byte_string(byte_str: *const c_char, length: size_t) -> Result<String, Utf8Error> {
     let mut vec_str: Vec<u8> = Vec::with_capacity(length as usize);
     for j in 0..length {
         let byte = unsafe { *byte_str.offset(j as isize) } as u8;
         vec_str.insert(j, byte);
     }
 
-    String::from_utf8(vec_str)
+    String::from_utf8(vec_str).map_err(|e| e.utf8_error())
 }

src/raw.rs

@@ -11,6 +11,7 @@ extern crate num_traits;
 use libc::size_t;
 use num_traits::FromPrimitive;
 use std::ffi::CString;
+use std::ptr;
 use std::slice;
 
 pub use crate::redisraw::bindings::*;
@@ -235,6 +236,20 @@ pub fn string_dma(key: *mut RedisModuleKey, len: *mut size_t, mode: KeyMode) ->
     unsafe { RedisModule_StringDMA.unwrap()(key, len, mode.bits) }
 }
 
+pub fn hash_get(key: *mut RedisModuleKey, field: &str) -> *mut RedisModuleString {
+    let res: *mut RedisModuleString = ptr::null_mut();
+    unsafe {
+        RedisModule_HashGet.unwrap()(key, REDISMODULE_HASH_CFIELDS as i32, CString::new(field).unwrap().as_ptr(), &res, 0);
+    }
+    res
+}
+
+pub fn hash_set(key: *mut RedisModuleKey, field: &str, value: *mut RedisModuleString) -> Status {
+    unsafe {
+        RedisModule_HashSet.unwrap()(key, REDISMODULE_HASH_CFIELDS as i32, CString::new(field).unwrap().as_ptr(), value, 0).into()
+    }
+}
+
 // Returns pointer to the C string, and sets len to its length
 pub fn string_ptr_len(s: *mut RedisModuleString, len: *mut size_t) -> *const c_char {
     unsafe { RedisModule_StringPtrLen.unwrap()(s, len) }
@@ -318,3 +333,7 @@ pub fn save_float(rdb: *mut RedisModuleIO, val: f32) {
 pub fn save_unsigned(rdb: *mut RedisModuleIO, val: u64) {
     unsafe { RedisModule_SaveUnsigned.unwrap()(rdb, val) };
 }
+
+pub fn string_append_buffer(ctx: *mut RedisModuleCtx, s: *mut RedisModuleString, buff: &str) -> Status {
+    unsafe { RedisModule_StringAppendBuffer.unwrap()(ctx, s, buff.as_ptr() as *mut i8, buff.len()).into() }
+}

src/redismodule.rs

@@ -71,19 +71,36 @@ pub struct RedisString {
 }
 
 impl RedisString {
+    pub fn new(ctx: *mut raw::RedisModuleCtx, inner: *mut raw::RedisModuleString) -> RedisString {
+        RedisString{
+            ctx,
+            inner
+        }
+    }
+
     pub fn create(ctx: *mut raw::RedisModuleCtx, s: &str) -> RedisString {
         let str = CString::new(s).unwrap();
         let inner = unsafe { raw::RedisModule_CreateString.unwrap()(ctx, str.as_ptr(), s.len()) };
 
         RedisString { ctx, inner }
     }
 
-    pub fn from_ptr<'a>(ptr: *mut raw::RedisModuleString) -> Result<&'a str, str::Utf8Error> {
+    pub fn from_ptr<'a>(ptr: *const raw::RedisModuleString) -> Result<&'a str, str::Utf8Error> {
         let mut len: libc::size_t = 0;
         let bytes = unsafe { raw::RedisModule_StringPtrLen.unwrap()(ptr, &mut len) };
 
         str::from_utf8(unsafe { slice::from_raw_parts(bytes as *const u8, len) })
     }
+
+    pub fn append(&mut self, s: &str) -> raw::Status {
+        raw::string_append_buffer(self.ctx, self.inner, s) 
+    }
+
+    pub fn len(&self) -> usize {
+        let mut len: usize = 0;
+        raw::string_ptr_len(self.inner, &mut len);
+        len
+    }
 }
 
 impl Drop for RedisString {