Add nullptr_t command type, refactor code even more

Added Command<nullptr_t> which successfully returns NIL replies from Redis, with REDOX_OK. Also renamed constants from REDISX_ -> REDOX_. Moved a bunch of code from redox.cpp into command.cpp, where it logically makes more sense.

Add nullptr_t command type, refactor code even more
Added Command<nullptr_t> which successfully returns NIL replies from Redis, with REDOX_OK. Also renamed constants from REDISX_ -> REDOX_. Moved a bunch of code from redox.cpp into command.cpp, where it logically makes more sense.
Hayk Martirosyan
1 parent dc17c42e
Showing 7 changed files with 156 additions and 96 deletions
CMakeLists.txt
examples/simple_loop.cpp
examples/simple_sync_loop.cpp
src/command.cpp
src/command.hpp
src/redox.cpp
src/redox.hpp
@@ -13,6 +13,7 @@ set(SRC_DIR ${CMAKE_SOURCE_DIR}/src)
  
 set(SRC_CORE
   ${SRC_DIR}/redox.cpp
+  ${SRC_DIR}/command.cpp
 )
  
 set(SRC_ALL ${SRC_CORE})
@@ -17,19 +17,21 @@ int main(int argc, char* argv[]) {
  
   Redox rdx = {"localhost", 6379};
   rdx.run();
-//
-//  Command<int>* del_cmd = rdx.command_blocking<int>("DEL simple_loop:count");
-//  cout << "deleted key, reply: " << del_cmd->reply() << endl;
-//  del_cmd->free();
+
   if(rdx.command_blocking("DEL simple_loop:count")) cout << "Deleted simple_loop:count" << endl;
   else cerr << "Failed to delete simple_loop:count" << endl;
  
+  Command<nullptr_t>* null_cmd = rdx.command_blocking<nullptr_t>("GET WFEOIEFJ");
+  if(null_cmd->status() == REDOX_OK) cout << "got nonexistent key." << endl;
+  else cerr << "error with null cmd: " << null_cmd->status() << endl;
+  null_cmd->free();
+
   Command<char*>* set_cmd = rdx.command_blocking<char*>("SET simple_loop:count 0");
   cout << "set key, reply: " << set_cmd->reply() << endl;
   set_cmd->free();
  
   Command<char*>* count_cmd = rdx.command_blocking<char*>("GET simple_loop:count");
-  if(count_cmd->status() == REDISX_OK) {
+  if(count_cmd->status() == REDOX_OK) {
     cout << "At the start, simple_loop:count = " << count_cmd->reply() << endl;
   }
   count_cmd->free();
@@ -38,7 +40,7 @@ int main(int argc, char* argv[]) {
  
   double freq = 10000; // Hz
   double dt = 1 / freq; // s
-  double t = 1; // s
+  double t = 3; // s
  
   cout << "Running \"" << cmd_str << "\" at dt = " << dt
       << "s for " << t << "s..." << endl;
@@ -30,7 +30,7 @@ int main(int argc, char* argv[]) {
  
   for(int i = 0; i < count; i++) {
     Command<int>* c = rdx.command_blocking<int>(cmd_str);
-    if(c->status() != REDIS_OK) cerr << "Bad reply, code: " << c->status() << endl;
+    if(c->status() != REDOX_OK) cerr << "Bad reply, code: " << c->status() << endl;
   }
  
   cout << "At the end, simple_loop:count = "
+/**
+* Redis C++11 wrapper.
+*/
+
+#include "command.hpp"
+
+namespace redox {
+
+template<class ReplyT>
+bool Command<ReplyT>::is_error_reply() {
+
+  if (reply_obj->type == REDIS_REPLY_ERROR) {
+    std::cerr << "[ERROR] " << cmd << ": " << reply_obj->str << std::endl;
+    return true;
+  }
+  return false;
+}
+
+template<class ReplyT>
+bool Command<ReplyT>::is_nil_reply() {
+
+  if (reply_obj->type == REDIS_REPLY_NIL) {
+    std::cerr << "[WARNING] " << cmd << ": Nil reply." << std::endl;
+    return true;
+  }
+  return false;
+}
+
+template<>
+void Command<redisReply*>::invoke_callback() {
+  invoke(reply_obj);
+}
+
+template<>
+void Command<std::string>::invoke_callback() {
+
+  if(is_error_reply()) invoke_error(REDOX_ERROR_REPLY);
+  else if(is_nil_reply()) invoke_error(REDOX_NIL_REPLY);
+
+  else if(reply_obj->type != REDIS_REPLY_STRING && reply_obj->type != REDIS_REPLY_STATUS) {
+    std::cerr << "[ERROR] " << cmd << ": Received non-string reply." << std::endl;
+    invoke_error(REDOX_WRONG_TYPE);
+
+  } else {
+    std::string s = reply_obj->str;
+    invoke(s);
+  }
+}
+
+template<>
+void Command<char*>::invoke_callback() {
+
+  if(is_error_reply()) invoke_error(REDOX_ERROR_REPLY);
+  else if(is_nil_reply()) invoke_error(REDOX_NIL_REPLY);
+
+  else if(reply_obj->type != REDIS_REPLY_STRING && reply_obj->type != REDIS_REPLY_STATUS) {
+    std::cerr << "[ERROR] " << cmd << ": Received non-string reply." << std::endl;
+    invoke_error(REDOX_WRONG_TYPE);
+
+  } else {
+    invoke(reply_obj->str);
+  }
+}
+
+template<>
+void Command<int>::invoke_callback() {
+
+  if(is_error_reply()) invoke_error(REDOX_ERROR_REPLY);
+  else if(is_nil_reply()) invoke_error(REDOX_NIL_REPLY);
+
+  else if(reply_obj->type != REDIS_REPLY_INTEGER) {
+    std::cerr << "[ERROR] " << cmd << ": Received non-integer reply." << std::endl;
+    invoke_error(REDOX_WRONG_TYPE);
+
+  } else {
+    invoke((int) reply_obj->integer);
+  }
+}
+
+template<>
+void Command<long long int>::invoke_callback() {
+
+  if(is_error_reply()) invoke_error(REDOX_ERROR_REPLY);
+  else if(is_nil_reply()) invoke_error(REDOX_NIL_REPLY);
+
+  else if(reply_obj->type != REDIS_REPLY_INTEGER) {
+    std::cerr << "[ERROR] " << cmd << ": Received non-integer reply." << std::endl;
+    invoke_error(REDOX_WRONG_TYPE);
+
+  } else {
+    invoke(reply_obj->integer);
+  }
+}
+
+template<>
+void Command<std::nullptr_t>::invoke_callback() {
+
+  if(is_error_reply()) invoke_error(REDOX_ERROR_REPLY);
+
+  else if(reply_obj->type != REDIS_REPLY_NIL) {
+    std::cerr << "[ERROR] " << cmd << ": Received non-nil reply." << std::endl;
+    invoke_error(REDOX_WRONG_TYPE);
+
+  } else {
+    invoke(nullptr);
+  }
+}
+
+} // End namespace redox
@@ -8,19 +8,20 @@
 #include <string>
 #include <functional>
 #include <atomic>
+#include <mutex>
  
 #include <hiredis/adapters/libev.h>
 #include <hiredis/async.h>
  
 namespace redox {
  
-static const int REDISX_UNINIT = -1;
-static const int REDISX_OK = 0;
-static const int REDISX_SEND_ERROR = 1;
-static const int REDISX_WRONG_TYPE = 2;
-static const int REDISX_NIL_REPLY = 3;
-static const int REDISX_ERROR_REPLY = 4;
-static const int REDISX_TIMEOUT = 5;
+static const int REDOX_UNINIT = -1;
+static const int REDOX_OK = 0;
+static const int REDOX_SEND_ERROR = 1;
+static const int REDOX_WRONG_TYPE = 2;
+static const int REDOX_NIL_REPLY = 3;
+static const int REDOX_ERROR_REPLY = 4;
+static const int REDOX_TIMEOUT = 5;
  
 template<class ReplyT>
 class Command {
@@ -60,7 +61,7 @@ public:
   */
   void free();
  
-  void free_reply_object();
+  static void command_callback(redisAsyncContext *c, void *r, void *privdata);
  
 private:
  
@@ -81,6 +82,12 @@ private:
     std::lock_guard<std::mutex> lg(timer_guard);
     return &timer;
   }
+
+  void free_reply_object();
+
+  void invoke_callback();
+  bool is_error_reply();
+  bool is_nil_reply();
 };
  
 template<class ReplyT>
@@ -97,6 +104,17 @@ Command&lt;ReplyT&gt;::Command(
 }
  
 template<class ReplyT>
+void Command<ReplyT>::command_callback(redisAsyncContext *c, void *r, void *privdata) {
+
+  auto *cmd_obj = (Command<ReplyT> *) privdata;
+  cmd_obj->reply_obj = (redisReply *) r;
+  cmd_obj->invoke_callback();
+
+  // Free the reply object unless told not to
+  if(cmd_obj->free_memory) cmd_obj->free_reply_object();
+}
+
+template<class ReplyT>
 void Command<ReplyT>::invoke(const ReplyT& r) {
  
   if(callback) callback(cmd, r);
@@ -148,7 +166,7 @@ void Command&lt;ReplyT&gt;::free() {
  
 template<class ReplyT>
 const ReplyT& Command<ReplyT>::reply() {
-  if(reply_status != REDISX_OK) {
+  if(reply_status != REDOX_OK) {
     std::cout << "[WARNING] " << cmd
               << ": Accessing value of reply with status != OK." << std::endl;
   }
@@ -98,34 +98,6 @@ void Redox::block() {
   exit_waiter.wait(ul, [this]() { return to_exit.load(); });
 }
  
-template<class ReplyT>
-void invoke_callback(
-  Command<ReplyT>* cmd_obj,
-  redisReply* reply
-);
-
-template<class ReplyT>
-void Redox::command_callback(redisAsyncContext *c, void *r, void *privdata) {
-
-  auto *cmd_obj = (Command<ReplyT> *) privdata;
-  cmd_obj->reply_obj = (redisReply *) r;
-
-  if (cmd_obj->reply_obj->type == REDIS_REPLY_ERROR) {
-    std::cerr << "[ERROR redisx.hpp:121] " << cmd_obj->cmd << ": " << cmd_obj->reply_obj->str << std::endl;
-    cmd_obj->invoke_error(REDISX_ERROR_REPLY);
-
-  } else if(cmd_obj->reply_obj->type == REDIS_REPLY_NIL) {
-    std::cerr << "[WARNING] " << cmd_obj->cmd << ": Nil reply." << std::endl;
-    cmd_obj->invoke_error(REDISX_NIL_REPLY);
-
-  } else {
-    invoke_callback<ReplyT>(cmd_obj, cmd_obj->reply_obj);
-  }
-
-  // Free the reply object unless told not to
-  if(cmd_obj->free_memory) cmd_obj->free_reply_object();
-}
-
 /**
 * Submit an asynchronous command to the Redox server. Return
 * true if succeeded, false otherwise.
@@ -133,9 +105,9 @@ void Redox::command_callback(redisAsyncContext *c, void *r, void *privdata) {
 template<class ReplyT>
 bool submit_to_server(Command<ReplyT>* cmd_obj) {
   cmd_obj->pending++;
-  if (redisAsyncCommand(cmd_obj->c, Redox::command_callback<ReplyT>, (void*)cmd_obj, cmd_obj->cmd.c_str()) != REDIS_OK) {
+  if (redisAsyncCommand(cmd_obj->c, cmd_obj->command_callback, (void*)cmd_obj, cmd_obj->cmd.c_str()) != REDIS_OK) {
     cerr << "[ERROR] Could not send \"" << cmd_obj->cmd << "\": " << cmd_obj->c->errstr << endl;
-    cmd_obj->invoke_error(REDISX_SEND_ERROR);
+    cmd_obj->invoke_error(REDOX_SEND_ERROR);
     return false;
   }
   return true;
@@ -191,6 +163,7 @@ void Redox::process_queued_commands() {
     else if(process_queued_command<char*>(cmd_ptr)) {}
     else if(process_queued_command<int>(cmd_ptr)) {}
     else if(process_queued_command<long long int>(cmd_ptr)) {}
+    else if(process_queued_command<nullptr_t>(cmd_ptr)) {}
     else throw runtime_error("[FATAL] Command pointer not found in any queue!");
  
     command_queue.pop();
@@ -208,64 +181,20 @@ long Redox::num_commands_processed() {
 template<> unordered_map<void*, Command<redisReply*>*>&
 Redox::get_command_map() { return commands_redis_reply; }
  
-template<>
-void invoke_callback(Command<redisReply*>* cmd_obj, redisReply* reply) {
-  cmd_obj->invoke(reply);
-}
-
 template<> unordered_map<void*, Command<string>*>&
 Redox::get_command_map() { return commands_string_r; }
  
-template<>
-void invoke_callback(Command<string>* cmd_obj, redisReply* reply) {
-  if(reply->type != REDIS_REPLY_STRING && reply->type != REDIS_REPLY_STATUS) {
-    cerr << "[ERROR] " << cmd_obj->cmd << ": Received non-string reply." << endl;
-    cmd_obj->invoke_error(REDISX_WRONG_TYPE);
-    return;
-  }
-
-  string s = reply->str;
-  cmd_obj->invoke(s);
-}
-
 template<> unordered_map<void*, Command<char*>*>&
 Redox::get_command_map() { return commands_char_p; }
  
-template<>
-void invoke_callback(Command<char*>* cmd_obj, redisReply* reply) {
-  if(reply->type != REDIS_REPLY_STRING && reply->type != REDIS_REPLY_STATUS) {
-    cerr << "[ERROR] " << cmd_obj->cmd << ": Received non-string reply." << endl;
-    cmd_obj->invoke_error(REDISX_WRONG_TYPE);
-    return;
-  }
-  cmd_obj->invoke(reply->str);
-}
-
 template<> unordered_map<void*, Command<int>*>&
 Redox::get_command_map() { return commands_int; }
  
-template<>
-void invoke_callback(Command<int>* cmd_obj, redisReply* reply) {
-  if(reply->type != REDIS_REPLY_INTEGER) {
-    cerr << "[ERROR] " << cmd_obj->cmd << ": Received non-integer reply." << endl;
-    cmd_obj->invoke_error(REDISX_WRONG_TYPE);
-    return;
-  }
-  cmd_obj->invoke((int)reply->integer);
-}
-
 template<> unordered_map<void*, Command<long long int>*>&
 Redox::get_command_map() { return commands_long_long_int; }
  
-template<>
-void invoke_callback(Command<long long int>* cmd_obj, redisReply* reply) {
-  if(reply->type != REDIS_REPLY_INTEGER) {
-    cerr << "[ERROR] " << cmd_obj->cmd << ": Received non-integer reply." << endl;
-    cmd_obj->invoke_error(REDISX_WRONG_TYPE);
-    return;
-  }
-  cmd_obj->invoke(reply->integer);
-}
+template<> unordered_map<void*, Command<nullptr_t>*>&
+Redox::get_command_map() { return commands_null; }
  
 // ----------------------------
 // Helpers
@@ -277,7 +206,7 @@ void Redox::command(const string&amp; cmd) {
  
 bool Redox::command_blocking(const string& cmd) {
   Command<redisReply*>* c = command_blocking<redisReply*>(cmd);
-  bool succeeded = (c->status() == REDISX_OK);
+  bool succeeded = (c->status() == REDOX_OK);
   c->free();
   return succeeded;
 }
@@ -89,6 +89,7 @@ private:
   std::unordered_map<void*, Command<char*>*> commands_char_p;
   std::unordered_map<void*, Command<int>*> commands_int;
   std::unordered_map<void*, Command<long long int>*> commands_long_long_int;
+  std::unordered_map<void*, Command<std::nullptr_t>*> commands_null;
  
   template<class ReplyT>
   std::unordered_map<void*, Command<ReplyT>*>& get_command_map();
@@ -142,7 +143,7 @@ template&lt;class ReplyT&gt;
 Command<ReplyT>* Redox::command_blocking(const std::string& cmd) {
  
   ReplyT val;
-  std::atomic_int status(REDISX_UNINIT);
+  std::atomic_int status(REDOX_UNINIT);
  
   std::condition_variable cv;
   std::mutex m;
@@ -153,7 +154,7 @@ Command&lt;ReplyT&gt;* Redox::command_blocking(const std::string&amp; cmd) {
     [&val, &status, &m, &cv](const std::string& cmd_str, const ReplyT& reply) {
       std::unique_lock<std::mutex> ul(m);
       val = reply;
-      status = REDISX_OK;
+      status = REDOX_OK;
       ul.unlock();
       cv.notify_one();
     },
@@ -167,7 +168,7 @@ Command&lt;ReplyT&gt;* Redox::command_blocking(const std::string&amp; cmd) {
   );
  
   // Wait until a callback is invoked
-  cv.wait(lk, [&status] { return status != REDISX_UNINIT; });
+  cv.wait(lk, [&status] { return status != REDOX_UNINIT; });
  
   cmd_obj->reply_val = val;
   cmd_obj->reply_status = status;