Finish code style refactoring for Redox, add license notices

Conform (mostly) to Google C++ guidelines. Apache license notice and link above each core file.

Finish code style refactoring for Redox, add license notices
Conform (mostly) to Google C++ guidelines. Apache license notice and link above each core file.
Hayk Martirosyan
1 parent b4f96a55
Showing 8 changed files with 227 additions and 103 deletions
examples/pub_sub.cpp
src/command.cpp
src/command.hpp
src/redox.cpp
src/redox.hpp
src/subscriber.cpp
src/subscriber.hpp
test/test.cpp
+/**
+* Redox example for basic pubsub usage.
+*/
+
 #include <stdlib.h>
 #include <iostream>
 #include "../src/redox.hpp"
 /**
-* Redis C++11 wrapper.
+* Redox - A modern, asynchronous, and wicked fast C++11 client for Redis
+*
+*    https://github.com/hmartiro/redox
+*
+* Copyright 2015 - Hayk Martirosyan <hayk.mart at gmail dot com>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
 */
  
 #include <vector>
 /**
-* Redis C++11 wrapper.
+* Redox - A modern, asynchronous, and wicked fast C++11 client for Redis
+*
+*    https://github.com/hmartiro/redox
+*
+* Copyright 2015 - Hayk Martirosyan <hayk.mart at gmail dot com>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
 */
  
 #pragma once
 /**
-* Redis C++11 wrapper.
+* Redox - A modern, asynchronous, and wicked fast C++11 client for Redis
+*
+*    https://github.com/hmartiro/redox
+*
+* Copyright 2015 - Hayk Martirosyan <hayk.mart at gmail dot com>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
 */
  
 #include <signal.h>
-#include <string.h>
 #include "redox.hpp"
  
 using namespace std;
@@ -126,7 +141,7 @@ void Redox::runEventLoop() {
  
   // Set up asynchronous watcher which we signal every
   // time we add a command
-  ev_async_init(&watcher_command_, proccessQueuedCommands);
+  ev_async_init(&watcher_command_, processQueuedCommands);
   ev_async_start(evloop_, &watcher_command_);
  
   // Set up an async watcher to break the loop
@@ -231,10 +246,6 @@ void Redox::commandCallback(redisAsyncContext* ctx, void* r, void* privdata) {
   c->processReply(reply_obj);
 }
  
-/**
-* Submit an asynchronous command to the Redox server. Return
-* true if succeeded, false otherwise.
-*/
 template<class ReplyT>
 bool Redox::submitToServer(Command<ReplyT>* c) {
  
@@ -290,8 +301,6 @@ void Redox::submitCommandCallback(struct ev_loop* loop, ev_timer* timer, int rev
  
   if(c->canceled()) {
  
-//    logger.info() << "Command " << c << " is completed, stopping event timer.";
-
     c->timer_guard_.lock();
     if((c->repeat_ != 0) || (c->after_ != 0))
       ev_timer_stop(loop, &c->timer_);
@@ -307,7 +316,7 @@ void Redox::submitCommandCallback(struct ev_loop* loop, ev_timer* timer, int rev
 }
  
 template<class ReplyT>
-bool Redox::proccessQueuedCommand(long id) {
+bool Redox::processQueuedCommand(long id) {
  
   Command<ReplyT>* c = findCommand<ReplyT>(id);
   if(c == nullptr) return false;
@@ -318,7 +327,7 @@ bool Redox::proccessQueuedCommand(long id) {
   } else {
  
     c->timer_.data = (void*)c->id_;
-    ev_timer_init(&c->timer_, submitCommandCallback <ReplyT>, c->after_, c->repeat_);
+    ev_timer_init(&c->timer_, submitCommandCallback<ReplyT>, c->after_, c->repeat_);
     ev_timer_start(evloop_, &c->timer_);
  
     c->timer_guard_.unlock();
@@ -327,26 +336,26 @@ bool Redox::proccessQueuedCommand(long id) {
   return true;
 }
  
-void Redox::proccessQueuedCommands(struct ev_loop* loop, ev_async* async, int revents) {
+void Redox::processQueuedCommands(struct ev_loop* loop, ev_async* async, int revents) {
  
   Redox* rdx = (Redox*) ev_userdata(loop);
  
-  lock_guard<mutex> lg(rdx->queue_guard);
+  lock_guard<mutex> lg(rdx->queue_guard_);
  
-  while(!rdx->command_queue.empty()) {
+  while(!rdx->command_queue_.empty()) {
  
-    long id = rdx->command_queue.front();
-    rdx->command_queue.pop();
+    long id = rdx->command_queue_.front();
+    rdx->command_queue_.pop();
  
-    if(rdx->proccessQueuedCommand<redisReply*>(id)) {}
-    else if(rdx->proccessQueuedCommand<string>(id)) {}
-    else if(rdx->proccessQueuedCommand<char*>(id)) {}
-    else if(rdx->proccessQueuedCommand<int>(id)) {}
-    else if(rdx->proccessQueuedCommand<long long int>(id)) {}
-    else if(rdx->proccessQueuedCommand<nullptr_t>(id)) {}
-    else if(rdx->proccessQueuedCommand<vector<string>>(id)) {}
-    else if(rdx->proccessQueuedCommand<std::set<string>>(id)) {}
-    else if(rdx->proccessQueuedCommand<unordered_set<string>>(id)) {}
+    if(rdx->processQueuedCommand<redisReply*>(id)) {}
+    else if(rdx->processQueuedCommand<string>(id)) {}
+    else if(rdx->processQueuedCommand<char*>(id)) {}
+    else if(rdx->processQueuedCommand<int>(id)) {}
+    else if(rdx->processQueuedCommand<long long int>(id)) {}
+    else if(rdx->processQueuedCommand<nullptr_t>(id)) {}
+    else if(rdx->processQueuedCommand<vector<string>>(id)) {}
+    else if(rdx->processQueuedCommand<std::set<string>>(id)) {}
+    else if(rdx->processQueuedCommand<unordered_set<string>>(id)) {}
     else throw runtime_error("Command pointer not found in any queue!");
   }
 }
@@ -416,18 +425,8 @@ bool Redox::del(const string&amp; key) {
   return commandSync("DEL " + key);
 }
  
-void Redox::publish(const string topic, const string msg,
-    function<void(const string&, const string&)> pub_callback,
-    function<void(const string&, int)> err_callback
-) {
-  command<redisReply*>("PUBLISH " + topic + " " + msg,
-      [topic, msg, err_callback, pub_callback](Command<redisReply*>& c) {
-        if(!c.ok()) {
-          if(err_callback) err_callback(topic, c.status());
-        }
-        if(pub_callback) pub_callback(topic, msg);
-      }
-  );
+void Redox::publish(const string& topic, const string& msg) {
+  command<redisReply*>("PUBLISH " + topic + " " + msg);
 }
  
 } // End namespace redis
 /**
-* Redis C++11 wrapper.
+* Redox - A modern, asynchronous, and wicked fast C++11 client for Redis
+*
+*    https://github.com/hmartiro/redox
+*
+* Copyright 2015 - Hayk Martirosyan <hayk.mart at gmail dot com>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
 */
  
 #pragma once
@@ -43,7 +59,11 @@ public:
   static const int DISCONNECTED = 2;
   static const int CONNECT_ERROR = 3;
   static const int DISCONNECT_ERROR = 4;
-  
+
+  // ------------------------------------------------
+  // Core public API
+  // ------------------------------------------------
+
   /**
   * Initializes everything, connects over TCP to a Redis server.
   */
@@ -155,30 +175,15 @@ public:
   bool del(const std::string& key);
  
   /**
-  * Publish to a topic. All subscribers will be notified.
-  *
-  * pub_callback: invoked when successfully published
-  * err_callback: invoked on some error state
-  *
-  * // TODO
+  * Redis PUBLISH command wrapper - publish the given message to all subscribers.
+  * Non-blocking call.
   */
-  void publish(const std::string topic, const std::string msg,
-      std::function<void(const std::string&, const std::string&)> pub_callback = nullptr,
-      std::function<void(const std::string&, int)> err_callback = nullptr
-  );
+  void publish(const std::string& topic, const std::string& msg);
  
   // ------------------------------------------------
-  // Public only for Command class
+  // Public members
   // ------------------------------------------------
  
-  // Invoked by Command objects when they are completed
-  template<class ReplyT>
-  void remove_active_command(const long id) {
-    std::lock_guard<std::mutex> lg1(command_map_guard_);
-    getCommandMap<ReplyT>().erase(id);
-    commands_deleted_ += 1;
-  }
-
   // Hiredis context, left public to allow low-level access
   redisAsyncContext * ctx_;
  
@@ -194,6 +199,12 @@ public:
  
 private:
  
+  // ------------------------------------------------
+  // Private methods
+  // ------------------------------------------------
+
+  // One stop shop for creating commands. The base of all public
+  // methods that run commands.
   template<class ReplyT>
   Command<ReplyT>& createCommand(
       const std::string& cmd,
@@ -207,6 +218,56 @@ private:
   void init_ev();
   void init_hiredis();
  
+  // Callbacks invoked on server connection/disconnection
+  static void connectedCallback(const redisAsyncContext* c, int status);
+  static void disconnectedCallback(const redisAsyncContext* c, int status);
+
+  // Main event loop, run in a separate thread
+  void runEventLoop();
+
+  // Return the command map corresponding to the templated reply type
+  template<class ReplyT>
+  std::unordered_map<long, Command<ReplyT>*>& getCommandMap();
+
+  // Return the given Command from the relevant command map, or nullptr if not there
+  template<class ReplyT>
+  Command<ReplyT>* findCommand(long id);
+
+  // Send all commands in the command queue to the server
+  static void processQueuedCommands(struct ev_loop* loop, ev_async* async, int revents);
+
+  // Process the command with the given ID. Return true if the command had the
+  // templated type, and false if it was not in the map of that type.
+  template<class ReplyT>
+  bool processQueuedCommand(long id);
+
+  // Callback given to libev for a Command's timer watcher, to be processed in
+  // a deferred or looping state
+  template<class ReplyT>
+  static void submitCommandCallback(struct ev_loop* loop, ev_timer* timer, int revents);
+
+  // Submit an asynchronous command to the Redox server. Return
+  // true if succeeded, false otherwise.
+  template<class ReplyT>
+  static bool submitToServer(Command<ReplyT>* c);
+
+  // Callback given to hiredis to invoke when a reply is received
+  template<class ReplyT>
+  static void commandCallback(redisAsyncContext* ctx, void* r, void* privdata);
+
+  // Invoked by Command objects when they are completed. Removes them
+  // from the command map.
+  template<class ReplyT>
+  void remove_active_command(const long id) {
+    std::lock_guard<std::mutex> lg1(command_map_guard_);
+    getCommandMap<ReplyT>().erase(id);
+    commands_deleted_ += 1;
+  }
+
+  // ------------------------------------------------
+  // Private members
+  // ------------------------------------------------
+
   // Manage connection state
   std::atomic_int connect_state_ = {NOT_YET_CONNECTED};
   std::mutex connect_lock_;
@@ -258,47 +319,27 @@ private:
   std::unordered_map<long, Command<std::unordered_set<std::string>>*> commands_unordered_set_string_;
   std::mutex command_map_guard_; // Guards access to all of the above
  
-  // Return the correct map from the above, based on the template specialization
-  template<class ReplyT>
-  std::unordered_map<long, Command<ReplyT>*>& getCommandMap();
-
-  // Return the given Command from the relevant command map, or nullptr if not there
-  template<class ReplyT>
-  Command<ReplyT>* findCommand(long id);
-
-  std::queue<long> command_queue;
-  std::mutex queue_guard;
-  static void proccessQueuedCommands(struct ev_loop* loop, ev_async* async, int revents);
+  // Command IDs pending to be sent to the server
+  std::queue<long> command_queue_;
+  std::mutex queue_guard_;
  
+  // Commands use this method to deregister themselves from Redox,
+  // give it access to private members
   template<class ReplyT>
-  bool proccessQueuedCommand(long id);
-
-  void runEventLoop();
-
-  // Callbacks invoked on server connection/disconnection
-  static void connectedCallback(const redisAsyncContext* c, int status);
-  static void disconnectedCallback(const redisAsyncContext* c, int status);
-
-  template<class ReplyT>
-  static void commandCallback(redisAsyncContext* ctx, void* r, void* privdata);
-
-  template<class ReplyT>
-  static bool submitToServer(Command<ReplyT>* c);
-
-  template<class ReplyT>
-  static void submitCommandCallback(struct ev_loop* loop, ev_timer* timer, int revents);
-
+  friend void Command<ReplyT>::freeCommand(Command<ReplyT>* c);
 };
  
-// ---------------------------
+// ------------------------------------------------
+// Implementation of templated methods
+// ------------------------------------------------
  
 template<class ReplyT>
 Command<ReplyT>& Redox::createCommand(
-  const std::string& cmd,
-  const std::function<void(Command<ReplyT>&)>& callback,
-  double repeat,
-  double after,
-  bool free_memory
+    const std::string& cmd,
+    const std::function<void(Command<ReplyT>&)>& callback,
+    double repeat,
+    double after,
+    bool free_memory
 ) {
  
   if(!running_) {
@@ -306,20 +347,20 @@ Command&lt;ReplyT&gt;&amp; Redox::createCommand(
   }
  
   commands_created_ += 1;
-  auto* c = new Command<ReplyT>(this, commands_created_, cmd,
-    callback, repeat, after, free_memory, logger_);
+  auto* c = new Command<ReplyT>(
+      this, commands_created_, cmd,
+      callback, repeat, after, free_memory, logger_
+  );
  
-  std::lock_guard<std::mutex> lg(queue_guard);
+  std::lock_guard<std::mutex> lg(queue_guard_);
   std::lock_guard<std::mutex> lg2(command_map_guard_);
  
   getCommandMap<ReplyT>()[c->id_] = c;
-  command_queue.push(c->id_);
+  command_queue_.push(c->id_);
  
   // Signal the event loop to process this command
   ev_async_send(evloop_, &watcher_command_);
  
-//  logger.debug() << "Created Command " << c->id << " at " << c;
-
   return *c;
 }
  
 /**
-* Redis C++11 wrapper.
+* Redox - A modern, asynchronous, and wicked fast C++11 client for Redis
+*
+*    https://github.com/hmartiro/redox
+*
+* Copyright 2015 - Hayk Martirosyan <hayk.mart at gmail dot com>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
 */
  
 #include <string.h>
 /**
-* Redis C++11 wrapper.
+* Redox - A modern, asynchronous, and wicked fast C++11 client for Redis
+*
+*    https://github.com/hmartiro/redox
+*
+* Copyright 2015 - Hayk Martirosyan <hayk.mart at gmail dot com>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
 */
  
 #pragma once
 /**
-* Test suite for Redox using GTest.
+* Redox - A modern, asynchronous, and wicked fast C++11 client for Redis
+*
+*    https://github.com/hmartiro/redox
+*
+* Copyright 2015 - Hayk Martirosyan <hayk.mart@gmail.com>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
 */
  
 #include <iostream>