More API improvements

Author: gavrie

examples/data_type.rs

@@ -3,6 +3,7 @@ extern crate redismodule;
 
 use redismodule::{Context, Command, RedisResult, NextArg};
 use redismodule::native_types::RedisType;
+use redismodule::redismodule::RedisValue;
 
 #[derive(Debug)]
 struct MyType {
@@ -20,53 +21,38 @@ fn alloc_set(ctx: &Context, args: Vec<String>) -> RedisResult {
 
     let key = ctx.open_key_writable(&key);
 
-    if key.is_empty() {
-        let value = MyType {
-            data: "A".repeat(size as usize)
-        };
-
-        ctx.log_debug(format!("key is empty; setting to value: '{:?}'", value).as_str());
-
-        key.set_value(&MY_REDIS_TYPE, value)?;
-    } else {
-        ctx.log_debug(format!("key exists; getting value").as_str());
-
-        let value: &mut MyType = key.get_value(&MY_REDIS_TYPE)?;
-        ctx.log_debug(format!("got value: '{:?}'", value).as_str());
-
-        value.data = "B".repeat(size as usize);
-        ctx.log_debug(format!("new value: '{:?}'", value).as_str());
-    };
+    match key.get_value::<MyType>(&MY_REDIS_TYPE)? {
+        None => {
+            let value = MyType {
+                data: "A".repeat(size as usize)
+            };
+
+            key.set_value(&MY_REDIS_TYPE, value)?;
+        }
+        Some(value) => {
+            value.data = "B".repeat(size as usize);
+        }
+    }
 
     Ok(size.into())
 }
 
-
-/*
 fn alloc_get(ctx: &Context, args: Vec<String>) -> RedisResult {
     let mut args = args.into_iter().skip(1);
     let key = args.next_string()?;
 
-    let key = ctx.open_key(&key);
-
-    key.verify_and_get_type(&MY_REDIS_TYPE)?;
-    let my = key.get_value() as *mut MyType;
+    let key = ctx.open_key_writable(&key); // TODO: Use read-only key
 
-    if my.is_null() {
-        r.reply_integer(0)?;
-        return Ok(());
+    match key.get_value::<MyType>(&MY_REDIS_TYPE)? {
+        None => Ok(RedisValue::None),
+        Some(value) => {
+            // TODO: Use the value
+            let _ = value;
+            Ok("some value".into())
+        }
     }
 
-    let my = unsafe { &mut *my };
-    let size = my.data.len();
-
-    r.reply_array(2)?;
-    r.reply_integer(size as i64)?;
-    r.reply_string(my.data.as_str())?;
-
-    Ok(())
 }
-*/
 
 //////////////////////////////////////////////////////
 

src/context.rs

@@ -70,6 +70,10 @@ impl Context {
                 raw::Status::Ok
             }
 
+            Ok(RedisValue::None) => unsafe {
+                raw::RedisModule_ReplyWithNull.unwrap()(self.ctx).into()
+            }
+
             Err(RedisError::WrongArity) => unsafe {
                 raw::RedisModule_WrongArity.unwrap()(self.ctx).into()
             }
@@ -83,10 +87,6 @@ impl Context {
                 let msg = CString::new(s).unwrap();
                 raw::RedisModule_ReplyWithError.unwrap()(self.ctx, msg.as_ptr()).into()
             }
-
-            Err(RedisError::MissingValue) => unsafe {
-                raw::RedisModule_ReplyWithNull.unwrap()(self.ctx).into()
-            }
         }
     }
 

src/key.rs

@@ -173,22 +173,24 @@ impl RedisKeyWritable {
         Ok("OK".into())
     }
 
-    pub fn get_value<T: Debug>(&self, redis_type: &RedisType) -> Result<&mut T, RedisError> {
+    pub fn get_value<T: Debug>(&self, redis_type: &RedisType) -> Result<Option<&mut T>, RedisError> {
         self.verify_type(redis_type)?;
 
+        redis_log(self.ctx, "Going to get value");
+
         let value = unsafe {
             raw::RedisModule_ModuleTypeGetValue.unwrap()(self.key_inner) as *mut T
         };
 
         if value.is_null() {
-            return Err(RedisError::MissingValue);
+            return Ok(None)
         }
 
         let value = unsafe { &mut *value };
 
         redis_log(self.ctx, format!("got value: '{:?}'", value).as_str());
 
-        Ok(value)
+        Ok(Some(value))
     }
 
     pub fn set_value<T: Debug>(&self, redis_type: &RedisType, value: T) -> Result<(), RedisError> {

src/redismodule.rs

@@ -11,14 +11,14 @@ pub enum RedisError {
     WrongArity,
     Str(&'static str),
     String(String),
-    MissingValue,
 }
 
 #[derive(Debug, PartialEq)]
 pub enum RedisValue {
     String(String),
     Integer(i64),
     Array(Vec<RedisValue>),
+    None,
 }
 
 impl From<i64> for RedisValue {