?

.gitignore

@@ -3,6 +3,7 @@ Release
 *.o
 *~
 *.mk
+.history
 libServerCore.a
 docs/latex/
 docs/html

.history/SubscriptionHandler_20221013185305.cpp

@@ -0,0 +1,68 @@
+#include "Subscription.h"
+#include "TCPSession.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   Subscription::Subscription(std::string id, std::string mode)
+       : id(id), mode(mode), owner(NULL) {}
+
+   Subscription::Subscription(std::string id, TCPSession &session, std::string mode)
+       : id(id), mode(mode), owner(&session) {}
+
+   Subscription::~Subscription()
+   {
+      std::stringstream out;
+      out << "cancel:" << id << std::endl;
+      for (auto subscriber : subscribers)
+      {
+         subscriber->write(out.str());
+      }
+   }
+
+   int Subscription::subscribe(TCPSession &session)
+   {
+      onSubscribe(session);
+      subscribers.push_back(&session);
+      return 1;
+   }
+
+   int Subscription::unsubscribe(TCPSession &session)
+   {
+      for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber)
+      {
+         if (*subscriber == &session)
+         {
+            subscribers.erase(subscriber++);
+            return 1;
+         }
+      }
+      return 0;
+   }
+
+   int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session)
+   {
+      out << "event:" << request[1] << ":" << request[2] << std::endl;
+      return 1;
+   }
+
+   int Subscription::event(std::stringstream &out)
+   {
+      for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber)
+         (*subscriber)->write(out.str());
+      return 1;
+   }
+
+   bool Subscription::ifSubscriber(TCPSession &session)
+   {
+      return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end());
+   }
+
+   int Subscription::onSubscribe(TCPSession &session)
+   {
+      return 0;
+   }
+
+}

.history/SubscriptionHandler_20221013191001.h

@@ -0,0 +1,24 @@
+#ifndef __SubscriptionHandler_h__
+#define __SubscriptionHandler_h__
+
+#include "ZString.h"
+#include <vector>
+#include <string>
+
+namespace core
+{
+
+   class SubscriptionHandler
+   {
+
+   public:
+      SubscriptionHandler();
+
+      virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session);
+
+      virtual int onSubscribe(TCPSession &session);
+
+   };
+}
+
+#endif

.history/SubscriptionHandler_20221013204338.h

@@ -0,0 +1,23 @@
+#ifndef __SubscriptionHandler_h__
+#define __SubscriptionHandler_h__
+
+#include "ZString.h"
+#include <string>
+#include <vector>
+
+namespace core
+{
+
+   class SubscriptionHandler
+   {
+
+   public:
+      SubscriptionHandler();
+
+      virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session);
+
+      virtual int onSubscribe(TCPSession &session);
+   };
+}
+
+#endif

.history/SubscriptionHandler_20221013204409.cpp

@@ -0,0 +1,68 @@
+#include "SubscriptionHandler.h"
+#include "Log.h"
+#include "TCPSession.h"
+#include <algorithm>
+
+namespace core
+{
+
+   Subscription::Subscription(std::string id, std::string mode)
+       : id(id), mode(mode), owner(NULL) {}
+
+   Subscription::Subscription(std::string id, TCPSession &session, std::string mode)
+       : id(id), mode(mode), owner(&session) {}
+
+   Subscription::~Subscription()
+   {
+      std::stringstream out;
+      out << "cancel:" << id << std::endl;
+      for (auto subscriber : subscribers)
+      {
+         subscriber->write(out.str());
+      }
+   }
+
+   int Subscription::subscribe(TCPSession &session)
+   {
+      onSubscribe(session);
+      subscribers.push_back(&session);
+      return 1;
+   }
+
+   int Subscription::unsubscribe(TCPSession &session)
+   {
+      for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber)
+      {
+         if (*subscriber == &session)
+         {
+            subscribers.erase(subscriber++);
+            return 1;
+         }
+      }
+      return 0;
+   }
+
+   int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session)
+   {
+      out << "event:" << request[1] << ":" << request[2] << std::endl;
+      return 1;
+   }
+
+   int Subscription::event(std::stringstream &out)
+   {
+      for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber)
+         (*subscriber)->write(out.str());
+      return 1;
+   }
+
+   bool Subscription::ifSubscriber(TCPSession &session)
+   {
+      return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end());
+   }
+
+   int Subscription::onSubscribe(TCPSession &session)
+   {
+      return 0;
+   }
+
+}

.history/SubscriptionHandler_20221013204504.h

@@ -0,0 +1,23 @@
+#ifndef __SubscriptionHandler_h__
+#define __SubscriptionHandler_h__
+
+#include "ZString.h"
+#include <string>
+#include <vector>
+
+namespace core
+{
+
+   class SubscriptionHandler
+   {
+
+   public:
+      SubscriptionHandler();
+
+      virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session);
+
+      virtual int onSubscribe(TCPSession &session);
+   };
+}
+
+#endif

.history/SubscriptionHandler_20221013204612.cpp

@@ -0,0 +1,68 @@
+#include "Log.h"
+#include "Subscription.h"
+#include "TCPSession.h"
+#include <algorithm>
+
+namespace core
+{
+
+   Subscription::Subscription(std::string id, std::string mode)
+       : id(id), mode(mode), owner(NULL) {}
+
+   Subscription::Subscription(std::string id, TCPSession &session, std::string mode)
+       : id(id), mode(mode), owner(&session) {}
+
+   Subscription::~Subscription()
+   {
+      std::stringstream out;
+      out << "cancel:" << id << std::endl;
+      for (auto subscriber : subscribers)
+      {
+         subscriber->write(out.str());
+      }
+   }
+
+   int Subscription::subscribe(TCPSession &session)
+   {
+      onSubscribe(session);
+      subscribers.push_back(&session);
+      return 1;
+   }
+
+   int Subscription::unsubscribe(TCPSession &session)
+   {
+      for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber)
+      {
+         if (*subscriber == &session)
+         {
+            subscribers.erase(subscriber++);
+            return 1;
+         }
+      }
+      return 0;
+   }
+
+   int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session)
+   {
+      out << "event:" << request[1] << ":" << request[2] << std::endl;
+      return 1;
+   }
+
+   int Subscription::event(std::stringstream &out)
+   {
+      for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber)
+         (*subscriber)->write(out.str());
+      return 1;
+   }
+
+   bool Subscription::ifSubscriber(TCPSession &session)
+   {
+      return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end());
+   }
+
+   int Subscription::onSubscribe(TCPSession &session)
+   {
+      return 0;
+   }
+
+}

.history/SubscriptionHandler_20221014152050.h

@@ -0,0 +1,22 @@
+#ifndef __SubscriptionHandler_h__
+#define __SubscriptionHandler_h__
+
+#include "TCPSession.h"
+#include "ZString.h"
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace core
+{
+
+   class SubscriptionHandler
+   {
+
+   public:
+      virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session);
+      virtual int onSubscribe(TCPSession &session){};
+   };
+}
+
+#endif

.history/SubscriptionHandler_20221014152131.h

@@ -0,0 +1,22 @@
+#ifndef __SubscriptionHandler_h__
+#define __SubscriptionHandler_h__
+
+#include "TCPSession.h"
+#include "ZString.h"
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace core
+{
+
+   class SubscriptionHandler
+   {
+
+   public:
+      virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session);
+      virtual int onSubscribe(TCPSession &session) {}
+   };
+}
+
+#endif

.history/SubscriptionHandler_20221014152241.h

@@ -0,0 +1,22 @@
+#ifndef __SubscriptionHandler_h__
+#define __SubscriptionHandler_h__
+
+#include "TCPSession.h"
+#include "ZString.h"
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace core
+{
+
+   class SubscriptionHandler : public Base
+   {
+
+   public:
+      virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session);
+      virtual int onSubscribe(TCPSession &session) {}
+   };
+}
+
+#endif

.history/SubscriptionHandler_20221014152252.h

@@ -0,0 +1,22 @@
+#ifndef __SubscriptionHandler_h__
+#define __SubscriptionHandler_h__
+
+#include "TCPSession.h"
+#include "ZString.h"
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace core
+{
+
+   class SubscriptionHandler
+   {
+
+   public:
+      virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session);
+      virtual int onSubscribe(TCPSession &session) {}
+   };
+}
+
+#endif

.history/SubscriptionHandler_20221014152513.h

@@ -0,0 +1,22 @@
+#ifndef __SubscriptionHandler_h__
+#define __SubscriptionHandler_h__
+
+#include "TCPSession.h"
+#include "ZString.h"
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace core
+{
+
+   class SubscriptionHandler
+   {
+
+   public:
+      virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session);
+      virtual int onSubscribe(TCPSession &session) { return 1; }
+   };
+}
+
+#endif

.history/SubscriptionHandler_20221014153238.h

@@ -0,0 +1,23 @@
+#ifndef __SubscriptionHandler_h__
+#define __SubscriptionHandler_h__
+
+#include "ZString.h"
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace core
+{
+
+   class TCPSession;
+
+   class SubscriptionHandler
+   {
+
+   public:
+      virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session);
+      virtual int onSubscribe(TCPSession &session);
+   };
+}
+
+#endif

.history/SubscriptionManager_20221013225816.h

@@ -0,0 +1,33 @@
+#ifndef __SubscriptionManager_h__
+#define __SubscriptionManager_h__
+
+#include "TCPSession.h"
+#include "Subscription.h"
+#include "Command.h"
+#include "ZString.h"
+#include <vector>
+#include <string>
+
+namespace core {
+
+   class SubscriptionManager : public Command {
+      
+    public:
+      SubscriptionManager();
+      
+      int add(Subscription &subscription);
+      int addHandler(std::string name, SubscriptionHandler &handler)
+      
+      int removeSessionSubscriptions(TCPSession &session);
+      
+      int processCommand(coreutils::ZString &request, TCPSession &session) override;
+      
+    private:
+      std::map<std::string, Subscription *> subscriptions;
+      std::map<std::string, SubscriptionHandler> handlers;
+      std::mutex lock;
+      
+   };
+}
+
+#endif

.history/SubscriptionManager_20221013230931.cpp

@@ -0,0 +1,100 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core {
+
+   SubscriptionManager::SubscriptionManager() {}
+	
+   int SubscriptionManager::add(Subscription &subscription, SubscriptionHandler *handler) {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      handlers.
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler) {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+   
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) {
+      int countSubscribed = 0;
+      int countPublished = 0;
+      
+      lock.lock();		
+      std::string temp = "";
+      for(auto [key, subscription] : subscriptions) {
+         if(temp != "") {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if(subscription->owner == &session) {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         } 
+      }
+      if(temp != "") {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+		lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) {
+      if(request[0].equals("publish")) {
+         Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+	      return 1;
+      } else if(request[0].equals("catalog")) {
+      	session.out << ":catalog:";
+         for(auto const& [key, subscription] : subscriptions) {
+	  	      session.out << subscription->id << ";";
+         }
+ 	      session.out << std::endl;
+      	return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+	   if(request[1].equals(subscription->id)) {
+         if(request[0].equals("unpublish")) {
+	         subscriptions.erase(request[1].str());
+         } else if(request[0].equals("subscribe")) {
+   	      subscription->subscribe(session);
+            return 1;
+         } else if(request[0].equals("unsubscribe")) {
+	         subscription->unsubscribe(session);
+            return 1;
+         } else if(request[0].equals("event")) {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if(subscription->mode == "*ANYONE") {
+	            subscription->event(out);
+               return 1;
+            } else if(subscription->mode == "*SUBSCRIBERS") {
+               if(subscription->ifSubscriber(session)) {
+	               subscription->event(out);
+                  return 1;
+               }
+            } else if(subscription->mode == "*AUTHOR") {
+               if(subscription->owner == &session) {
+	               subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+
+}

.history/SubscriptionManager_20221013231054.cpp

@@ -0,0 +1,127 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription, SubscriptionHandler *handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      handlers.lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+
+}

.history/SubscriptionManager_20221013231834.h

@@ -0,0 +1,34 @@
+#ifndef __SubscriptionManager_h__
+#define __SubscriptionManager_h__
+
+#include "Command.h"
+#include "Subscription.h"
+#include "TCPSession.h"
+#include "ZString.h"
+#include <string>
+#include <vector>
+
+namespace core
+{
+
+  class SubscriptionManager : public Command
+  {
+
+  public:
+    SubscriptionManager();
+
+    int add(Subscription &subscription);
+    int addHandler(std::string name, SubscriptionHandler &handler);
+
+    int removeSessionSubscriptions(TCPSession &session);
+
+    int processCommand(coreutils::ZString &request, TCPSession &session) override;
+
+  private:
+    std::map<std::string, Subscription *> subscriptions;
+    std::map<std::string, SubscriptionHandler> handlers;
+    std::mutex lock;
+  };
+}
+
+#endif

.history/SubscriptionManager_20221013232252.h

@@ -0,0 +1,34 @@
+#ifndef __SubscriptionManager_h__
+#define __SubscriptionManager_h__
+
+#include "Command.h"
+#include "Subscription.h"
+#include "TCPSession.h"
+#include "ZString.h"
+#include <string>
+#include <vector>
+
+namespace core
+{
+
+  class SubscriptionManager : public Command
+  {
+
+  public:
+    SubscriptionManager();
+
+    int add(Subscription &subscription);
+    int addHandler(std::string name, SubscriptionHandler &handler);
+
+    int removeSessionSubscriptions(TCPSession &session);
+
+    int processCommand(coreutils::ZString &request, TCPSession &session) override;
+
+  private:
+    std::map<std::string, Subscription *> subscriptions;
+    std::map<std::string, SubscriptionHandler *> handlers;
+    std::mutex lock;
+  };
+}
+
+#endif

.history/SubscriptionManager_20221013232501.h

@@ -0,0 +1,34 @@
+#ifndef __SubscriptionManager_h__
+#define __SubscriptionManager_h__
+
+#include "Command.h"
+#include "Subscription.h"
+#include "TCPSession.h"
+#include "ZString.h"
+#include <string>
+#include <vector>
+
+namespace core
+{
+
+  class SubscriptionManager : public Command
+  {
+
+  public:
+    SubscriptionManager();
+
+    int add(Subscription &subscription, SubscriptionHandler &handlers);
+    int addHandler(std::string name, SubscriptionHandler &handler);
+
+    int removeSessionSubscriptions(TCPSession &session);
+
+    int processCommand(coreutils::ZString &request, TCPSession &session) override;
+
+  private:
+    std::map<std::string, Subscription *> subscriptions;
+    std::map<std::string, SubscriptionHandler *> handlers;
+    std::mutex lock;
+  };
+}
+
+#endif

.history/SubscriptionManager_20221013232513.h

@@ -0,0 +1,34 @@
+#ifndef __SubscriptionManager_h__
+#define __SubscriptionManager_h__
+
+#include "Command.h"
+#include "Subscription.h"
+#include "TCPSession.h"
+#include "ZString.h"
+#include <string>
+#include <vector>
+
+namespace core
+{
+
+  class SubscriptionManager : public Command
+  {
+
+  public:
+    SubscriptionManager();
+
+    int add(Subscription &subscription, SubscriptionHandler *handlers);
+    int addHandler(std::string name, SubscriptionHandler &handler);
+
+    int removeSessionSubscriptions(TCPSession &session);
+
+    int processCommand(coreutils::ZString &request, TCPSession &session) override;
+
+  private:
+    std::map<std::string, Subscription *> subscriptions;
+    std::map<std::string, SubscriptionHandler *> handlers;
+    std::mutex lock;
+  };
+}
+
+#endif

.history/SubscriptionManager_20221013232519.h

@@ -0,0 +1,34 @@
+#ifndef __SubscriptionManager_h__
+#define __SubscriptionManager_h__
+
+#include "Command.h"
+#include "Subscription.h"
+#include "TCPSession.h"
+#include "ZString.h"
+#include <string>
+#include <vector>
+
+namespace core
+{
+
+  class SubscriptionManager : public Command
+  {
+
+  public:
+    SubscriptionManager();
+
+    int add(Subscription &subscription, SubscriptionHandler *handler);
+    int addHandler(std::string name, SubscriptionHandler &handler);
+
+    int removeSessionSubscriptions(TCPSession &session);
+
+    int processCommand(coreutils::ZString &request, TCPSession &session) override;
+
+  private:
+    std::map<std::string, Subscription *> subscriptions;
+    std::map<std::string, SubscriptionHandler *> handlers;
+    std::mutex lock;
+  };
+}
+
+#endif

.history/SubscriptionManager_20221013232529.cpp

@@ -0,0 +1,127 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription, SubscriptionHandler *handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      handler.lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+
+}

.history/SubscriptionManager_20221013232559.cpp

@@ -0,0 +1,128 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription, SubscriptionHandler *handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+
+      handler.lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+
+}

.history/SubscriptionManager_20221013232603.cpp

@@ -0,0 +1,128 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription, SubscriptionHandler *handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+
+      handlers.lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+
+}

.history/SubscriptionManager_20221013232637.cpp

@@ -0,0 +1,128 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription, SubscriptionHandler *handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+
+}

.history/SubscriptionManager_20221013232709.cpp

@@ -0,0 +1,128 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription, SubscriptionHandler *handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+
+}

.history/SubscriptionManager_20221013232718.cpp

@@ -0,0 +1,127 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription, SubscriptionHandler *handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+
+}

.history/SubscriptionManager_20221014001552.cpp

@@ -0,0 +1,141 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handler)
+         subscription.setHandler = handler[handler];
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014001640.cpp

@@ -0,0 +1,141 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handler)
+         subscription->setHandler = handler[handler];
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014001750.cpp

@@ -0,0 +1,141 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handlers)
+         subscription->setHandler = handler[handler];
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014001801.cpp

@@ -0,0 +1,141 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handler)
+         subscription->setHandler = handler[handler];
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014001829.cpp

@@ -0,0 +1,141 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handler)
+         subscription->setHandler = handlers[handler];
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014001848.cpp

@@ -0,0 +1,141 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handler)
+         subscription->setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014002019.cpp

@@ -0,0 +1,141 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handler)
+         subscription->setHandler(*handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014002052.cpp

@@ -0,0 +1,141 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handler)
+         subscription->setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014002112.cpp

@@ -0,0 +1,141 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handler != NULL)
+         subscription->setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014002118.cpp

@@ -0,0 +1,141 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handler == NULL)
+         subscription->setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014002130.cpp

@@ -0,0 +1,141 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handler = !NULL)
+         subscription->setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014002136.cpp

@@ -0,0 +1,141 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handler)
+         subscription->setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014002203.cpp

@@ -0,0 +1,142 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handler)
+         subscription.setHandler(handlers[handler]);
+      subscription->setHandler();
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(SubscriptionHandler &handler, std::string name)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014002300.cpp

@@ -0,0 +1,142 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handler)
+         subscription.setHandler(handlers[handler]);
+
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014002351.cpp

@@ -0,0 +1,142 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handlers != NULL)
+         subscription.setHandler(handlers[handler]);
+
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014002355.cpp

@@ -0,0 +1,142 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handlers = NULL)
+         subscription.setHandler(handlers[handler]);
+
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014002404.cpp

@@ -0,0 +1,142 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handlers == NULL)
+         subscription.setHandler(handlers[handler]);
+
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014002416.cpp

@@ -0,0 +1,142 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handlers)
+         subscription.setHandler(handlers[handler]);
+
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014002543.cpp

@@ -0,0 +1,142 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (*handlers)
+         subscription.setHandler(handlers[handler]);
+
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014002547.cpp

@@ -0,0 +1,142 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handlers)
+         subscription.setHandler(handlers[handler]);
+
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014002751.cpp

@@ -0,0 +1,142 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handlers.empty())
+         subscription.setHandler(handlers[handler]);
+
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014002909.cpp

@@ -0,0 +1,142 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handlers.find(handler))
+         subscription.setHandler(handlers[handler]);
+
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014002931.cpp

@@ -0,0 +1,142 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handlers.find(handler) == handlers.end())
+         subscription.setHandler(handlers[handler]);
+
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014002952.cpp

@@ -0,0 +1,141 @@
+#include "Log.h"
+#include "SubscriptionManager.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014003012.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handlers.find(handler) == handlers.end())
+      {
+      }
+      else
+      {
+         subscription.setHandler(handlers[handler]);
+         lock.unlock();
+      }
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014003016.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handlers.find(handler) == handlers.end())
+      {
+      }
+      else
+      {
+         subscription.setHandler(handlers[handler]);
+         lock.unlock();
+      }
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014003032.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handlers.find(handler) == handlers.end())
+      {
+      }
+      else
+      {
+         subscription.setHandler(handlers[handler]);
+         lock.unlock();
+      }
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014003110.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handlers.find(handler) == handlers.end())
+      {
+      }
+      else
+      {
+         subscription.setHandler(handlers[handler]);
+         lock.unlock();
+      }
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscriptions = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014003112.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handlers.find(handler) == handlers.end())
+      {
+      }
+      else
+      {
+         subscription.setHandler(handlers[handler]);
+         lock.unlock();
+      }
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscriptions = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscriptions));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014003118.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handlers.find(handler) == handlers.end())
+      {
+      }
+      else
+      {
+         subscription.setHandler(handlers[handler]);
+         lock.unlock();
+      }
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014003740.cpp

@@ -0,0 +1,142 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handler)
+         subscription.setHandler(handlers[handler]);
+
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014003842.cpp

@@ -0,0 +1,142 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      if (handler)
+         subscription.setHandler = handlers[handler];
+
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         if (request.getList().size() > 2)
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            Subscription *newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+      }
+
+      return 1;
+   }
+   else if (request[0].equals("catalog"))
+   {
+      session.out << ":catalog:";
+      for (auto const &[key, subscription] : subscriptions)
+      {
+         session.out << subscription->id << ";";
+      }
+      session.out << std::endl;
+      return 1;
+   }
+
+   auto subscription = subscriptions[request[1].str()];
+
+   if (request[1].equals(subscription->id))
+   {
+      if (request[0].equals("unpublish"))
+      {
+         subscriptions.erase(request[1].str());
+      }
+      else if (request[0].equals("subscribe"))
+      {
+         subscription->subscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("unsubscribe"))
+      {
+         subscription->unsubscribe(session);
+         return 1;
+      }
+      else if (request[0].equals("event"))
+      {
+         std::stringstream out;
+         subscription->process(request, out, session);
+         if (subscription->mode == "*ANYONE")
+         {
+            subscription->event(out);
+            return 1;
+         }
+         else if (subscription->mode == "*SUBSCRIBERS")
+         {
+            if (subscription->ifSubscriber(session))
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+         else if (subscription->mode == "*AUTHOR")
+         {
+            if (subscription->owner == &session)
+            {
+               subscription->event(out);
+               return 1;
+            }
+         }
+      }
+      return 0;
+   }
+   return 0;
+}
+}

.history/SubscriptionManager_20221014224510.cpp

@@ -0,0 +1,142 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         Subscription *newSubscription;
+         if (request.getList().size() > 2)
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015132404.cpp

@@ -0,0 +1,142 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         Subscription *newSubscription;
+         //   if (request.getList().size() > 2)
+         //    newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         //   else
+         newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015135839.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         Subscription *newSubscription;
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015140050.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         Subscription *newSubscription;
+         if (request.getList().size() > 3)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015140147.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+         Subscription *newSubscription;
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015140418.h

@@ -0,0 +1,37 @@
+#ifndef __SubscriptionManager_h__
+#define __SubscriptionManager_h__
+
+#include "Command.h"
+#include "Subscription.h"
+#include "SubscriptionHandler.h"
+#include "TCPSession.h"
+#include "ZString.h"
+#include <string>
+#include <vector>
+
+namespace core
+{
+
+  class SubscriptionManager : public Command
+  {
+
+  public:
+    SubscriptionManager();
+
+    int add(Subscription &subscription);
+    int add(Subscription &subscription, std::string handler);
+    int addHandler(std::string name, SubscriptionHandler &handler);
+
+    int removeSessionSubscriptions(TCPSession &session);
+
+    int processCommand(coreutils::ZString &request, TCPSession &session) override;
+
+  private:
+    std::map<std::string, Subscription *> subscriptions;
+    std::map<std::string, SubscriptionHandler *> handlers;
+    Subscription *newSubscription;
+    std::mutex lock;
+  };
+}
+
+#endif

.history/SubscriptionManager_20221015140432.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015140547.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.str().getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015140637.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getLength.size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015140703.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015140849.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015140915.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            // newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015141339.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            // newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015141418.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+            subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         }
+         else
+         {
+            // newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015141638.cpp

@@ -0,0 +1,147 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+            subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+            subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         }
+
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015180125.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015181249.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 3)
+         {
+
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015181639.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() >= 2)
+         {
+
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015181912.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015182122.cpp

@@ -0,0 +1,143 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015183109.cpp

@@ -0,0 +1,143 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() >= 2)
+
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         else
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015183204.cpp

@@ -0,0 +1,144 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() >= 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+         else
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015183209.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() >= 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015183518.cpp

@@ -0,0 +1,146 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015191146.cpp

@@ -0,0 +1,147 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015193901.cpp

@@ -0,0 +1,147 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015200446.cpp

@@ -0,0 +1,147 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      subscription.setHandler(handlers["handler"]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015200502.cpp

@@ -0,0 +1,147 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015201436.h

@@ -0,0 +1,38 @@
+#ifndef __SubscriptionManager_h__
+#define __SubscriptionManager_h__
+
+#include "Command.h"
+#include "Subscription.h"
+#include "SubscriptionHandler.h"
+#include "TCPSession.h"
+#include "ZString.h"
+#include <string>
+#include <vector>
+
+namespace core
+{
+
+  class SubscriptionManager : public Command
+  {
+
+  public:
+    SubscriptionManager();
+
+    int add(Subscription &subscription);
+    int add(Subscription &subscription, std::string handler);
+    int addHandler(std::string name, SubscriptionHandler &handler);
+
+    int removeSessionSubscriptions(TCPSession &session);
+
+    int processCommand(coreutils::ZString &request, TCPSession &session) override;
+
+  private:
+    Subscription subscription;
+    std::map<std::string, Subscription *> subscriptions;
+    std::map<std::string, SubscriptionHandler *> handlers;
+    Subscription *newSubscription;
+    std::mutex lock;
+  };
+}
+
+#endif

.history/SubscriptionManager_20221015201440.h

@@ -0,0 +1,38 @@
+#ifndef __SubscriptionManager_h__
+#define __SubscriptionManager_h__
+
+#include "Command.h"
+#include "Subscription.h"
+#include "SubscriptionHandler.h"
+#include "TCPSession.h"
+#include "ZString.h"
+#include <string>
+#include <vector>
+
+namespace core
+{
+
+  class SubscriptionManager : public Command
+  {
+
+  public:
+    SubscriptionManager();
+
+    int add(Subscription &subscription);
+    int add(Subscription &subscription, std::string handler);
+    int addHandler(std::string name, SubscriptionHandler &handler);
+
+    int removeSessionSubscriptions(TCPSession &session);
+
+    int processCommand(coreutils::ZString &request, TCPSession &session) override;
+
+  private:
+    Subscription *subscription;
+    std::map<std::string, Subscription *> subscriptions;
+    std::map<std::string, SubscriptionHandler *> handlers;
+    Subscription *newSubscription;
+    std::mutex lock;
+  };
+}
+
+#endif

.history/SubscriptionManager_20221015201500.cpp

@@ -0,0 +1,147 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015201542.cpp

@@ -0,0 +1,147 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      subscription->setHandler(handlers[name]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221015201557.cpp

@@ -0,0 +1,147 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      subscription->setHandler(handlers[name]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221016174159.cpp

@@ -0,0 +1,148 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      coreutils::Log(coreutils::LOG_DEBUG_1) << "Adding handler to SubscriptionManager for " << name;
+      subscription->setHandler(handler);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221016174206.cpp

@@ -0,0 +1,148 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      coreutils::Log(coreutils::LOG_DEBUG_1) << "Adding handler to SubscriptionManager for " << name;
+      subscription->setHandler(&handler);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221016175448.cpp

@@ -0,0 +1,148 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler &handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, &handler));
+      coreutils::Log(coreutils::LOG_DEBUG_1) << "Adding handler to SubscriptionManager for " << name;
+      subscription->setHandler(handlers[name]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221016180238.cpp

@@ -0,0 +1,148 @@
+#include "SubscriptionManager.h"
+#include "Log.h"
+#include "Subscription.h"
+#include <algorithm>
+
+namespace core
+{
+
+   SubscriptionManager::SubscriptionManager() {}
+
+   int SubscriptionManager::add(Subscription &subscription)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::add(Subscription &subscription, std::string handler)
+   {
+      lock.lock();
+      subscriptions.insert(std::make_pair(subscription.id, &subscription));
+      subscription.setHandler(handlers[handler]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::addHandler(std::string name, SubscriptionHandler *handler)
+   {
+      lock.lock();
+      handlers.insert(std::make_pair(name, handler));
+      coreutils::Log(coreutils::LOG_DEBUG_1) << "Adding handler to SubscriptionManager for " << name;
+      subscription->setHandler(handlers[name]);
+      lock.unlock();
+      return 1;
+   }
+
+   int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
+   {
+      int countSubscribed = 0;
+      int countPublished = 0;
+
+      lock.lock();
+      std::string temp = "";
+      for (auto [key, subscription] : subscriptions)
+      {
+         if (temp != "")
+         {
+            subscriptions.erase(temp);
+            temp = "";
+         }
+         countSubscribed += subscription->unsubscribe(session);
+         if (subscription->owner == &session)
+         {
+            temp = key;
+            delete subscription;
+            ++countPublished;
+         }
+      }
+      if (temp != "")
+      {
+         subscriptions.erase(temp);
+         temp = "";
+      }
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Removed session from " << countSubscribed << " subscription(s).";
+      coreutils::Log(coreutils::LOG_DEBUG_2) << "Cancelled " << countPublished << " channel(s) for session.";
+      lock.unlock();
+      return countSubscribed;
+   }
+
+   int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session)
+   {
+      if (request[0].equals("publish"))
+      {
+
+         if (request.getList().size() > 2)
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str(), request[3].str());
+         }
+         else
+         {
+            newSubscription = new Subscription(request[1].str(), session, request[2].str());
+         }
+
+         subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
+         return 1;
+      }
+
+      else if (request[0].equals("catalog"))
+      {
+         session.out << ":catalog:";
+         for (auto const &[key, subscription] : subscriptions)
+         {
+            session.out << subscription->id << ";";
+         }
+         session.out << std::endl;
+         return 1;
+      }
+
+      auto subscription = subscriptions[request[1].str()];
+
+      if (request[1].equals(subscription->id))
+      {
+         if (request[0].equals("unpublish"))
+         {
+            subscriptions.erase(request[1].str());
+         }
+         else if (request[0].equals("subscribe"))
+         {
+            subscription->subscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("unsubscribe"))
+         {
+            subscription->unsubscribe(session);
+            return 1;
+         }
+         else if (request[0].equals("event"))
+         {
+            std::stringstream out;
+            subscription->process(request, out, session);
+            if (subscription->mode == "*ANYONE")
+            {
+               subscription->event(out);
+               return 1;
+            }
+            else if (subscription->mode == "*SUBSCRIBERS")
+            {
+               if (subscription->ifSubscriber(session))
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+            else if (subscription->mode == "*AUTHOR")
+            {
+               if (subscription->owner == &session)
+               {
+                  subscription->event(out);
+                  return 1;
+               }
+            }
+         }
+         return 0;
+      }
+      return 0;
+   }
+}

.history/SubscriptionManager_20221016180248.h

@@ -0,0 +1,38 @@
+#ifndef __SubscriptionManager_h__
+#define __SubscriptionManager_h__
+
+#include "Command.h"
+#include "Subscription.h"
+#include "SubscriptionHandler.h"
+#include "TCPSession.h"
+#include "ZString.h"
+#include <string>
+#include <vector>
+
+namespace core
+{
+
+  class SubscriptionManager : public Command
+  {
+
+  public:
+    SubscriptionManager();
+
+    int add(Subscription &subscription);
+    int add(Subscription &subscription, std::string handler);
+    int addHandler(std::string name, SubscriptionHandler *handler);
+
+    int removeSessionSubscriptions(TCPSession &session);
+
+    int processCommand(coreutils::ZString &request, TCPSession &session) override;
+
+  private:
+    Subscription *subscription;
+    std::map<std::string, Subscription *> subscriptions;
+    std::map<std::string, SubscriptionHandler *> handlers;
+    Subscription *newSubscription;
+    std::mutex lock;
+  };
+}
+
+#endif

.history/Subscription_20221013190812.h

@@ -0,0 +1,46 @@
+#ifndef __Subscription_h__
+#define __Subscription_h__
+
+#include "ZString.h"
+#include <vector>
+#include <string>
+
+namespace core
+{
+
+   class TCPSession;
+
+   class Subscription
+   {
+
+   public:
+      Subscription(std::string id, std::string mode = "*AUTHOR");
+      Subscription(std::string id, TCPSession &session, std::string mode = "*AUTHOR");
+      virtual ~Subscription();
+
+      int subscribe(TCPSession &session);
+      int unsubscribe(TCPSession &session);
+
+      virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session);
+
+      virtual int onSubscribe(TCPSession &session);
+
+      int event(std::stringstream &out);
+
+      bool ifSubscriber(TCPSession &session);
+
+      void setHandler(SubscriptionHandler *handler);      
+
+      //      int processCommand(coreutils::ZString &request, TCPSession &session) override;
+
+      std::string id;
+      std::string mode;
+      TCPSession *owner;
+
+      SubscriptionHandler *handler;
+      
+      std::vector<TCPSession *> subscribers;
+   };
+}
+
+#endif

.history/Subscription_20221013190943.cpp

@@ -0,0 +1,75 @@
+#include "Subscription.h"
+#include "TCPSession.h"
+#include "Log.h"
+#include <algorithm>
+
+namespace core
+{
+
+   Subscription::Subscription(std::string id, std::string mode)
+       : id(id), mode(mode), owner(NULL) {}
+
+   Subscription::Subscription(std::string id, TCPSession &session, std::string mode)
+       : id(id), mode(mode), owner(&session) {}
+
+   Subscription::~Subscription()
+   {
+      std::stringstream out;
+      out << "cancel:" << id << std::endl;
+      for (auto subscriber : subscribers)
+      {
+         subscriber->write(out.str());
+      }
+   }
+
+   int Subscription::subscribe(TCPSession &session)
+   {
+      onSubscribe(session);
+      subscribers.push_back(&session);
+      return 1;
+   }
+
+   int Subscription::unsubscribe(TCPSession &session)
+   {
+      for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber)
+      {
+         if (*subscriber == &session)
+         {
+            subscribers.erase(subscriber++);
+            return 1;
+         }
+      }
+      return 0;
+   }
+
+   int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session)
+   {
+      if(handler)
+	handler->process(request, out, session);
+      else
+	out << "event:" << request[1] << ":" << request[2] << std::endl;
+      return 1;
+   }
+
+   int Subscription::event(std::stringstream &out)
+   {
+      for (auto subscriber = subscribers.begin(); subscriber < subscribers.end(); ++subscriber)
+         (*subscriber)->write(out.str());
+      return 1;
+   }
+
+   bool Subscription::ifSubscriber(TCPSession &session)
+   {
+      return (std::find(subscribers.begin(), subscribers.end(), &session) != subscribers.end());
+   }
+
+   int Subscription::onSubscribe(TCPSession &session)
+   {
+      return 0;
+   }
+
+    void setHandler(SubscriptionHandler *handler) {
+       this->handler = handler;       
+    }
+   
+}

.history/Subscription_20221013204658.h

@@ -0,0 +1,47 @@
+#ifndef __Subscription_h__
+#define __Subscription_h__
+
+#include "SubscriptionHandler.h"
+#include "ZString.h"
+#include <string>
+#include <vector>
+
+namespace core
+{
+
+   class TCPSession;
+
+   class Subscription
+   {
+
+   public:
+      Subscription(std::string id, std::string mode = "*AUTHOR");
+      Subscription(std::string id, TCPSession &session, std::string mode = "*AUTHOR");
+      virtual ~Subscription();
+
+      int subscribe(TCPSession &session);
+      int unsubscribe(TCPSession &session);
+
+      virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session);
+
+      virtual int onSubscribe(TCPSession &session);
+
+      int event(std::stringstream &out);
+
+      bool ifSubscriber(TCPSession &session);
+
+      void setHandler(SubscriptionHandler *handler);
+
+      //      int processCommand(coreutils::ZString &request, TCPSession &session) override;
+
+      std::string id;
+      std::string mode;
+      TCPSession *owner;
+
+      SubscriptionHandler *handler;
+
+      std::vector<TCPSession *> subscribers;
+   };
+}
+
+#endif