diff --git a/.history/SubscriptionHandler_20221013185305.cpp b/.history/SubscriptionHandler_20221013185305.cpp new file mode 100644 index 0000000..ce40556 --- /dev/null +++ b/.history/SubscriptionHandler_20221013185305.cpp @@ -0,0 +1,68 @@ +#include "Subscription.h" +#include "TCPSession.h" +#include "Log.h" +#include + +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; + } + +} diff --git a/.history/SubscriptionHandler_20221013191001.h b/.history/SubscriptionHandler_20221013191001.h new file mode 100644 index 0000000..43d7bd0 --- /dev/null +++ b/.history/SubscriptionHandler_20221013191001.h @@ -0,0 +1,24 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "ZString.h" +#include +#include + +namespace core +{ + + class SubscriptionHandler + { + + public: + SubscriptionHandler(); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + + }; +} + +#endif diff --git a/.history/SubscriptionHandler_20221013204338.h b/.history/SubscriptionHandler_20221013204338.h new file mode 100644 index 0000000..6fc8994 --- /dev/null +++ b/.history/SubscriptionHandler_20221013204338.h @@ -0,0 +1,23 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "ZString.h" +#include +#include + +namespace core +{ + + class SubscriptionHandler + { + + public: + SubscriptionHandler(); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + }; +} + +#endif diff --git a/.history/SubscriptionHandler_20221013204409.cpp b/.history/SubscriptionHandler_20221013204409.cpp new file mode 100644 index 0000000..23c2e94 --- /dev/null +++ b/.history/SubscriptionHandler_20221013204409.cpp @@ -0,0 +1,68 @@ +#include "SubscriptionHandler.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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; + } + +} diff --git a/.history/SubscriptionHandler_20221013204504.h b/.history/SubscriptionHandler_20221013204504.h new file mode 100644 index 0000000..6fc8994 --- /dev/null +++ b/.history/SubscriptionHandler_20221013204504.h @@ -0,0 +1,23 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "ZString.h" +#include +#include + +namespace core +{ + + class SubscriptionHandler + { + + public: + SubscriptionHandler(); + + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + + virtual int onSubscribe(TCPSession &session); + }; +} + +#endif diff --git a/.history/SubscriptionHandler_20221013204612.cpp b/.history/SubscriptionHandler_20221013204612.cpp new file mode 100644 index 0000000..45cb3fb --- /dev/null +++ b/.history/SubscriptionHandler_20221013204612.cpp @@ -0,0 +1,68 @@ +#include "Log.h" +#include "Subscription.h" +#include "TCPSession.h" +#include + +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; + } + +} diff --git a/.history/SubscriptionHandler_20221014152050.h b/.history/SubscriptionHandler_20221014152050.h new file mode 100644 index 0000000..a625a99 --- /dev/null +++ b/.history/SubscriptionHandler_20221014152050.h @@ -0,0 +1,22 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "TCPSession.h" +#include "ZString.h" +#include +#include +#include + +namespace core +{ + + class SubscriptionHandler + { + + public: + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + virtual int onSubscribe(TCPSession &session){}; + }; +} + +#endif diff --git a/.history/SubscriptionHandler_20221014152131.h b/.history/SubscriptionHandler_20221014152131.h new file mode 100644 index 0000000..fef3b55 --- /dev/null +++ b/.history/SubscriptionHandler_20221014152131.h @@ -0,0 +1,22 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "TCPSession.h" +#include "ZString.h" +#include +#include +#include + +namespace core +{ + + class SubscriptionHandler + { + + public: + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + virtual int onSubscribe(TCPSession &session) {} + }; +} + +#endif diff --git a/.history/SubscriptionHandler_20221014152241.h b/.history/SubscriptionHandler_20221014152241.h new file mode 100644 index 0000000..1c8484b --- /dev/null +++ b/.history/SubscriptionHandler_20221014152241.h @@ -0,0 +1,22 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "TCPSession.h" +#include "ZString.h" +#include +#include +#include + +namespace core +{ + + class SubscriptionHandler : public Base + { + + public: + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + virtual int onSubscribe(TCPSession &session) {} + }; +} + +#endif diff --git a/.history/SubscriptionHandler_20221014152252.h b/.history/SubscriptionHandler_20221014152252.h new file mode 100644 index 0000000..fef3b55 --- /dev/null +++ b/.history/SubscriptionHandler_20221014152252.h @@ -0,0 +1,22 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "TCPSession.h" +#include "ZString.h" +#include +#include +#include + +namespace core +{ + + class SubscriptionHandler + { + + public: + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + virtual int onSubscribe(TCPSession &session) {} + }; +} + +#endif diff --git a/.history/SubscriptionHandler_20221014152513.h b/.history/SubscriptionHandler_20221014152513.h new file mode 100644 index 0000000..7ad43f5 --- /dev/null +++ b/.history/SubscriptionHandler_20221014152513.h @@ -0,0 +1,22 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "TCPSession.h" +#include "ZString.h" +#include +#include +#include + +namespace core +{ + + class SubscriptionHandler + { + + public: + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + virtual int onSubscribe(TCPSession &session) { return 1; } + }; +} + +#endif diff --git a/.history/SubscriptionHandler_20221014153238.h b/.history/SubscriptionHandler_20221014153238.h new file mode 100644 index 0000000..71929a1 --- /dev/null +++ b/.history/SubscriptionHandler_20221014153238.h @@ -0,0 +1,23 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "ZString.h" +#include +#include +#include + +namespace core +{ + + class TCPSession; + + class SubscriptionHandler + { + + public: + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session); + virtual int onSubscribe(TCPSession &session); + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221013225816.h b/.history/SubscriptionManager_20221013225816.h new file mode 100644 index 0000000..d748e1c --- /dev/null +++ b/.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 +#include + +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 subscriptions; + std::map handlers; + std::mutex lock; + + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221013230931.cpp b/.history/SubscriptionManager_20221013230931.cpp new file mode 100644 index 0000000..bff4406 --- /dev/null +++ b/.history/SubscriptionManager_20221013230931.cpp @@ -0,0 +1,100 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; + } + +} diff --git a/.history/SubscriptionManager_20221013231054.cpp b/.history/SubscriptionManager_20221013231054.cpp new file mode 100644 index 0000000..2c897ba --- /dev/null +++ b/.history/SubscriptionManager_20221013231054.cpp @@ -0,0 +1,127 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; + } + +} diff --git a/.history/SubscriptionManager_20221013231834.h b/.history/SubscriptionManager_20221013231834.h new file mode 100644 index 0000000..6113b52 --- /dev/null +++ b/.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 +#include + +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 subscriptions; + std::map handlers; + std::mutex lock; + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221013232252.h b/.history/SubscriptionManager_20221013232252.h new file mode 100644 index 0000000..69e27ad --- /dev/null +++ b/.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 +#include + +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 subscriptions; + std::map handlers; + std::mutex lock; + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221013232501.h b/.history/SubscriptionManager_20221013232501.h new file mode 100644 index 0000000..33bfae4 --- /dev/null +++ b/.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 +#include + +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 subscriptions; + std::map handlers; + std::mutex lock; + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221013232513.h b/.history/SubscriptionManager_20221013232513.h new file mode 100644 index 0000000..22b4d1d --- /dev/null +++ b/.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 +#include + +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 subscriptions; + std::map handlers; + std::mutex lock; + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221013232519.h b/.history/SubscriptionManager_20221013232519.h new file mode 100644 index 0000000..4e31671 --- /dev/null +++ b/.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 +#include + +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 subscriptions; + std::map handlers; + std::mutex lock; + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221013232529.cpp b/.history/SubscriptionManager_20221013232529.cpp new file mode 100644 index 0000000..d618840 --- /dev/null +++ b/.history/SubscriptionManager_20221013232529.cpp @@ -0,0 +1,127 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; + } + +} diff --git a/.history/SubscriptionManager_20221013232559.cpp b/.history/SubscriptionManager_20221013232559.cpp new file mode 100644 index 0000000..e4e91fb --- /dev/null +++ b/.history/SubscriptionManager_20221013232559.cpp @@ -0,0 +1,128 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; + } + +} diff --git a/.history/SubscriptionManager_20221013232603.cpp b/.history/SubscriptionManager_20221013232603.cpp new file mode 100644 index 0000000..9cb8023 --- /dev/null +++ b/.history/SubscriptionManager_20221013232603.cpp @@ -0,0 +1,128 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; + } + +} diff --git a/.history/SubscriptionManager_20221013232637.cpp b/.history/SubscriptionManager_20221013232637.cpp new file mode 100644 index 0000000..b77390f --- /dev/null +++ b/.history/SubscriptionManager_20221013232637.cpp @@ -0,0 +1,128 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; + } + +} diff --git a/.history/SubscriptionManager_20221013232709.cpp b/.history/SubscriptionManager_20221013232709.cpp new file mode 100644 index 0000000..75f920d --- /dev/null +++ b/.history/SubscriptionManager_20221013232709.cpp @@ -0,0 +1,128 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; + } + +} diff --git a/.history/SubscriptionManager_20221013232718.cpp b/.history/SubscriptionManager_20221013232718.cpp new file mode 100644 index 0000000..616f635 --- /dev/null +++ b/.history/SubscriptionManager_20221013232718.cpp @@ -0,0 +1,127 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; + } + +} diff --git a/.history/SubscriptionManager_20221014001552.cpp b/.history/SubscriptionManager_20221014001552.cpp new file mode 100644 index 0000000..8324d3c --- /dev/null +++ b/.history/SubscriptionManager_20221014001552.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014001640.cpp b/.history/SubscriptionManager_20221014001640.cpp new file mode 100644 index 0000000..784a103 --- /dev/null +++ b/.history/SubscriptionManager_20221014001640.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014001750.cpp b/.history/SubscriptionManager_20221014001750.cpp new file mode 100644 index 0000000..bae78e2 --- /dev/null +++ b/.history/SubscriptionManager_20221014001750.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014001801.cpp b/.history/SubscriptionManager_20221014001801.cpp new file mode 100644 index 0000000..784a103 --- /dev/null +++ b/.history/SubscriptionManager_20221014001801.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014001829.cpp b/.history/SubscriptionManager_20221014001829.cpp new file mode 100644 index 0000000..1278eb1 --- /dev/null +++ b/.history/SubscriptionManager_20221014001829.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014001848.cpp b/.history/SubscriptionManager_20221014001848.cpp new file mode 100644 index 0000000..7405bf1 --- /dev/null +++ b/.history/SubscriptionManager_20221014001848.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014002019.cpp b/.history/SubscriptionManager_20221014002019.cpp new file mode 100644 index 0000000..efc059b --- /dev/null +++ b/.history/SubscriptionManager_20221014002019.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014002052.cpp b/.history/SubscriptionManager_20221014002052.cpp new file mode 100644 index 0000000..7405bf1 --- /dev/null +++ b/.history/SubscriptionManager_20221014002052.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014002112.cpp b/.history/SubscriptionManager_20221014002112.cpp new file mode 100644 index 0000000..9324632 --- /dev/null +++ b/.history/SubscriptionManager_20221014002112.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014002118.cpp b/.history/SubscriptionManager_20221014002118.cpp new file mode 100644 index 0000000..23e3e53 --- /dev/null +++ b/.history/SubscriptionManager_20221014002118.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014002130.cpp b/.history/SubscriptionManager_20221014002130.cpp new file mode 100644 index 0000000..4580af7 --- /dev/null +++ b/.history/SubscriptionManager_20221014002130.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014002136.cpp b/.history/SubscriptionManager_20221014002136.cpp new file mode 100644 index 0000000..7405bf1 --- /dev/null +++ b/.history/SubscriptionManager_20221014002136.cpp @@ -0,0 +1,141 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014002203.cpp b/.history/SubscriptionManager_20221014002203.cpp new file mode 100644 index 0000000..a26a962 --- /dev/null +++ b/.history/SubscriptionManager_20221014002203.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014002300.cpp b/.history/SubscriptionManager_20221014002300.cpp new file mode 100644 index 0000000..ccfb690 --- /dev/null +++ b/.history/SubscriptionManager_20221014002300.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014002351.cpp b/.history/SubscriptionManager_20221014002351.cpp new file mode 100644 index 0000000..00c9082 --- /dev/null +++ b/.history/SubscriptionManager_20221014002351.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014002355.cpp b/.history/SubscriptionManager_20221014002355.cpp new file mode 100644 index 0000000..17f04bb --- /dev/null +++ b/.history/SubscriptionManager_20221014002355.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014002404.cpp b/.history/SubscriptionManager_20221014002404.cpp new file mode 100644 index 0000000..a07e58e --- /dev/null +++ b/.history/SubscriptionManager_20221014002404.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014002416.cpp b/.history/SubscriptionManager_20221014002416.cpp new file mode 100644 index 0000000..33ca4eb --- /dev/null +++ b/.history/SubscriptionManager_20221014002416.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014002543.cpp b/.history/SubscriptionManager_20221014002543.cpp new file mode 100644 index 0000000..5e29a2f --- /dev/null +++ b/.history/SubscriptionManager_20221014002543.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014002547.cpp b/.history/SubscriptionManager_20221014002547.cpp new file mode 100644 index 0000000..33ca4eb --- /dev/null +++ b/.history/SubscriptionManager_20221014002547.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014002751.cpp b/.history/SubscriptionManager_20221014002751.cpp new file mode 100644 index 0000000..66ccaf0 --- /dev/null +++ b/.history/SubscriptionManager_20221014002751.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014002909.cpp b/.history/SubscriptionManager_20221014002909.cpp new file mode 100644 index 0000000..1422f5b --- /dev/null +++ b/.history/SubscriptionManager_20221014002909.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014002931.cpp b/.history/SubscriptionManager_20221014002931.cpp new file mode 100644 index 0000000..c7ac40c --- /dev/null +++ b/.history/SubscriptionManager_20221014002931.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014002952.cpp b/.history/SubscriptionManager_20221014002952.cpp new file mode 100644 index 0000000..69b185b --- /dev/null +++ b/.history/SubscriptionManager_20221014002952.cpp @@ -0,0 +1,141 @@ +#include "Log.h" +#include "SubscriptionManager.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014003012.cpp b/.history/SubscriptionManager_20221014003012.cpp new file mode 100644 index 0000000..558ff62 --- /dev/null +++ b/.history/SubscriptionManager_20221014003012.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014003016.cpp b/.history/SubscriptionManager_20221014003016.cpp new file mode 100644 index 0000000..558ff62 --- /dev/null +++ b/.history/SubscriptionManager_20221014003016.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014003032.cpp b/.history/SubscriptionManager_20221014003032.cpp new file mode 100644 index 0000000..558ff62 --- /dev/null +++ b/.history/SubscriptionManager_20221014003032.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014003110.cpp b/.history/SubscriptionManager_20221014003110.cpp new file mode 100644 index 0000000..6f3cc96 --- /dev/null +++ b/.history/SubscriptionManager_20221014003110.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014003112.cpp b/.history/SubscriptionManager_20221014003112.cpp new file mode 100644 index 0000000..c6463cd --- /dev/null +++ b/.history/SubscriptionManager_20221014003112.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014003118.cpp b/.history/SubscriptionManager_20221014003118.cpp new file mode 100644 index 0000000..558ff62 --- /dev/null +++ b/.history/SubscriptionManager_20221014003118.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014003740.cpp b/.history/SubscriptionManager_20221014003740.cpp new file mode 100644 index 0000000..ccfb690 --- /dev/null +++ b/.history/SubscriptionManager_20221014003740.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014003842.cpp b/.history/SubscriptionManager_20221014003842.cpp new file mode 100644 index 0000000..c04fdce --- /dev/null +++ b/.history/SubscriptionManager_20221014003842.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include + +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; +} +} diff --git a/.history/SubscriptionManager_20221014224510.cpp b/.history/SubscriptionManager_20221014224510.cpp new file mode 100644 index 0000000..fd31da3 --- /dev/null +++ b/.history/SubscriptionManager_20221014224510.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015132404.cpp b/.history/SubscriptionManager_20221015132404.cpp new file mode 100644 index 0000000..6d5fa0b --- /dev/null +++ b/.history/SubscriptionManager_20221015132404.cpp @@ -0,0 +1,142 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015135839.cpp b/.history/SubscriptionManager_20221015135839.cpp new file mode 100644 index 0000000..3beda7c --- /dev/null +++ b/.history/SubscriptionManager_20221015135839.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015140050.cpp b/.history/SubscriptionManager_20221015140050.cpp new file mode 100644 index 0000000..71a21da --- /dev/null +++ b/.history/SubscriptionManager_20221015140050.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015140147.cpp b/.history/SubscriptionManager_20221015140147.cpp new file mode 100644 index 0000000..4baacdb --- /dev/null +++ b/.history/SubscriptionManager_20221015140147.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015140418.h b/.history/SubscriptionManager_20221015140418.h new file mode 100644 index 0000000..e370a76 --- /dev/null +++ b/.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 +#include + +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 subscriptions; + std::map handlers; + Subscription *newSubscription; + std::mutex lock; + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221015140432.cpp b/.history/SubscriptionManager_20221015140432.cpp new file mode 100644 index 0000000..a7b9c82 --- /dev/null +++ b/.history/SubscriptionManager_20221015140432.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015140547.cpp b/.history/SubscriptionManager_20221015140547.cpp new file mode 100644 index 0000000..f976bcf --- /dev/null +++ b/.history/SubscriptionManager_20221015140547.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015140637.cpp b/.history/SubscriptionManager_20221015140637.cpp new file mode 100644 index 0000000..92e4dc5 --- /dev/null +++ b/.history/SubscriptionManager_20221015140637.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015140703.cpp b/.history/SubscriptionManager_20221015140703.cpp new file mode 100644 index 0000000..a7b9c82 --- /dev/null +++ b/.history/SubscriptionManager_20221015140703.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015140849.cpp b/.history/SubscriptionManager_20221015140849.cpp new file mode 100644 index 0000000..a7b9c82 --- /dev/null +++ b/.history/SubscriptionManager_20221015140849.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015140915.cpp b/.history/SubscriptionManager_20221015140915.cpp new file mode 100644 index 0000000..fdfdec3 --- /dev/null +++ b/.history/SubscriptionManager_20221015140915.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015141339.cpp b/.history/SubscriptionManager_20221015141339.cpp new file mode 100644 index 0000000..b120314 --- /dev/null +++ b/.history/SubscriptionManager_20221015141339.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015141418.cpp b/.history/SubscriptionManager_20221015141418.cpp new file mode 100644 index 0000000..7b8d183 --- /dev/null +++ b/.history/SubscriptionManager_20221015141418.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015141638.cpp b/.history/SubscriptionManager_20221015141638.cpp new file mode 100644 index 0000000..6424f60 --- /dev/null +++ b/.history/SubscriptionManager_20221015141638.cpp @@ -0,0 +1,147 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015180125.cpp b/.history/SubscriptionManager_20221015180125.cpp new file mode 100644 index 0000000..df0809a --- /dev/null +++ b/.history/SubscriptionManager_20221015180125.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015181249.cpp b/.history/SubscriptionManager_20221015181249.cpp new file mode 100644 index 0000000..464076a --- /dev/null +++ b/.history/SubscriptionManager_20221015181249.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015181639.cpp b/.history/SubscriptionManager_20221015181639.cpp new file mode 100644 index 0000000..be48bd0 --- /dev/null +++ b/.history/SubscriptionManager_20221015181639.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015181912.cpp b/.history/SubscriptionManager_20221015181912.cpp new file mode 100644 index 0000000..df0809a --- /dev/null +++ b/.history/SubscriptionManager_20221015181912.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015182122.cpp b/.history/SubscriptionManager_20221015182122.cpp new file mode 100644 index 0000000..3ed7565 --- /dev/null +++ b/.history/SubscriptionManager_20221015182122.cpp @@ -0,0 +1,143 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015183109.cpp b/.history/SubscriptionManager_20221015183109.cpp new file mode 100644 index 0000000..4a7a545 --- /dev/null +++ b/.history/SubscriptionManager_20221015183109.cpp @@ -0,0 +1,143 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015183204.cpp b/.history/SubscriptionManager_20221015183204.cpp new file mode 100644 index 0000000..0981e51 --- /dev/null +++ b/.history/SubscriptionManager_20221015183204.cpp @@ -0,0 +1,144 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015183209.cpp b/.history/SubscriptionManager_20221015183209.cpp new file mode 100644 index 0000000..8d76f43 --- /dev/null +++ b/.history/SubscriptionManager_20221015183209.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015183518.cpp b/.history/SubscriptionManager_20221015183518.cpp new file mode 100644 index 0000000..a7b9c82 --- /dev/null +++ b/.history/SubscriptionManager_20221015183518.cpp @@ -0,0 +1,146 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015191146.cpp b/.history/SubscriptionManager_20221015191146.cpp new file mode 100644 index 0000000..1ab0538 --- /dev/null +++ b/.history/SubscriptionManager_20221015191146.cpp @@ -0,0 +1,147 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015193901.cpp b/.history/SubscriptionManager_20221015193901.cpp new file mode 100644 index 0000000..1db78ab --- /dev/null +++ b/.history/SubscriptionManager_20221015193901.cpp @@ -0,0 +1,147 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015200446.cpp b/.history/SubscriptionManager_20221015200446.cpp new file mode 100644 index 0000000..0804ac6 --- /dev/null +++ b/.history/SubscriptionManager_20221015200446.cpp @@ -0,0 +1,147 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015200502.cpp b/.history/SubscriptionManager_20221015200502.cpp new file mode 100644 index 0000000..1db78ab --- /dev/null +++ b/.history/SubscriptionManager_20221015200502.cpp @@ -0,0 +1,147 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015201436.h b/.history/SubscriptionManager_20221015201436.h new file mode 100644 index 0000000..7e928e4 --- /dev/null +++ b/.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 +#include + +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 subscriptions; + std::map handlers; + Subscription *newSubscription; + std::mutex lock; + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221015201440.h b/.history/SubscriptionManager_20221015201440.h new file mode 100644 index 0000000..566cac8 --- /dev/null +++ b/.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 +#include + +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 subscriptions; + std::map handlers; + Subscription *newSubscription; + std::mutex lock; + }; +} + +#endif diff --git a/.history/SubscriptionManager_20221015201500.cpp b/.history/SubscriptionManager_20221015201500.cpp new file mode 100644 index 0000000..1db78ab --- /dev/null +++ b/.history/SubscriptionManager_20221015201500.cpp @@ -0,0 +1,147 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015201542.cpp b/.history/SubscriptionManager_20221015201542.cpp new file mode 100644 index 0000000..cc7c533 --- /dev/null +++ b/.history/SubscriptionManager_20221015201542.cpp @@ -0,0 +1,147 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221015201557.cpp b/.history/SubscriptionManager_20221015201557.cpp new file mode 100644 index 0000000..cc7c533 --- /dev/null +++ b/.history/SubscriptionManager_20221015201557.cpp @@ -0,0 +1,147 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221016174159.cpp b/.history/SubscriptionManager_20221016174159.cpp new file mode 100644 index 0000000..f32b63a --- /dev/null +++ b/.history/SubscriptionManager_20221016174159.cpp @@ -0,0 +1,148 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221016174206.cpp b/.history/SubscriptionManager_20221016174206.cpp new file mode 100644 index 0000000..d34f2f4 --- /dev/null +++ b/.history/SubscriptionManager_20221016174206.cpp @@ -0,0 +1,148 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221016175448.cpp b/.history/SubscriptionManager_20221016175448.cpp new file mode 100644 index 0000000..42235f3 --- /dev/null +++ b/.history/SubscriptionManager_20221016175448.cpp @@ -0,0 +1,148 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221016180238.cpp b/.history/SubscriptionManager_20221016180238.cpp new file mode 100644 index 0000000..614e1f4 --- /dev/null +++ b/.history/SubscriptionManager_20221016180238.cpp @@ -0,0 +1,148 @@ +#include "SubscriptionManager.h" +#include "Log.h" +#include "Subscription.h" +#include + +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; + } +} diff --git a/.history/SubscriptionManager_20221016180248.h b/.history/SubscriptionManager_20221016180248.h new file mode 100644 index 0000000..d7613fd --- /dev/null +++ b/.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 +#include + +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 subscriptions; + std::map handlers; + Subscription *newSubscription; + std::mutex lock; + }; +} + +#endif diff --git a/.history/Subscription_20221013190812.h b/.history/Subscription_20221013190812.h new file mode 100644 index 0000000..e995db7 --- /dev/null +++ b/.history/Subscription_20221013190812.h @@ -0,0 +1,46 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "ZString.h" +#include +#include + +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 subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221013190943.cpp b/.history/Subscription_20221013190943.cpp new file mode 100644 index 0000000..6fa4cd0 --- /dev/null +++ b/.history/Subscription_20221013190943.cpp @@ -0,0 +1,75 @@ +#include "Subscription.h" +#include "TCPSession.h" +#include "Log.h" +#include + +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; + } + +} diff --git a/.history/Subscription_20221013204658.h b/.history/Subscription_20221013204658.h new file mode 100644 index 0000000..e2c4d84 --- /dev/null +++ b/.history/Subscription_20221013204658.h @@ -0,0 +1,47 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +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 subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221013204725.cpp b/.history/Subscription_20221013204725.cpp new file mode 100644 index 0000000..3f683db --- /dev/null +++ b/.history/Subscription_20221013204725.cpp @@ -0,0 +1,76 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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; + } + +} diff --git a/.history/Subscription_20221013204753.cpp b/.history/Subscription_20221013204753.cpp new file mode 100644 index 0000000..3f683db --- /dev/null +++ b/.history/Subscription_20221013204753.cpp @@ -0,0 +1,76 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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; + } + +} diff --git a/.history/Subscription_20221013205054.cpp b/.history/Subscription_20221013205054.cpp new file mode 100644 index 0000000..2fe2d13 --- /dev/null +++ b/.history/Subscription_20221013205054.cpp @@ -0,0 +1,76 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221014003150.h b/.history/Subscription_20221014003150.h new file mode 100644 index 0000000..e2c4d84 --- /dev/null +++ b/.history/Subscription_20221014003150.h @@ -0,0 +1,47 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +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 subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221014212452.h b/.history/Subscription_20221014212452.h new file mode 100644 index 0000000..6f8ef82 --- /dev/null +++ b/.history/Subscription_20221014212452.h @@ -0,0 +1,49 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "TCPSession.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + 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 subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221014212457.h b/.history/Subscription_20221014212457.h new file mode 100644 index 0000000..d55b0e7 --- /dev/null +++ b/.history/Subscription_20221014212457.h @@ -0,0 +1,47 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "TCPSession.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + 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 subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221014212653.h b/.history/Subscription_20221014212653.h new file mode 100644 index 0000000..c5ef04a --- /dev/null +++ b/.history/Subscription_20221014212653.h @@ -0,0 +1,48 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + 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 subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221014220951.cpp b/.history/Subscription_20221014220951.cpp new file mode 100644 index 0000000..6a1cb7b --- /dev/null +++ b/.history/Subscription_20221014220951.cpp @@ -0,0 +1,76 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handler) + : 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015131611.cpp b/.history/Subscription_20221015131611.cpp new file mode 100644 index 0000000..6a1cb7b --- /dev/null +++ b/.history/Subscription_20221015131611.cpp @@ -0,0 +1,76 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handler) + : 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015142023.cpp b/.history/Subscription_20221015142023.cpp new file mode 100644 index 0000000..640cd6b --- /dev/null +++ b/.history/Subscription_20221015142023.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handler) + : id(id), mode(mode), owner(&session) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015175629.cpp b/.history/Subscription_20221015175629.cpp new file mode 100644 index 0000000..640cd6b --- /dev/null +++ b/.history/Subscription_20221015175629.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handler) + : id(id), mode(mode), owner(&session) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015182553.h b/.history/Subscription_20221015182553.h new file mode 100644 index 0000000..7f0398f --- /dev/null +++ b/.history/Subscription_20221015182553.h @@ -0,0 +1,49 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + 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 subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221015182613.h b/.history/Subscription_20221015182613.h new file mode 100644 index 0000000..0d98e5e --- /dev/null +++ b/.history/Subscription_20221015182613.h @@ -0,0 +1,49 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + 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; + std::string handler; + + SubscriptionHandler *handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221015182633.cpp b/.history/Subscription_20221015182633.cpp new file mode 100644 index 0000000..3c1199a --- /dev/null +++ b/.history/Subscription_20221015182633.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handler) + : id(id), mode(mode), owner(&session), handler(handler) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015182644.cpp b/.history/Subscription_20221015182644.cpp new file mode 100644 index 0000000..fc07da5 --- /dev/null +++ b/.history/Subscription_20221015182644.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handler(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015182655.h b/.history/Subscription_20221015182655.h new file mode 100644 index 0000000..53fd588 --- /dev/null +++ b/.history/Subscription_20221015182655.h @@ -0,0 +1,49 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + 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; + std::string handlers; + + SubscriptionHandler *handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221015182706.cpp b/.history/Subscription_20221015182706.cpp new file mode 100644 index 0000000..c583ea8 --- /dev/null +++ b/.history/Subscription_20221015182706.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015182712.cpp b/.history/Subscription_20221015182712.cpp new file mode 100644 index 0000000..c583ea8 --- /dev/null +++ b/.history/Subscription_20221015182712.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015203632.h b/.history/Subscription_20221015203632.h new file mode 100644 index 0000000..b9340b2 --- /dev/null +++ b/.history/Subscription_20221015203632.h @@ -0,0 +1,49 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + 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; + std::string handlers; + + SubscriptionHandler &handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221015203643.cpp b/.history/Subscription_20221015203643.cpp new file mode 100644 index 0000000..ac861a6 --- /dev/null +++ b/.history/Subscription_20221015203643.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015203655.cpp b/.history/Subscription_20221015203655.cpp new file mode 100644 index 0000000..73d9ad2 --- /dev/null +++ b/.history/Subscription_20221015203655.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015203702.cpp b/.history/Subscription_20221015203702.cpp new file mode 100644 index 0000000..73d9ad2 --- /dev/null +++ b/.history/Subscription_20221015203702.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015203734.h b/.history/Subscription_20221015203734.h new file mode 100644 index 0000000..53fd588 --- /dev/null +++ b/.history/Subscription_20221015203734.h @@ -0,0 +1,49 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + 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; + std::string handlers; + + SubscriptionHandler *handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221015203735.cpp b/.history/Subscription_20221015203735.cpp new file mode 100644 index 0000000..c583ea8 --- /dev/null +++ b/.history/Subscription_20221015203735.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015203805.cpp b/.history/Subscription_20221015203805.cpp new file mode 100644 index 0000000..c583ea8 --- /dev/null +++ b/.history/Subscription_20221015203805.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221015204939.cpp b/.history/Subscription_20221015204939.cpp new file mode 100644 index 0000000..dde1003 --- /dev/null +++ b/.history/Subscription_20221015204939.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221016151339.cpp b/.history/Subscription_20221016151339.cpp new file mode 100644 index 0000000..c583ea8 --- /dev/null +++ b/.history/Subscription_20221016151339.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221016162014.cpp b/.history/Subscription_20221016162014.cpp new file mode 100644 index 0000000..c583ea8 --- /dev/null +++ b/.history/Subscription_20221016162014.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } + +} diff --git a/.history/Subscription_20221016172637.cpp b/.history/Subscription_20221016172637.cpp new file mode 100644 index 0000000..0040988 --- /dev/null +++ b/.history/Subscription_20221016172637.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + coreutils::Log(coreutils::LOG_DEBUG_1) << "Setting handler" << handler; + } +} diff --git a/.history/Subscription_20221016172643.cpp b/.history/Subscription_20221016172643.cpp new file mode 100644 index 0000000..0040988 --- /dev/null +++ b/.history/Subscription_20221016172643.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + coreutils::Log(coreutils::LOG_DEBUG_1) << "Setting handler" << handler; + } +} diff --git a/.history/Subscription_20221016173312.cpp b/.history/Subscription_20221016173312.cpp new file mode 100644 index 0000000..ee6d5ea --- /dev/null +++ b/.history/Subscription_20221016173312.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + coreutils::Log(coreutils::LOG_DEBUG_1) << "Setting handler"; + } +} diff --git a/.history/Subscription_20221016173458.cpp b/.history/Subscription_20221016173458.cpp new file mode 100644 index 0000000..b843257 --- /dev/null +++ b/.history/Subscription_20221016173458.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + // handler = handler; + coreutils::Log(coreutils::LOG_DEBUG_1) << "Setting handler"; + } +} diff --git a/.history/Subscription_20221016173903.cpp b/.history/Subscription_20221016173903.cpp new file mode 100644 index 0000000..ee6d5ea --- /dev/null +++ b/.history/Subscription_20221016173903.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + coreutils::Log(coreutils::LOG_DEBUG_1) << "Setting handler"; + } +} diff --git a/.history/Subscription_20221016174406.cpp b/.history/Subscription_20221016174406.cpp new file mode 100644 index 0000000..0040988 --- /dev/null +++ b/.history/Subscription_20221016174406.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + coreutils::Log(coreutils::LOG_DEBUG_1) << "Setting handler" << handler; + } +} diff --git a/.history/Subscription_20221016174556.cpp b/.history/Subscription_20221016174556.cpp new file mode 100644 index 0000000..d62d2b5 --- /dev/null +++ b/.history/Subscription_20221016174556.cpp @@ -0,0 +1,78 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } +} diff --git a/.history/Subscription_20221016174634.cpp b/.history/Subscription_20221016174634.cpp new file mode 100644 index 0000000..6b2e0b2 --- /dev/null +++ b/.history/Subscription_20221016174634.cpp @@ -0,0 +1,78 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } +} diff --git a/.history/Subscription_20221016174652.cpp b/.history/Subscription_20221016174652.cpp new file mode 100644 index 0000000..ce23872 --- /dev/null +++ b/.history/Subscription_20221016174652.cpp @@ -0,0 +1,78 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = &handler; + } +} diff --git a/.history/Subscription_20221016174712.cpp b/.history/Subscription_20221016174712.cpp new file mode 100644 index 0000000..6b2e0b2 --- /dev/null +++ b/.history/Subscription_20221016174712.cpp @@ -0,0 +1,78 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handler) + { + handler = handler; + } +} diff --git a/.history/Subscription_20221016174852.h b/.history/Subscription_20221016174852.h new file mode 100644 index 0000000..6010ad0 --- /dev/null +++ b/.history/Subscription_20221016174852.h @@ -0,0 +1,49 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + 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; + std::string handlers; + + SubscriptionHandler *handlers; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221016174910.h b/.history/Subscription_20221016174910.h new file mode 100644 index 0000000..53fd588 --- /dev/null +++ b/.history/Subscription_20221016174910.h @@ -0,0 +1,49 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + 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; + std::string handlers; + + SubscriptionHandler *handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221016174913.h b/.history/Subscription_20221016174913.h new file mode 100644 index 0000000..b9e448b --- /dev/null +++ b/.history/Subscription_20221016174913.h @@ -0,0 +1,49 @@ +#ifndef __Subscription_h__ +#define __Subscription_h__ + +#include "SubscriptionHandler.h" +#include "ZString.h" +#include +#include + +namespace core +{ + + class TCPSession; + + class Subscription + { + + public: + Subscription(std::string id, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, std::string handler); + 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 *handlers); + + // int processCommand(coreutils::ZString &request, TCPSession &session) override; + + std::string id; + std::string mode; + TCPSession *owner; + std::string handlers; + + SubscriptionHandler *handler; + + std::vector subscribers; + }; +} + +#endif diff --git a/.history/Subscription_20221016174921.cpp b/.history/Subscription_20221016174921.cpp new file mode 100644 index 0000000..e18853c --- /dev/null +++ b/.history/Subscription_20221016174921.cpp @@ -0,0 +1,78 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handlers) + { + handler = handler; + } +} diff --git a/.history/Subscription_20221016174923.cpp b/.history/Subscription_20221016174923.cpp new file mode 100644 index 0000000..21c5b39 --- /dev/null +++ b/.history/Subscription_20221016174923.cpp @@ -0,0 +1,78 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handlers) + { + handler = handlers; + } +} diff --git a/.history/Subscription_20221016175152.cpp b/.history/Subscription_20221016175152.cpp new file mode 100644 index 0000000..9f30eaf --- /dev/null +++ b/.history/Subscription_20221016175152.cpp @@ -0,0 +1,79 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handlers) + { + handler = handlers; + coreutils::Log(coreutils::LOG_DEBUG_1) << "Test Test"; + } +} diff --git a/.history/Subscription_20221016175838.cpp b/.history/Subscription_20221016175838.cpp new file mode 100644 index 0000000..33256cc --- /dev/null +++ b/.history/Subscription_20221016175838.cpp @@ -0,0 +1,80 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handlers) + { + handler = handlers; + + coreutils::Log(coreutils::LOG_DEBUG_1) << "Test Test"; + } +} diff --git a/.history/Subscription_20221016175855.cpp b/.history/Subscription_20221016175855.cpp new file mode 100644 index 0000000..6271e2e --- /dev/null +++ b/.history/Subscription_20221016175855.cpp @@ -0,0 +1,80 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handlers) + { + handler = handlers; + + return handler; + } +} diff --git a/.history/Subscription_20221016175911.cpp b/.history/Subscription_20221016175911.cpp new file mode 100644 index 0000000..33256cc --- /dev/null +++ b/.history/Subscription_20221016175911.cpp @@ -0,0 +1,80 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handlers) + { + handler = handlers; + + coreutils::Log(coreutils::LOG_DEBUG_1) << "Test Test"; + } +} diff --git a/.history/Subscription_20221016175912.cpp b/.history/Subscription_20221016175912.cpp new file mode 100644 index 0000000..33256cc --- /dev/null +++ b/.history/Subscription_20221016175912.cpp @@ -0,0 +1,80 @@ +#include "Subscription.h" +#include "Log.h" +#include "TCPSession.h" +#include + +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, std::string handlers) + : id(id), mode(mode), owner(&session), handlers(handlers) {} + + 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 Subscription::setHandler(SubscriptionHandler *handlers) + { + handler = handlers; + + coreutils::Log(coreutils::LOG_DEBUG_1) << "Test Test"; + } +} diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json index 7adc94f..6720a7b 100644 --- a/.vscode/c_cpp_properties.json +++ b/.vscode/c_cpp_properties.json @@ -7,7 +7,7 @@ "${workspaceFolder}/../CoreUtils" ], "defines": [], - "compilerPath": "/usr/bin/g++-9", + "compilerPath": "/usr/bin/clang-12", "cStandard": "c17", "cppStandard": "gnu++20", "intelliSenseMode": "windows-gcc-x64", diff --git a/Subscription.cpp b/Subscription.cpp index ce40556..f37a6d5 100644 --- a/Subscription.cpp +++ b/Subscription.cpp @@ -1,16 +1,19 @@ #include "Subscription.h" -#include "TCPSession.h" #include "Log.h" +#include "TCPSession.h" #include namespace core { Subscription::Subscription(std::string id, std::string mode) - : id(id), mode(mode), owner(NULL) {} - + : id(id), mode(mode), owner(NULL), handler(NULL) {} + Subscription::Subscription(std::string id, TCPSession &session, std::string mode) - : id(id), mode(mode), owner(&session) {} + : id(id), mode(mode), owner(&session), handler(NULL) {} + + Subscription::Subscription(std::string id, TCPSession &session, std::string mode, SubscriptionHandler *handler) + : id(id), mode(mode), owner(&session), handler(handler) {} Subscription::~Subscription() { @@ -24,7 +27,11 @@ namespace core int Subscription::subscribe(TCPSession &session) { - onSubscribe(session); + if(handler) + handler->onSubscribe(session); + else + onSubscribe(session); + subscribers.push_back(&session); return 1; } @@ -44,7 +51,11 @@ namespace core int Subscription::process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) { - out << "event:" << request[1] << ":" << request[2] << std::endl; + std::cout << "(" << handler << ")" << std::endl; + if (handler) + handler->process(request, out, session); + else + out << "event:" << request[1] << ":" << request[2] << std::endl; return 1; } @@ -65,4 +76,10 @@ namespace core return 0; } +// void Subscription::setHandler(SubscriptionHandler *handlers) +// { +// handler = handlers; + +// coreutils::Log(coreutils::LOG_DEBUG_1) << "Test Test"; +// } } diff --git a/Subscription.h b/Subscription.h index 371b6c4..b62e342 100644 --- a/Subscription.h +++ b/Subscription.h @@ -1,9 +1,10 @@ #ifndef __Subscription_h__ #define __Subscription_h__ +#include "SubscriptionHandler.h" #include "ZString.h" -#include #include +#include namespace core { @@ -15,7 +16,8 @@ namespace core public: Subscription(std::string id, std::string mode = "*AUTHOR"); - Subscription(std::string id, TCPSession &session, std::string mode = "*AUTHOR"); + Subscription(std::string id, TCPSession &session, std::string mode); + Subscription(std::string id, TCPSession &session, std::string mode, SubscriptionHandler *handler); virtual ~Subscription(); int subscribe(TCPSession &session); @@ -29,12 +31,16 @@ namespace core bool ifSubscriber(TCPSession &session); +// void setHandler(SubscriptionHandler *handlers); + // int processCommand(coreutils::ZString &request, TCPSession &session) override; std::string id; std::string mode; TCPSession *owner; + SubscriptionHandler *handler; + std::vector subscribers; }; } diff --git a/SubscriptionHandler.h b/SubscriptionHandler.h new file mode 100644 index 0000000..786faf6 --- /dev/null +++ b/SubscriptionHandler.h @@ -0,0 +1,25 @@ +#ifndef __SubscriptionHandler_h__ +#define __SubscriptionHandler_h__ + +#include "ZString.h" +#include +#include +#include + +namespace core +{ + + class TCPSession; + + class SubscriptionHandler + { + + public: + virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) { return 0; } + + virtual int onSubscribe(TCPSession &session) { return 0; } + + }; +} + +#endif diff --git a/SubscriptionManager.cpp b/SubscriptionManager.cpp index 48fb233..cc3df99 100644 --- a/SubscriptionManager.cpp +++ b/SubscriptionManager.cpp @@ -1,85 +1,123 @@ #include "SubscriptionManager.h" #include "Log.h" +#include "Subscription.h" #include -namespace core { +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) { + lock.lock(); + subscriptions.insert(std::make_pair(subscription.id, &subscription)); + lock.unlock(); + return 1; + } - int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) { + 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 << "' (" << handler; + lock.unlock(); + return 1; + } + + int SubscriptionManager::removeSessionSubscriptions(TCPSession &session) + { int countSubscribed = 0; int countPublished = 0; - lock.lock(); + lock.lock(); std::string temp = ""; - for(auto [key, subscription] : subscriptions) { - if(temp != "") { + for (auto [key, subscription] : subscriptions) + { + if (temp != "") + { subscriptions.erase(temp); temp = ""; } countSubscribed += subscription->unsubscribe(session); - if(subscription->owner == &session) { + if (subscription->owner == &session) + { temp = key; delete subscription; ++countPublished; } } - if(temp != "") { + 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(); + 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()); + int SubscriptionManager::processCommand(coreutils::ZString &request, TCPSession &session) + { + if (request[0].equals("publish")) + { + SubscriptionHandler *handler = handlers[request[3].str()]; + newSubscription = new Subscription(request[1].str(), session, request[2].str(), handler); + 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 << ";"; + 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; + 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); + 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); + } + else if (request[0].equals("unsubscribe")) + { + subscription->unsubscribe(session); return 1; - } else if(request[0].equals("event")) { + } + else if (request[0].equals("event")) + { std::stringstream out; subscription->process(request, out, session); - if(subscription->mode == "*ANYONE") { - subscription->event(out); + if (subscription->mode == "*ANYONE") + { + subscription->event(out); return 1; - } else if(subscription->mode == "*SUBSCRIBERS") { - if(subscription->ifSubscriber(session)) { - subscription->event(out); + } + 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); + } + else if (subscription->mode == "*AUTHOR") + { + if (subscription->owner == &session) + { + subscription->event(out); return 1; } } @@ -88,5 +126,4 @@ namespace core { } return 0; } - } diff --git a/SubscriptionManager.h b/SubscriptionManager.h index 6fa042a..38226e7 100644 --- a/SubscriptionManager.h +++ b/SubscriptionManager.h @@ -1,31 +1,36 @@ #ifndef __SubscriptionManager_h__ #define __SubscriptionManager_h__ -#include "TCPSession.h" -#include "Subscription.h" #include "Command.h" +#include "Subscription.h" +#include "SubscriptionHandler.h" +#include "TCPSession.h" #include "ZString.h" -#include #include +#include namespace core { - + class SubscriptionManager : public Command { - + public: SubscriptionManager(); - - int add(Subscription &subscription); - + + int add(Subscription &subscription); + int addHandler(std::string name, SubscriptionHandler *handler); + int removeSessionSubscriptions(TCPSession &session); - + int processCommand(coreutils::ZString &request, TCPSession &session) override; - + private: + Subscription *subscription; std::map subscriptions; - std::mutex lock; - + std::map handlers; + Subscription *newSubscription; + std::mutex lock; }; + } #endif diff --git a/html/SubscriptionHandler_8h_source.html b/html/SubscriptionHandler_8h_source.html new file mode 100644 index 0000000..92ba37a --- /dev/null +++ b/html/SubscriptionHandler_8h_source.html @@ -0,0 +1,101 @@ + + + + + + + +My Project: SubscriptionHandler.h Source File + + + + + + + + + +
+
+ + + + + + +
+
My Project +
+
+
+ + + + + + + +
+ +
+
+ + +
+ +
+ +
+
+
SubscriptionHandler.h
+
+
+
1 #ifndef __SubscriptionHandler_h__
+
2 #define __SubscriptionHandler_h__
+
3 
+
4 #include "ZString.h"
+
5 #include <sstream>
+
6 #include <string>
+
7 #include <vector>
+
8 
+
9 namespace core
+
10 {
+
11 
+
12  class TCPSession;
+
13 
+
14  class SubscriptionHandler
+
15  {
+
16 
+
17  public:
+
18  virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) { return 0; }
+
19 
+
20  virtual int onSubscribe(TCPSession &session) { return 0; }
+
21 
+
22  };
+
23 }
+
24 
+
25 #endif
+
core::SubscriptionHandler
Definition: SubscriptionHandler.h:15
+
core::TCPSession
Definition: TCPSession.h:24
+
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/html/SubscriptionManager_8h_source.html b/html/SubscriptionManager_8h_source.html index d947d5e..05b879d 100644 --- a/html/SubscriptionManager_8h_source.html +++ b/html/SubscriptionManager_8h_source.html @@ -68,38 +68,44 @@ $(function() {
1 #ifndef __SubscriptionManager_h__
2 #define __SubscriptionManager_h__
3 
-
4 #include "TCPSession.h"
+
4 #include "Command.h"
5 #include "Subscription.h"
-
6 #include "Command.h"
-
7 #include "ZString.h"
-
8 #include <vector>
+
6 #include "SubscriptionHandler.h"
+
7 #include "TCPSession.h"
+
8 #include "ZString.h"
9 #include <string>
-
10 
-
11 namespace core {
-
12 
-
13  class SubscriptionManager : public Command {
-
14 
-
15  public:
-
16  SubscriptionManager();
-
17 
-
18  int add(Subscription &subscription);
-
19 
-
20  int removeSessionSubscriptions(TCPSession &session);
-
21 
-
22  int processCommand(coreutils::ZString &request, TCPSession &session) override;
-
23 
-
24  private:
-
25  std::map<std::string, Subscription *> subscriptions;
-
26  std::mutex lock;
-
27 
-
28  };
-
29 }
-
30 
-
31 #endif
+
10 #include <vector>
+
11 
+
12 namespace core {
+
13 
+
14  class SubscriptionManager : public Command {
+
15 
+
16  public:
+
17  SubscriptionManager();
+
18 
+
19  int add(Subscription &subscription);
+
20  int addHandler(std::string name, SubscriptionHandler *handler);
+
21 
+
22  int removeSessionSubscriptions(TCPSession &session);
+
23 
+
24  int processCommand(coreutils::ZString &request, TCPSession &session) override;
+
25 
+
26  private:
+
27  Subscription *subscription;
+
28  std::map<std::string, Subscription *> subscriptions;
+
29  std::map<std::string, SubscriptionHandler *> handlers;
+
30  Subscription *newSubscription;
+
31  std::mutex lock;
+
32  };
+
33 
+
34 }
+
35 
+
36 #endif
core::Command
Definition: Command.h:22
-
core::SubscriptionManager
Definition: SubscriptionManager.h:13
-
core::SubscriptionManager::processCommand
int processCommand(coreutils::ZString &request, TCPSession &session) override
Definition: SubscriptionManager.cpp:44
-
core::Subscription
Definition: Subscription.h:14
+
core::SubscriptionHandler
Definition: SubscriptionHandler.h:15
+
core::SubscriptionManager
Definition: SubscriptionManager.h:14
+
core::SubscriptionManager::processCommand
int processCommand(coreutils::ZString &request, TCPSession &session) override
Definition: SubscriptionManager.cpp:59
+
core::Subscription
Definition: Subscription.h:15
core::TCPSession
Definition: TCPSession.h:24
diff --git a/html/Subscription_8h_source.html b/html/Subscription_8h_source.html index 76584a9..e9d2dbb 100644 --- a/html/Subscription_8h_source.html +++ b/html/Subscription_8h_source.html @@ -68,46 +68,53 @@ $(function() {
1 #ifndef __Subscription_h__
2 #define __Subscription_h__
3 
-
4 #include "ZString.h"
-
5 #include <vector>
+
4 #include "SubscriptionHandler.h"
+
5 #include "ZString.h"
6 #include <string>
-
7 
-
8 namespace core
-
9 {
-
10 
-
11  class TCPSession;
-
12 
-
13  class Subscription
-
14  {
-
15 
-
16  public:
-
17  Subscription(std::string id, std::string mode = "*AUTHOR");
-
18  Subscription(std::string id, TCPSession &session, std::string mode = "*AUTHOR");
-
19  virtual ~Subscription();
-
20 
-
21  int subscribe(TCPSession &session);
-
22  int unsubscribe(TCPSession &session);
-
23 
-
24  virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session);
+
7 #include <vector>
+
8 
+
9 namespace core
+
10 {
+
11 
+
12  class TCPSession;
+
13 
+
14  class Subscription
+
15  {
+
16 
+
17  public:
+
18  Subscription(std::string id, std::string mode = "*AUTHOR");
+
19  Subscription(std::string id, TCPSession &session, std::string mode);
+
20  Subscription(std::string id, TCPSession &session, std::string mode, SubscriptionHandler *handler);
+
21  virtual ~Subscription();
+
22 
+
23  int subscribe(TCPSession &session);
+
24  int unsubscribe(TCPSession &session);
25 
-
26  virtual int onSubscribe(TCPSession &session);
+
26  virtual int process(coreutils::ZString &request, std::stringstream &out, TCPSession &session);
27 
-
28  int event(std::stringstream &out);
+
28  virtual int onSubscribe(TCPSession &session);
29 
-
30  bool ifSubscriber(TCPSession &session);
+
30  int event(std::stringstream &out);
31 
-
32  // int processCommand(coreutils::ZString &request, TCPSession &session) override;
+
32  bool ifSubscriber(TCPSession &session);
33 
-
34  std::string id;
-
35  std::string mode;
-
36  TCPSession *owner;
+
34 // void setHandler(SubscriptionHandler *handlers);
+
35 
+
36  // int processCommand(coreutils::ZString &request, TCPSession &session) override;
37 
-
38  std::vector<TCPSession *> subscribers;
-
39  };
-
40 }
+
38  std::string id;
+
39  std::string mode;
+
40  TCPSession *owner;
41 
-
42 #endif
-
core::Subscription
Definition: Subscription.h:14
+
42  SubscriptionHandler *handler;
+
43 
+
44  std::vector<TCPSession *> subscribers;
+
45  };
+
46 }
+
47 
+
48 #endif
+
core::SubscriptionHandler
Definition: SubscriptionHandler.h:15
+
core::Subscription
Definition: Subscription.h:15
core::TCPSession
Definition: TCPSession.h:24
diff --git a/html/TCPServer_8h_source.html b/html/TCPServer_8h_source.html index 35128ae..bed5652 100644 --- a/html/TCPServer_8h_source.html +++ b/html/TCPServer_8h_source.html @@ -145,7 +145,7 @@ $(function() {
core::IPAddressList
Definition: IPAddressList.h:9
core::IPAddress
Definition: IPAddress.h:9
core::SessionFilter
Definition: SessionFilter.h:10
-
core::SubscriptionManager
Definition: SubscriptionManager.h:13
+
core::SubscriptionManager
Definition: SubscriptionManager.h:14
core::TCPServer
Definition: TCPServer.h:25
core::TCPServer::onDataReceived
void onDataReceived(std::string data) override
Definition: TCPServer.cpp:36
core::TCPServer::subscriptions
SubscriptionManager subscriptions
Definition: TCPServer.h:116
diff --git a/html/annotated.html b/html/annotated.html index d2eef12..9332215 100644 --- a/html/annotated.html +++ b/html/annotated.html @@ -80,19 +80,20 @@ $(function() {  CSessionFilter  CSocket  CSubscription - CSubscriptionManager - CTCPServer - CTCPSession - CTCPSession2 - CTCPSocket - CTerminalSession - CThread - CThreadScope - CTimer - CTLSServer - CTLSSession - CUDPServerSocket - CUDPSocket + CSubscriptionHandler + CSubscriptionManager + CTCPServer + CTCPSession + CTCPSession2 + CTCPSocket + CTerminalSession + CThread + CThreadScope + CTimer + CTLSServer + CTLSSession + CUDPServerSocket + CUDPSocket diff --git a/html/classcore_1_1Subscription-members.html b/html/classcore_1_1Subscription-members.html index bf4d3db..8bccb68 100644 --- a/html/classcore_1_1Subscription-members.html +++ b/html/classcore_1_1Subscription-members.html @@ -73,16 +73,18 @@ $(function() {

This is the complete list of members for core::Subscription, including all inherited members.

- - - - - - - - - - + + + + + + + + + + + +
event(std::stringstream &out) (defined in core::Subscription)core::Subscription
id (defined in core::Subscription)core::Subscription
ifSubscriber(TCPSession &session) (defined in core::Subscription)core::Subscription
mode (defined in core::Subscription)core::Subscription
onSubscribe(TCPSession &session) (defined in core::Subscription)core::Subscriptionvirtual
owner (defined in core::Subscription)core::Subscription
process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) (defined in core::Subscription)core::Subscriptionvirtual
subscribe(TCPSession &session) (defined in core::Subscription)core::Subscription
subscribers (defined in core::Subscription)core::Subscription
Subscription(std::string id, std::string mode="*AUTHOR") (defined in core::Subscription)core::Subscription
Subscription(std::string id, TCPSession &session, std::string mode="*AUTHOR") (defined in core::Subscription)core::Subscription
handler (defined in core::Subscription)core::Subscription
id (defined in core::Subscription)core::Subscription
ifSubscriber(TCPSession &session) (defined in core::Subscription)core::Subscription
mode (defined in core::Subscription)core::Subscription
onSubscribe(TCPSession &session) (defined in core::Subscription)core::Subscriptionvirtual
owner (defined in core::Subscription)core::Subscription
process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) (defined in core::Subscription)core::Subscriptionvirtual
subscribe(TCPSession &session) (defined in core::Subscription)core::Subscription
subscribers (defined in core::Subscription)core::Subscription
Subscription(std::string id, std::string mode="*AUTHOR") (defined in core::Subscription)core::Subscription
Subscription(std::string id, TCPSession &session, std::string mode) (defined in core::Subscription)core::Subscription
Subscription(std::string id, TCPSession &session, std::string mode, SubscriptionHandler *handler) (defined in core::Subscription)core::Subscription
unsubscribe(TCPSession &session) (defined in core::Subscription)core::Subscription
~Subscription() (defined in core::Subscription)core::Subscriptionvirtual
diff --git a/html/classcore_1_1Subscription.html b/html/classcore_1_1Subscription.html index 4bd1830..62d710d 100644 --- a/html/classcore_1_1Subscription.html +++ b/html/classcore_1_1Subscription.html @@ -78,15 +78,16 @@ Collaboration diagram for core::Subscription:
Collaboration graph
- - + + + - + @@ -98,9 +99,12 @@ Public Member Functions  Subscription (std::string id, std::string mode="*AUTHOR")   - - Subscription (std::string id, TCPSession &session, std::string mode="*AUTHOR") -  + + Subscription (std::string id, TCPSession &session, std::string mode) +  + + Subscription (std::string id, TCPSession &session, std::string mode, SubscriptionHandler *handler) +  int subscribe (TCPSession &session)   @@ -131,6 +135,9 @@ std::string mode< TCPSession * owner   + +SubscriptionHandler * handler +  std::vector< TCPSession * > subscribers   diff --git a/html/classcore_1_1SubscriptionHandler-members.html b/html/classcore_1_1SubscriptionHandler-members.html new file mode 100644 index 0000000..a880caf --- /dev/null +++ b/html/classcore_1_1SubscriptionHandler-members.html @@ -0,0 +1,83 @@ + + + + + + + +My Project: Member List + + + + + + + + + +
+
+ + + + + + +
+
My Project +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+
core::SubscriptionHandler Member List
+
+
+ +

This is the complete list of members for core::SubscriptionHandler, including all inherited members.

+ + + +
onSubscribe(TCPSession &session) (defined in core::SubscriptionHandler)core::SubscriptionHandlerinlinevirtual
process(coreutils::ZString &request, std::stringstream &out, TCPSession &session) (defined in core::SubscriptionHandler)core::SubscriptionHandlerinlinevirtual
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/html/classcore_1_1SubscriptionHandler.html b/html/classcore_1_1SubscriptionHandler.html new file mode 100644 index 0000000..3edbfae --- /dev/null +++ b/html/classcore_1_1SubscriptionHandler.html @@ -0,0 +1,94 @@ + + + + + + + +My Project: core::SubscriptionHandler Class Reference + + + + + + + + + +
+
+ + + + + + +
+
My Project +
+
+
+ + + + + + + + +
+
+ + +
+ +
+ + +
+
+
+Public Member Functions | +List of all members
+
+
core::SubscriptionHandler Class Reference
+
+
+ + + + + + +

+Public Member Functions

+virtual int process (coreutils::ZString &request, std::stringstream &out, TCPSession &session)
 
+virtual int onSubscribe (TCPSession &session)
 
+
The documentation for this class was generated from the following file: +
+ +
+Generated by doxygen 1.9.1 +
+ + diff --git a/html/classcore_1_1SubscriptionManager-members.html b/html/classcore_1_1SubscriptionManager-members.html index 98308d3..189999c 100644 --- a/html/classcore_1_1SubscriptionManager-members.html +++ b/html/classcore_1_1SubscriptionManager-members.html @@ -73,10 +73,11 @@ $(function() {

This is the complete list of members for core::SubscriptionManager, including all inherited members.

- - - - + + + + +
add(Subscription &subscription) (defined in core::SubscriptionManager)core::SubscriptionManager
output(std::stringstream &out)core::Commandvirtual
processCommand(coreutils::ZString &request, TCPSession &session) overridecore::SubscriptionManagervirtual
removeSessionSubscriptions(TCPSession &session) (defined in core::SubscriptionManager)core::SubscriptionManager
SubscriptionManager() (defined in core::SubscriptionManager)core::SubscriptionManager
addHandler(std::string name, SubscriptionHandler *handler) (defined in core::SubscriptionManager)core::SubscriptionManager
output(std::stringstream &out)core::Commandvirtual
processCommand(coreutils::ZString &request, TCPSession &session) overridecore::SubscriptionManagervirtual
removeSessionSubscriptions(TCPSession &session) (defined in core::SubscriptionManager)core::SubscriptionManager
SubscriptionManager() (defined in core::SubscriptionManager)core::SubscriptionManager
diff --git a/html/classcore_1_1SubscriptionManager.html b/html/classcore_1_1SubscriptionManager.html index 558182a..a5d8441 100644 --- a/html/classcore_1_1SubscriptionManager.html +++ b/html/classcore_1_1SubscriptionManager.html @@ -96,6 +96,9 @@ Public Member Functions int add (Subscription &subscription)   + +int addHandler (std::string name, SubscriptionHandler *handler) +  int removeSessionSubscriptions (TCPSession &session)   diff --git a/html/classcore_1_1Subscription__coll__graph.map b/html/classcore_1_1Subscription__coll__graph.map index 284eb43..6bca637 100644 --- a/html/classcore_1_1Subscription__coll__graph.map +++ b/html/classcore_1_1Subscription__coll__graph.map @@ -1,14 +1,15 @@ - - - - - - - - - - - - + + + + + + + + + + + + + diff --git a/html/classcore_1_1Subscription__coll__graph.md5 b/html/classcore_1_1Subscription__coll__graph.md5 index d8c5317..8099362 100644 --- a/html/classcore_1_1Subscription__coll__graph.md5 +++ b/html/classcore_1_1Subscription__coll__graph.md5 @@ -1 +1 @@ -3f390c0fbcf254a8f2dec14ce3855745 \ No newline at end of file +349f64021c7577575a335d64271fb257 \ No newline at end of file diff --git a/html/classcore_1_1Subscription__coll__graph.png b/html/classcore_1_1Subscription__coll__graph.png index 37c2930..b2c2b1c 100644 Binary files a/html/classcore_1_1Subscription__coll__graph.png and b/html/classcore_1_1Subscription__coll__graph.png differ diff --git a/html/classes.html b/html/classes.html index 5a7ffbd..b45a4d9 100644 --- a/html/classes.html +++ b/html/classes.html @@ -81,7 +81,7 @@ $(function() {
Object (core)
S
-
SessionFilter (core)
Socket (core)
Subscription (core)
SubscriptionManager (core)
+
SessionFilter (core)
Socket (core)
Subscription (core)
SubscriptionHandler (core)
SubscriptionManager (core)
T
TCPServer (core)
TCPSession (core)
TCPSession2 (core)
TCPSocket (core)
TerminalSession (core)
Thread (core)
ThreadScope (core)
Timer (core)
TLSServer (core)
TLSSession (core)
diff --git a/html/files.html b/html/files.html index 5310d60..2720b51 100644 --- a/html/files.html +++ b/html/files.html @@ -79,19 +79,20 @@ $(function() {  SessionFilter.h  Socket.h  Subscription.h - SubscriptionManager.h - TCPServer.h - TCPSession.h - TCPSession2.h - TCPSocket.h - TerminalSession.h - Thread.h - ThreadScope.h - Timer.h - TLSServer.h - TLSSession.h - UDPServerSocket.h - UDPSocket.h + SubscriptionHandler.h + SubscriptionManager.h + TCPServer.h + TCPSession.h + TCPSession2.h + TCPSocket.h + TerminalSession.h + Thread.h + ThreadScope.h + Timer.h + TLSServer.h + TLSSession.h + UDPServerSocket.h + UDPSocket.h diff --git a/html/hierarchy.html b/html/hierarchy.html index adb93e6..9d8c0e7 100644 --- a/html/hierarchy.html +++ b/html/hierarchy.html @@ -97,7 +97,8 @@ This inheritance list is sorted roughly, but not completely, alphabetically: ▼Ccore::UDPSocket  Ccore::UDPServerSocket  Ccore::Subscription - Ccore::ThreadScope + Ccore::SubscriptionHandler + Ccore::ThreadScope diff --git a/html/inherit_graph_4.map b/html/inherit_graph_4.map index 5ab4fa2..fb2c300 100644 --- a/html/inherit_graph_4.map +++ b/html/inherit_graph_4.map @@ -1,3 +1,3 @@ - + diff --git a/html/inherit_graph_4.md5 b/html/inherit_graph_4.md5 index 10c264c..b9b4fef 100644 --- a/html/inherit_graph_4.md5 +++ b/html/inherit_graph_4.md5 @@ -1 +1 @@ -af3a9400a188146f4f12e1a0e129faf2 \ No newline at end of file +6bfd00f81b50345da1bbf756e128f069 \ No newline at end of file diff --git a/html/inherit_graph_4.png b/html/inherit_graph_4.png index 8dd8946..0a81b26 100644 Binary files a/html/inherit_graph_4.png and b/html/inherit_graph_4.png differ diff --git a/html/inherit_graph_5.map b/html/inherit_graph_5.map new file mode 100644 index 0000000..5ab4fa2 --- /dev/null +++ b/html/inherit_graph_5.map @@ -0,0 +1,3 @@ + + + diff --git a/html/inherit_graph_5.md5 b/html/inherit_graph_5.md5 new file mode 100644 index 0000000..10c264c --- /dev/null +++ b/html/inherit_graph_5.md5 @@ -0,0 +1 @@ +af3a9400a188146f4f12e1a0e129faf2 \ No newline at end of file diff --git a/html/inherit_graph_5.png b/html/inherit_graph_5.png new file mode 100644 index 0000000..8dd8946 Binary files /dev/null and b/html/inherit_graph_5.png differ diff --git a/html/inherits.html b/html/inherits.html index d3889f0..441a4e0 100644 --- a/html/inherits.html +++ b/html/inherits.html @@ -109,7 +109,12 @@ $(function() { - + + + + + + diff --git a/html/search/all_a.js b/html/search/all_a.js index 9c2ee14..f6093c3 100644 --- a/html/search/all_a.js +++ b/html/search/all_a.js @@ -13,6 +13,7 @@ var searchData= ['start_51',['start',['../classcore_1_1EPoll.html#aaefe2caef75eb538af90cb34682d277b',1,'core::EPoll::start()'],['../classcore_1_1Thread.html#ae6885df9a9b9503669e5776518b19054',1,'core::Thread::start()']]], ['stop_52',['stop',['../classcore_1_1EPoll.html#a0c2865acd31d14fbf19dbc42cc084ddc',1,'core::EPoll']]], ['subscription_53',['Subscription',['../classcore_1_1Subscription.html',1,'core']]], - ['subscriptionmanager_54',['SubscriptionManager',['../classcore_1_1SubscriptionManager.html',1,'core']]], - ['subscriptions_55',['subscriptions',['../classcore_1_1TCPServer.html#a28302dd844cfc971ee41de2000d24aa0',1,'core::TCPServer']]] + ['subscriptionhandler_54',['SubscriptionHandler',['../classcore_1_1SubscriptionHandler.html',1,'core']]], + ['subscriptionmanager_55',['SubscriptionManager',['../classcore_1_1SubscriptionManager.html',1,'core']]], + ['subscriptions_56',['subscriptions',['../classcore_1_1TCPServer.html#a28302dd844cfc971ee41de2000d24aa0',1,'core::TCPServer']]] ]; diff --git a/html/search/all_b.js b/html/search/all_b.js index a463ff5..b6100b7 100644 --- a/html/search/all_b.js +++ b/html/search/all_b.js @@ -1,14 +1,14 @@ var searchData= [ - ['tcpserver_56',['TCPServer',['../classcore_1_1TCPServer.html',1,'core::TCPServer'],['../classcore_1_1TCPServer.html#abaecb97c336b757d1029d45277f9fc5b',1,'core::TCPServer::TCPServer()']]], - ['tcpsession_57',['TCPSession',['../classcore_1_1TCPSession.html',1,'core']]], - ['tcpsession2_58',['TCPSession2',['../classcore_1_1TCPSession2.html',1,'core']]], - ['tcpsocket_59',['TCPSocket',['../classcore_1_1TCPSocket.html',1,'core']]], - ['terminalsession_60',['TerminalSession',['../classcore_1_1TerminalSession.html',1,'core']]], - ['terminate_61',['terminate',['../classcore_1_1TCPSession.html#a34936745e8d7669d5400e78d353a56d3',1,'core::TCPSession::terminate()'],['../classcore_1_1TCPSession2.html#a6b999e7ea6551a1b513ee057afaa9e4a',1,'core::TCPSession2::terminate()']]], - ['thread_62',['Thread',['../classcore_1_1Thread.html',1,'core']]], - ['threadscope_63',['ThreadScope',['../classcore_1_1ThreadScope.html',1,'core']]], - ['timer_64',['Timer',['../classcore_1_1Timer.html',1,'core']]], - ['tlsserver_65',['TLSServer',['../classcore_1_1TLSServer.html',1,'core::TLSServer'],['../classcore_1_1TLSServer.html#a6460f9872936015efdfd0b8de04aa2fe',1,'core::TLSServer::TLSServer()']]], - ['tlssession_66',['TLSSession',['../classcore_1_1TLSSession.html',1,'core']]] + ['tcpserver_57',['TCPServer',['../classcore_1_1TCPServer.html',1,'core::TCPServer'],['../classcore_1_1TCPServer.html#abaecb97c336b757d1029d45277f9fc5b',1,'core::TCPServer::TCPServer()']]], + ['tcpsession_58',['TCPSession',['../classcore_1_1TCPSession.html',1,'core']]], + ['tcpsession2_59',['TCPSession2',['../classcore_1_1TCPSession2.html',1,'core']]], + ['tcpsocket_60',['TCPSocket',['../classcore_1_1TCPSocket.html',1,'core']]], + ['terminalsession_61',['TerminalSession',['../classcore_1_1TerminalSession.html',1,'core']]], + ['terminate_62',['terminate',['../classcore_1_1TCPSession.html#a34936745e8d7669d5400e78d353a56d3',1,'core::TCPSession::terminate()'],['../classcore_1_1TCPSession2.html#a6b999e7ea6551a1b513ee057afaa9e4a',1,'core::TCPSession2::terminate()']]], + ['thread_63',['Thread',['../classcore_1_1Thread.html',1,'core']]], + ['threadscope_64',['ThreadScope',['../classcore_1_1ThreadScope.html',1,'core']]], + ['timer_65',['Timer',['../classcore_1_1Timer.html',1,'core']]], + ['tlsserver_66',['TLSServer',['../classcore_1_1TLSServer.html',1,'core::TLSServer'],['../classcore_1_1TLSServer.html#a6460f9872936015efdfd0b8de04aa2fe',1,'core::TLSServer::TLSServer()']]], + ['tlssession_67',['TLSSession',['../classcore_1_1TLSSession.html',1,'core']]] ]; diff --git a/html/search/all_c.js b/html/search/all_c.js index 449190d..a03a5b6 100644 --- a/html/search/all_c.js +++ b/html/search/all_c.js @@ -1,6 +1,6 @@ var searchData= [ - ['udpserversocket_67',['UDPServerSocket',['../classcore_1_1UDPServerSocket.html',1,'core']]], - ['udpsocket_68',['UDPSocket',['../classcore_1_1UDPSocket.html',1,'core']]], - ['unregistersocket_69',['unregisterSocket',['../classcore_1_1EPoll.html#a5ab5e82ab51e0952fc8fbcc128f52900',1,'core::EPoll']]] + ['udpserversocket_68',['UDPServerSocket',['../classcore_1_1UDPServerSocket.html',1,'core']]], + ['udpsocket_69',['UDPSocket',['../classcore_1_1UDPSocket.html',1,'core']]], + ['unregistersocket_70',['unregisterSocket',['../classcore_1_1EPoll.html#a5ab5e82ab51e0952fc8fbcc128f52900',1,'core::EPoll']]] ]; diff --git a/html/search/all_d.js b/html/search/all_d.js index 56f1de6..3ea4c67 100644 --- a/html/search/all_d.js +++ b/html/search/all_d.js @@ -1,5 +1,5 @@ var searchData= [ - ['whitelist_70',['whiteList',['../classcore_1_1TCPServer.html#abad6300b6234ca8b69cef9128755342e',1,'core::TCPServer']]], - ['write_71',['write',['../classcore_1_1Socket.html#a1413c826307ef0f29d7457770af675e3',1,'core::Socket']]] + ['whitelist_71',['whiteList',['../classcore_1_1TCPServer.html#abad6300b6234ca8b69cef9128755342e',1,'core::TCPServer']]], + ['write_72',['write',['../classcore_1_1Socket.html#a1413c826307ef0f29d7457770af675e3',1,'core::Socket']]] ]; diff --git a/html/search/all_e.js b/html/search/all_e.js index adb3a62..70efe7a 100644 --- a/html/search/all_e.js +++ b/html/search/all_e.js @@ -1,7 +1,7 @@ var searchData= [ - ['_7eepoll_72',['~EPoll',['../classcore_1_1EPoll.html#a8e7a2496d684b745a6410f9bd3e88534',1,'core::EPoll']]], - ['_7esocket_73',['~Socket',['../classcore_1_1Socket.html#aa5003845f8ae464ad2fa206176381be0',1,'core::Socket']]], - ['_7etcpserver_74',['~TCPServer',['../classcore_1_1TCPServer.html#a7ccdc057c9eee8504fce796301f82088',1,'core::TCPServer']]], - ['_7etlsserver_75',['~TLSServer',['../classcore_1_1TLSServer.html#ac71db77c796a1bf65357409cb96054c7',1,'core::TLSServer']]] + ['_7eepoll_73',['~EPoll',['../classcore_1_1EPoll.html#a8e7a2496d684b745a6410f9bd3e88534',1,'core::EPoll']]], + ['_7esocket_74',['~Socket',['../classcore_1_1Socket.html#aa5003845f8ae464ad2fa206176381be0',1,'core::Socket']]], + ['_7etcpserver_75',['~TCPServer',['../classcore_1_1TCPServer.html#a7ccdc057c9eee8504fce796301f82088',1,'core::TCPServer']]], + ['_7etlsserver_76',['~TLSServer',['../classcore_1_1TLSServer.html#ac71db77c796a1bf65357409cb96054c7',1,'core::TLSServer']]] ]; diff --git a/html/search/classes_0.js b/html/search/classes_0.js index 8b5b0e9..3d5deca 100644 --- a/html/search/classes_0.js +++ b/html/search/classes_0.js @@ -1,7 +1,7 @@ var searchData= [ - ['command_76',['Command',['../classcore_1_1Command.html',1,'core']]], - ['commandlist_77',['CommandList',['../classcore_1_1CommandList.html',1,'core']]], - ['consoleserver_78',['ConsoleServer',['../classcore_1_1ConsoleServer.html',1,'core']]], - ['consolesession_79',['ConsoleSession',['../classcore_1_1ConsoleSession.html',1,'core']]] + ['command_77',['Command',['../classcore_1_1Command.html',1,'core']]], + ['commandlist_78',['CommandList',['../classcore_1_1CommandList.html',1,'core']]], + ['consoleserver_79',['ConsoleServer',['../classcore_1_1ConsoleServer.html',1,'core']]], + ['consolesession_80',['ConsoleSession',['../classcore_1_1ConsoleSession.html',1,'core']]] ]; diff --git a/html/search/classes_1.js b/html/search/classes_1.js index ede01d4..5d358b0 100644 --- a/html/search/classes_1.js +++ b/html/search/classes_1.js @@ -1,4 +1,4 @@ var searchData= [ - ['epoll_80',['EPoll',['../classcore_1_1EPoll.html',1,'core']]] + ['epoll_81',['EPoll',['../classcore_1_1EPoll.html',1,'core']]] ]; diff --git a/html/search/classes_2.js b/html/search/classes_2.js index 5895b67..17850a4 100644 --- a/html/search/classes_2.js +++ b/html/search/classes_2.js @@ -1,6 +1,6 @@ var searchData= [ - ['inotify_81',['INotify',['../classcore_1_1INotify.html',1,'core']]], - ['ipaddress_82',['IPAddress',['../classcore_1_1IPAddress.html',1,'core']]], - ['ipaddresslist_83',['IPAddressList',['../classcore_1_1IPAddressList.html',1,'core']]] + ['inotify_82',['INotify',['../classcore_1_1INotify.html',1,'core']]], + ['ipaddress_83',['IPAddress',['../classcore_1_1IPAddress.html',1,'core']]], + ['ipaddresslist_84',['IPAddressList',['../classcore_1_1IPAddressList.html',1,'core']]] ]; diff --git a/html/search/classes_3.js b/html/search/classes_3.js index 4ede2d7..229426e 100644 --- a/html/search/classes_3.js +++ b/html/search/classes_3.js @@ -1,4 +1,4 @@ var searchData= [ - ['object_84',['Object',['../classcore_1_1Object.html',1,'core']]] + ['object_85',['Object',['../classcore_1_1Object.html',1,'core']]] ]; diff --git a/html/search/classes_4.js b/html/search/classes_4.js index 0e08cb2..bd66c60 100644 --- a/html/search/classes_4.js +++ b/html/search/classes_4.js @@ -1,7 +1,8 @@ var searchData= [ - ['sessionfilter_85',['SessionFilter',['../classcore_1_1SessionFilter.html',1,'core']]], - ['socket_86',['Socket',['../classcore_1_1Socket.html',1,'core']]], - ['subscription_87',['Subscription',['../classcore_1_1Subscription.html',1,'core']]], - ['subscriptionmanager_88',['SubscriptionManager',['../classcore_1_1SubscriptionManager.html',1,'core']]] + ['sessionfilter_86',['SessionFilter',['../classcore_1_1SessionFilter.html',1,'core']]], + ['socket_87',['Socket',['../classcore_1_1Socket.html',1,'core']]], + ['subscription_88',['Subscription',['../classcore_1_1Subscription.html',1,'core']]], + ['subscriptionhandler_89',['SubscriptionHandler',['../classcore_1_1SubscriptionHandler.html',1,'core']]], + ['subscriptionmanager_90',['SubscriptionManager',['../classcore_1_1SubscriptionManager.html',1,'core']]] ]; diff --git a/html/search/classes_5.js b/html/search/classes_5.js index d78d741..2724312 100644 --- a/html/search/classes_5.js +++ b/html/search/classes_5.js @@ -1,13 +1,13 @@ var searchData= [ - ['tcpserver_89',['TCPServer',['../classcore_1_1TCPServer.html',1,'core']]], - ['tcpsession_90',['TCPSession',['../classcore_1_1TCPSession.html',1,'core']]], - ['tcpsession2_91',['TCPSession2',['../classcore_1_1TCPSession2.html',1,'core']]], - ['tcpsocket_92',['TCPSocket',['../classcore_1_1TCPSocket.html',1,'core']]], - ['terminalsession_93',['TerminalSession',['../classcore_1_1TerminalSession.html',1,'core']]], - ['thread_94',['Thread',['../classcore_1_1Thread.html',1,'core']]], - ['threadscope_95',['ThreadScope',['../classcore_1_1ThreadScope.html',1,'core']]], - ['timer_96',['Timer',['../classcore_1_1Timer.html',1,'core']]], - ['tlsserver_97',['TLSServer',['../classcore_1_1TLSServer.html',1,'core']]], - ['tlssession_98',['TLSSession',['../classcore_1_1TLSSession.html',1,'core']]] + ['tcpserver_91',['TCPServer',['../classcore_1_1TCPServer.html',1,'core']]], + ['tcpsession_92',['TCPSession',['../classcore_1_1TCPSession.html',1,'core']]], + ['tcpsession2_93',['TCPSession2',['../classcore_1_1TCPSession2.html',1,'core']]], + ['tcpsocket_94',['TCPSocket',['../classcore_1_1TCPSocket.html',1,'core']]], + ['terminalsession_95',['TerminalSession',['../classcore_1_1TerminalSession.html',1,'core']]], + ['thread_96',['Thread',['../classcore_1_1Thread.html',1,'core']]], + ['threadscope_97',['ThreadScope',['../classcore_1_1ThreadScope.html',1,'core']]], + ['timer_98',['Timer',['../classcore_1_1Timer.html',1,'core']]], + ['tlsserver_99',['TLSServer',['../classcore_1_1TLSServer.html',1,'core']]], + ['tlssession_100',['TLSSession',['../classcore_1_1TLSSession.html',1,'core']]] ]; diff --git a/html/search/classes_6.js b/html/search/classes_6.js index 864dc2a..d37a51a 100644 --- a/html/search/classes_6.js +++ b/html/search/classes_6.js @@ -1,5 +1,5 @@ var searchData= [ - ['udpserversocket_99',['UDPServerSocket',['../classcore_1_1UDPServerSocket.html',1,'core']]], - ['udpsocket_100',['UDPSocket',['../classcore_1_1UDPSocket.html',1,'core']]] + ['udpserversocket_101',['UDPServerSocket',['../classcore_1_1UDPServerSocket.html',1,'core']]], + ['udpsocket_102',['UDPSocket',['../classcore_1_1UDPSocket.html',1,'core']]] ]; diff --git a/html/search/functions_0.js b/html/search/functions_0.js index 17b87ed..bf61cc3 100644 --- a/html/search/functions_0.js +++ b/html/search/functions_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['add_101',['add',['../classcore_1_1CommandList.html#a7a45e75e3d21a25fd3f7e887acf395e9',1,'core::CommandList']]] + ['add_103',['add',['../classcore_1_1CommandList.html#a7a45e75e3d21a25fd3f7e887acf395e9',1,'core::CommandList']]] ]; diff --git a/html/search/functions_1.js b/html/search/functions_1.js index 3fb0d0c..fe627dc 100644 --- a/html/search/functions_1.js +++ b/html/search/functions_1.js @@ -1,6 +1,6 @@ var searchData= [ - ['clear_102',['clear',['../classcore_1_1TerminalSession.html#a42bb06857891220a831da04248233935',1,'core::TerminalSession']]], - ['cleareol_103',['clearEOL',['../classcore_1_1TerminalSession.html#aa660768eed03b0b996a749e8a146446c',1,'core::TerminalSession']]], - ['cleartimer_104',['clearTimer',['../classcore_1_1Timer.html#a8e063f46e89dac04364871e909ab940a',1,'core::Timer']]] + ['clear_104',['clear',['../classcore_1_1TerminalSession.html#a42bb06857891220a831da04248233935',1,'core::TerminalSession']]], + ['cleareol_105',['clearEOL',['../classcore_1_1TerminalSession.html#aa660768eed03b0b996a749e8a146446c',1,'core::TerminalSession']]], + ['cleartimer_106',['clearTimer',['../classcore_1_1Timer.html#a8e063f46e89dac04364871e909ab940a',1,'core::Timer']]] ]; diff --git a/html/search/functions_2.js b/html/search/functions_2.js index 0fb2868..9ab5d3a 100644 --- a/html/search/functions_2.js +++ b/html/search/functions_2.js @@ -1,5 +1,5 @@ var searchData= [ - ['epoll_105',['EPoll',['../classcore_1_1EPoll.html#a2fd5cc4336b5f72990ecc0e7ea3d7641',1,'core::EPoll']]], - ['eventreceived_106',['eventReceived',['../classcore_1_1EPoll.html#a3238b150b5d0a57eb2e1b17daa236d3b',1,'core::EPoll::eventReceived()'],['../classcore_1_1Socket.html#a1a045e15fb5851d666a21be05ac4c5d7',1,'core::Socket::eventReceived()']]] + ['epoll_107',['EPoll',['../classcore_1_1EPoll.html#a2fd5cc4336b5f72990ecc0e7ea3d7641',1,'core::EPoll']]], + ['eventreceived_108',['eventReceived',['../classcore_1_1EPoll.html#a3238b150b5d0a57eb2e1b17daa236d3b',1,'core::EPoll::eventReceived()'],['../classcore_1_1Socket.html#a1a045e15fb5851d666a21be05ac4c5d7',1,'core::Socket::eventReceived()']]] ]; diff --git a/html/search/functions_3.js b/html/search/functions_3.js index ce196a2..131d135 100644 --- a/html/search/functions_3.js +++ b/html/search/functions_3.js @@ -1,10 +1,10 @@ var searchData= [ - ['getclientaddress_107',['getClientAddress',['../classcore_1_1IPAddress.html#ae5e7e28589d026bbbc6c3423d418b008',1,'core::IPAddress']]], - ['getclientaddressandport_108',['getClientAddressAndPort',['../classcore_1_1IPAddress.html#abea870f1a048cb7bba1d2bad98558232',1,'core::IPAddress']]], - ['getclientport_109',['getClientPort',['../classcore_1_1IPAddress.html#a39f706f2d43d7d001296ecead4b587e8',1,'core::IPAddress']]], - ['getdescriptor_110',['getDescriptor',['../classcore_1_1EPoll.html#a1e52017e1deae15c1c87c6b6a099e1ed',1,'core::EPoll::getDescriptor()'],['../classcore_1_1Socket.html#a06ba54744530439d4131e6aba4623d08',1,'core::Socket::getDescriptor()']]], - ['getelapsed_111',['getElapsed',['../classcore_1_1Timer.html#a0df7f1ffc05529b45d6e13713bbc0209',1,'core::Timer']]], - ['getsocketaccept_112',['getSocketAccept',['../classcore_1_1ConsoleServer.html#a80d9ea7f3fc5e07c50d5b9e0d4943ca8',1,'core::ConsoleServer::getSocketAccept()'],['../classcore_1_1TCPServer.html#a841f02799ad8529aad7cea132f4de8a9',1,'core::TCPServer::getSocketAccept()']]], - ['grabinput_113',['grabInput',['../classcore_1_1CommandList.html#a72aea93a650f148c639ba25a724da243',1,'core::CommandList']]] + ['getclientaddress_109',['getClientAddress',['../classcore_1_1IPAddress.html#ae5e7e28589d026bbbc6c3423d418b008',1,'core::IPAddress']]], + ['getclientaddressandport_110',['getClientAddressAndPort',['../classcore_1_1IPAddress.html#abea870f1a048cb7bba1d2bad98558232',1,'core::IPAddress']]], + ['getclientport_111',['getClientPort',['../classcore_1_1IPAddress.html#a39f706f2d43d7d001296ecead4b587e8',1,'core::IPAddress']]], + ['getdescriptor_112',['getDescriptor',['../classcore_1_1EPoll.html#a1e52017e1deae15c1c87c6b6a099e1ed',1,'core::EPoll::getDescriptor()'],['../classcore_1_1Socket.html#a06ba54744530439d4131e6aba4623d08',1,'core::Socket::getDescriptor()']]], + ['getelapsed_113',['getElapsed',['../classcore_1_1Timer.html#a0df7f1ffc05529b45d6e13713bbc0209',1,'core::Timer']]], + ['getsocketaccept_114',['getSocketAccept',['../classcore_1_1ConsoleServer.html#a80d9ea7f3fc5e07c50d5b9e0d4943ca8',1,'core::ConsoleServer::getSocketAccept()'],['../classcore_1_1TCPServer.html#a841f02799ad8529aad7cea132f4de8a9',1,'core::TCPServer::getSocketAccept()']]], + ['grabinput_115',['grabInput',['../classcore_1_1CommandList.html#a72aea93a650f148c639ba25a724da243',1,'core::CommandList']]] ]; diff --git a/html/search/functions_4.js b/html/search/functions_4.js index 48c7f3c..4187140 100644 --- a/html/search/functions_4.js +++ b/html/search/functions_4.js @@ -1,4 +1,4 @@ var searchData= [ - ['isstopping_114',['isStopping',['../classcore_1_1EPoll.html#a301b46b71ac7ac61a687ff723fe269b3',1,'core::EPoll']]] + ['isstopping_116',['isStopping',['../classcore_1_1EPoll.html#a301b46b71ac7ac61a687ff723fe269b3',1,'core::EPoll']]] ]; diff --git a/html/search/functions_5.js b/html/search/functions_5.js index ebf885a..dc05dc0 100644 --- a/html/search/functions_5.js +++ b/html/search/functions_5.js @@ -1,12 +1,12 @@ var searchData= [ - ['onblockreceived_115',['onBlockReceived',['../classcore_1_1TCPSession2.html#a6c88775e81dc0074ef0832146be9f4b9',1,'core::TCPSession2::onBlockReceived()'],['../classcore_1_1TCPSession.html#a9c996cbbfa2e592c23cf67ed8b15a32a',1,'core::TCPSession::onBlockReceived(coreutils::ZString &block)']]], - ['onconnected_116',['onConnected',['../classcore_1_1TCPSession.html#a8719952f7bb00bf7239ec40aa2868626',1,'core::TCPSession::onConnected()'],['../classcore_1_1TCPSession2.html#af1913cb444a9e07c0f31a2cd8d934a62',1,'core::TCPSession2::onConnected()']]], - ['ondatareceived_117',['onDataReceived',['../classcore_1_1Socket.html#ac8d6a2c54696eb6fc2024cf6bcf6b4e5',1,'core::Socket::onDataReceived()'],['../classcore_1_1TCPServer.html#a276ccbc8cb9b4380ebd78807b97f0159',1,'core::TCPServer::onDataReceived()'],['../classcore_1_1TCPSession.html#afc2d2a92bc65e1e5122a93d120253a1d',1,'core::TCPSession::onDataReceived()'],['../classcore_1_1TCPSession2.html#a67c473e1a22b10fc100ae54206f7471b',1,'core::TCPSession2::onDataReceived()'],['../classcore_1_1UDPServerSocket.html#a41933ca153c854a800e3d047ab18313e',1,'core::UDPServerSocket::onDataReceived()']]], - ['onlinereceived_118',['onLineReceived',['../classcore_1_1TCPSession.html#a3d9e0f14e7d24357fd1950b3f9b4eaff',1,'core::TCPSession::onLineReceived()'],['../classcore_1_1TCPSession2.html#a6cd36b444d9548d1024190c6ba747e18',1,'core::TCPSession2::onLineReceived()']]], - ['onregister_119',['onRegister',['../classcore_1_1TLSSession.html#a76cec7cf4851eb27abe77a2339344c6d',1,'core::TLSSession::onRegister()'],['../classcore_1_1Socket.html#a81e5ee3e17834166d97c6e8b7dfe0da0',1,'core::Socket::onRegister()']]], - ['onregistered_120',['onRegistered',['../classcore_1_1Socket.html#a23b9824653bbe4652a716acb828665b1',1,'core::Socket::onRegistered()'],['../classcore_1_1TCPSession.html#aed4ed499b978bcea57a8efefe929fc98',1,'core::TCPSession::onRegistered()'],['../classcore_1_1TCPSession2.html#a76096659b82c5dcbf6eac1d916511e60',1,'core::TCPSession2::onRegistered()'],['../classcore_1_1TLSSession.html#a8e26fdc9e8a6c573b5a504a1f1b137a9',1,'core::TLSSession::onRegistered()']]], - ['ontimeout_121',['onTimeout',['../classcore_1_1Timer.html#ae51704ff08d985bbc30e3ff4c9b3c6ca',1,'core::Timer']]], - ['onunregistered_122',['onUnregistered',['../classcore_1_1Socket.html#ae9be59697c2b2e5efb19aaae3ba943d2',1,'core::Socket']]], - ['output_123',['output',['../classcore_1_1Command.html#ab6352ce5650e70a5c76c3d6e4eefd292',1,'core::Command::output()'],['../classcore_1_1TCPServer.html#a49e3ead1bf4e7830685780e73c4db5db',1,'core::TCPServer::output()'],['../classcore_1_1TCPSession.html#a50037cbfc515650e04054e5481785981',1,'core::TCPSession::output()'],['../classcore_1_1TCPSession2.html#ae7648a7759570a00d3d4a8c169183291',1,'core::TCPSession2::output()'],['../classcore_1_1TCPSocket.html#afacf7528ff3c9ac077d7b5a49e2116fd',1,'core::TCPSocket::output()'],['../classcore_1_1TLSSession.html#ae55de8a035d1ddc560cf619b2030af43',1,'core::TLSSession::output()']]] + ['onblockreceived_117',['onBlockReceived',['../classcore_1_1TCPSession2.html#a6c88775e81dc0074ef0832146be9f4b9',1,'core::TCPSession2::onBlockReceived()'],['../classcore_1_1TCPSession.html#a9c996cbbfa2e592c23cf67ed8b15a32a',1,'core::TCPSession::onBlockReceived(coreutils::ZString &block)']]], + ['onconnected_118',['onConnected',['../classcore_1_1TCPSession.html#a8719952f7bb00bf7239ec40aa2868626',1,'core::TCPSession::onConnected()'],['../classcore_1_1TCPSession2.html#af1913cb444a9e07c0f31a2cd8d934a62',1,'core::TCPSession2::onConnected()']]], + ['ondatareceived_119',['onDataReceived',['../classcore_1_1Socket.html#ac8d6a2c54696eb6fc2024cf6bcf6b4e5',1,'core::Socket::onDataReceived()'],['../classcore_1_1TCPServer.html#a276ccbc8cb9b4380ebd78807b97f0159',1,'core::TCPServer::onDataReceived()'],['../classcore_1_1TCPSession.html#afc2d2a92bc65e1e5122a93d120253a1d',1,'core::TCPSession::onDataReceived()'],['../classcore_1_1TCPSession2.html#a67c473e1a22b10fc100ae54206f7471b',1,'core::TCPSession2::onDataReceived()'],['../classcore_1_1UDPServerSocket.html#a41933ca153c854a800e3d047ab18313e',1,'core::UDPServerSocket::onDataReceived()']]], + ['onlinereceived_120',['onLineReceived',['../classcore_1_1TCPSession.html#a3d9e0f14e7d24357fd1950b3f9b4eaff',1,'core::TCPSession::onLineReceived()'],['../classcore_1_1TCPSession2.html#a6cd36b444d9548d1024190c6ba747e18',1,'core::TCPSession2::onLineReceived()']]], + ['onregister_121',['onRegister',['../classcore_1_1TLSSession.html#a76cec7cf4851eb27abe77a2339344c6d',1,'core::TLSSession::onRegister()'],['../classcore_1_1Socket.html#a81e5ee3e17834166d97c6e8b7dfe0da0',1,'core::Socket::onRegister()']]], + ['onregistered_122',['onRegistered',['../classcore_1_1Socket.html#a23b9824653bbe4652a716acb828665b1',1,'core::Socket::onRegistered()'],['../classcore_1_1TCPSession.html#aed4ed499b978bcea57a8efefe929fc98',1,'core::TCPSession::onRegistered()'],['../classcore_1_1TCPSession2.html#a76096659b82c5dcbf6eac1d916511e60',1,'core::TCPSession2::onRegistered()'],['../classcore_1_1TLSSession.html#a8e26fdc9e8a6c573b5a504a1f1b137a9',1,'core::TLSSession::onRegistered()']]], + ['ontimeout_123',['onTimeout',['../classcore_1_1Timer.html#ae51704ff08d985bbc30e3ff4c9b3c6ca',1,'core::Timer']]], + ['onunregistered_124',['onUnregistered',['../classcore_1_1Socket.html#ae9be59697c2b2e5efb19aaae3ba943d2',1,'core::Socket']]], + ['output_125',['output',['../classcore_1_1Command.html#ab6352ce5650e70a5c76c3d6e4eefd292',1,'core::Command::output()'],['../classcore_1_1TCPServer.html#a49e3ead1bf4e7830685780e73c4db5db',1,'core::TCPServer::output()'],['../classcore_1_1TCPSession.html#a50037cbfc515650e04054e5481785981',1,'core::TCPSession::output()'],['../classcore_1_1TCPSession2.html#ae7648a7759570a00d3d4a8c169183291',1,'core::TCPSession2::output()'],['../classcore_1_1TCPSocket.html#afacf7528ff3c9ac077d7b5a49e2116fd',1,'core::TCPSocket::output()'],['../classcore_1_1TLSSession.html#ae55de8a035d1ddc560cf619b2030af43',1,'core::TLSSession::output()']]] ]; diff --git a/html/search/functions_6.js b/html/search/functions_6.js index c2a32b3..5a9fc7f 100644 --- a/html/search/functions_6.js +++ b/html/search/functions_6.js @@ -1,6 +1,6 @@ var searchData= [ - ['processcommand_124',['processCommand',['../classcore_1_1Command.html#a95176f2532c38ee14e3fee40ee28b1bd',1,'core::Command::processCommand()'],['../classcore_1_1CommandList.html#a1819e1cb377b5d8e5e00b4777e2b4aba',1,'core::CommandList::processCommand()'],['../classcore_1_1EPoll.html#a22b5f1545aff3162040844be043abcce',1,'core::EPoll::processCommand()'],['../classcore_1_1SubscriptionManager.html#aaa30bf772ad72b3f319a790662e4f8ae',1,'core::SubscriptionManager::processCommand()'],['../classcore_1_1TCPServer.html#a6b7a7e1ac4132942fcaf418ed41c1437',1,'core::TCPServer::processCommand()']]], - ['processrequest_125',['processRequest',['../classcore_1_1CommandList.html#abcfb26e37e1ee6ff5655ebc3d33b1818',1,'core::CommandList']]], - ['protocol_126',['protocol',['../classcore_1_1ConsoleSession.html#aa1818efcd33a4152d2089aa545f08833',1,'core::ConsoleSession::protocol()'],['../classcore_1_1TCPSession.html#a98a65da2346b79bee659fca6902e94c7',1,'core::TCPSession::protocol()'],['../classcore_1_1TCPSession2.html#a45df5db21355bf7d3585d68789b371ce',1,'core::TCPSession2::protocol()'],['../classcore_1_1TLSSession.html#a208145cc1fcdc14054602aacc2c51d91',1,'core::TLSSession::protocol()']]] + ['processcommand_126',['processCommand',['../classcore_1_1Command.html#a95176f2532c38ee14e3fee40ee28b1bd',1,'core::Command::processCommand()'],['../classcore_1_1CommandList.html#a1819e1cb377b5d8e5e00b4777e2b4aba',1,'core::CommandList::processCommand()'],['../classcore_1_1EPoll.html#a22b5f1545aff3162040844be043abcce',1,'core::EPoll::processCommand()'],['../classcore_1_1SubscriptionManager.html#aaa30bf772ad72b3f319a790662e4f8ae',1,'core::SubscriptionManager::processCommand()'],['../classcore_1_1TCPServer.html#a6b7a7e1ac4132942fcaf418ed41c1437',1,'core::TCPServer::processCommand()']]], + ['processrequest_127',['processRequest',['../classcore_1_1CommandList.html#abcfb26e37e1ee6ff5655ebc3d33b1818',1,'core::CommandList']]], + ['protocol_128',['protocol',['../classcore_1_1ConsoleSession.html#aa1818efcd33a4152d2089aa545f08833',1,'core::ConsoleSession::protocol()'],['../classcore_1_1TCPSession.html#a98a65da2346b79bee659fca6902e94c7',1,'core::TCPSession::protocol()'],['../classcore_1_1TCPSession2.html#a45df5db21355bf7d3585d68789b371ce',1,'core::TCPSession2::protocol()'],['../classcore_1_1TLSSession.html#a208145cc1fcdc14054602aacc2c51d91',1,'core::TLSSession::protocol()']]] ]; diff --git a/html/search/functions_7.js b/html/search/functions_7.js index 80d4fce..1c495a2 100644 --- a/html/search/functions_7.js +++ b/html/search/functions_7.js @@ -1,6 +1,6 @@ var searchData= [ - ['receivedata_127',['receiveData',['../classcore_1_1Socket.html#a46ed2e240852d3fa949979ebbc4ac875',1,'core::Socket::receiveData()'],['../classcore_1_1TLSSession.html#a8507cdcd23ac4b340ce6f6d5f0b26a52',1,'core::TLSSession::receiveData()']]], - ['registersocket_128',['registerSocket',['../classcore_1_1EPoll.html#a3d813c7bbf0da70ebc8e3cb6aeeacfb4',1,'core::EPoll']]], - ['remove_129',['remove',['../classcore_1_1CommandList.html#aaac684effb9ecf5238d23ca60d3fffaa',1,'core::CommandList']]] + ['receivedata_129',['receiveData',['../classcore_1_1Socket.html#a46ed2e240852d3fa949979ebbc4ac875',1,'core::Socket::receiveData()'],['../classcore_1_1TLSSession.html#a8507cdcd23ac4b340ce6f6d5f0b26a52',1,'core::TLSSession::receiveData()']]], + ['registersocket_130',['registerSocket',['../classcore_1_1EPoll.html#a3d813c7bbf0da70ebc8e3cb6aeeacfb4',1,'core::EPoll']]], + ['remove_131',['remove',['../classcore_1_1CommandList.html#aaac684effb9ecf5238d23ca60d3fffaa',1,'core::CommandList']]] ]; diff --git a/html/search/functions_8.js b/html/search/functions_8.js index ceda823..ca6eedb 100644 --- a/html/search/functions_8.js +++ b/html/search/functions_8.js @@ -1,13 +1,13 @@ var searchData= [ - ['send_130',['send',['../classcore_1_1TCPSession.html#a2b09eeafef5e44009a77d9da43e3b889',1,'core::TCPSession::send()'],['../classcore_1_1TCPSession2.html#aca2f7127b4081fa0e2d2d128083fb0f7',1,'core::TCPSession2::send()']]], - ['sendtoall_131',['sendToAll',['../classcore_1_1TCPServer.html#a7080f7d45e734087e81b83c5e1f8e676',1,'core::TCPServer::sendToAll(std::stringstream &out, TCPSession &sender, SessionFilter filter)'],['../classcore_1_1TCPServer.html#af708df59e1bc60077c16db97f9cc8ff0',1,'core::TCPServer::sendToAll(std::stringstream &out, TCPSession &sender)']]], - ['setblocksize_132',['setBlockSize',['../classcore_1_1TCPSession.html#a836fb3fd5ee543ebc93262a980ae88b5',1,'core::TCPSession::setBlockSize()'],['../classcore_1_1TCPSession2.html#a6f4ed04cd2848e5b903b8331b2e951c8',1,'core::TCPSession2::setBlockSize()']]], - ['setcursorlocation_133',['setCursorLocation',['../classcore_1_1TerminalSession.html#aa9939cbe36c08e1a0b8413a96ca251fa',1,'core::TerminalSession']]], - ['setdescriptor_134',['setDescriptor',['../classcore_1_1Socket.html#ac44f6ae3196a8a3e09a6a85fcf495762',1,'core::Socket']]], - ['settimer_135',['setTimer',['../classcore_1_1Timer.html#ac0a642cdcb76b7f995137162050d3d0b',1,'core::Timer']]], - ['shutdown_136',['shutdown',['../classcore_1_1Socket.html#af2d1b6de7a64a9d446b0305b6ec47b31',1,'core::Socket']]], - ['socket_137',['Socket',['../classcore_1_1Socket.html#a4c3f87fd1de3c9eab4bf5efbb30ce87d',1,'core::Socket']]], - ['start_138',['start',['../classcore_1_1EPoll.html#aaefe2caef75eb538af90cb34682d277b',1,'core::EPoll::start()'],['../classcore_1_1Thread.html#ae6885df9a9b9503669e5776518b19054',1,'core::Thread::start()']]], - ['stop_139',['stop',['../classcore_1_1EPoll.html#a0c2865acd31d14fbf19dbc42cc084ddc',1,'core::EPoll']]] + ['send_132',['send',['../classcore_1_1TCPSession.html#a2b09eeafef5e44009a77d9da43e3b889',1,'core::TCPSession::send()'],['../classcore_1_1TCPSession2.html#aca2f7127b4081fa0e2d2d128083fb0f7',1,'core::TCPSession2::send()']]], + ['sendtoall_133',['sendToAll',['../classcore_1_1TCPServer.html#a7080f7d45e734087e81b83c5e1f8e676',1,'core::TCPServer::sendToAll(std::stringstream &out, TCPSession &sender, SessionFilter filter)'],['../classcore_1_1TCPServer.html#af708df59e1bc60077c16db97f9cc8ff0',1,'core::TCPServer::sendToAll(std::stringstream &out, TCPSession &sender)']]], + ['setblocksize_134',['setBlockSize',['../classcore_1_1TCPSession.html#a836fb3fd5ee543ebc93262a980ae88b5',1,'core::TCPSession::setBlockSize()'],['../classcore_1_1TCPSession2.html#a6f4ed04cd2848e5b903b8331b2e951c8',1,'core::TCPSession2::setBlockSize()']]], + ['setcursorlocation_135',['setCursorLocation',['../classcore_1_1TerminalSession.html#aa9939cbe36c08e1a0b8413a96ca251fa',1,'core::TerminalSession']]], + ['setdescriptor_136',['setDescriptor',['../classcore_1_1Socket.html#ac44f6ae3196a8a3e09a6a85fcf495762',1,'core::Socket']]], + ['settimer_137',['setTimer',['../classcore_1_1Timer.html#ac0a642cdcb76b7f995137162050d3d0b',1,'core::Timer']]], + ['shutdown_138',['shutdown',['../classcore_1_1Socket.html#af2d1b6de7a64a9d446b0305b6ec47b31',1,'core::Socket']]], + ['socket_139',['Socket',['../classcore_1_1Socket.html#a4c3f87fd1de3c9eab4bf5efbb30ce87d',1,'core::Socket']]], + ['start_140',['start',['../classcore_1_1EPoll.html#aaefe2caef75eb538af90cb34682d277b',1,'core::EPoll::start()'],['../classcore_1_1Thread.html#ae6885df9a9b9503669e5776518b19054',1,'core::Thread::start()']]], + ['stop_141',['stop',['../classcore_1_1EPoll.html#a0c2865acd31d14fbf19dbc42cc084ddc',1,'core::EPoll']]] ]; diff --git a/html/search/functions_9.js b/html/search/functions_9.js index 34795bb..731c62b 100644 --- a/html/search/functions_9.js +++ b/html/search/functions_9.js @@ -1,6 +1,6 @@ var searchData= [ - ['tcpserver_140',['TCPServer',['../classcore_1_1TCPServer.html#abaecb97c336b757d1029d45277f9fc5b',1,'core::TCPServer']]], - ['terminate_141',['terminate',['../classcore_1_1TCPSession.html#a34936745e8d7669d5400e78d353a56d3',1,'core::TCPSession::terminate()'],['../classcore_1_1TCPSession2.html#a6b999e7ea6551a1b513ee057afaa9e4a',1,'core::TCPSession2::terminate()']]], - ['tlsserver_142',['TLSServer',['../classcore_1_1TLSServer.html#a6460f9872936015efdfd0b8de04aa2fe',1,'core::TLSServer']]] + ['tcpserver_142',['TCPServer',['../classcore_1_1TCPServer.html#abaecb97c336b757d1029d45277f9fc5b',1,'core::TCPServer']]], + ['terminate_143',['terminate',['../classcore_1_1TCPSession.html#a34936745e8d7669d5400e78d353a56d3',1,'core::TCPSession::terminate()'],['../classcore_1_1TCPSession2.html#a6b999e7ea6551a1b513ee057afaa9e4a',1,'core::TCPSession2::terminate()']]], + ['tlsserver_144',['TLSServer',['../classcore_1_1TLSServer.html#a6460f9872936015efdfd0b8de04aa2fe',1,'core::TLSServer']]] ]; diff --git a/html/search/functions_a.js b/html/search/functions_a.js index b864a38..c15d2e3 100644 --- a/html/search/functions_a.js +++ b/html/search/functions_a.js @@ -1,4 +1,4 @@ var searchData= [ - ['unregistersocket_143',['unregisterSocket',['../classcore_1_1EPoll.html#a5ab5e82ab51e0952fc8fbcc128f52900',1,'core::EPoll']]] + ['unregistersocket_145',['unregisterSocket',['../classcore_1_1EPoll.html#a5ab5e82ab51e0952fc8fbcc128f52900',1,'core::EPoll']]] ]; diff --git a/html/search/functions_b.js b/html/search/functions_b.js index d2df662..a733b17 100644 --- a/html/search/functions_b.js +++ b/html/search/functions_b.js @@ -1,4 +1,4 @@ var searchData= [ - ['write_144',['write',['../classcore_1_1Socket.html#a1413c826307ef0f29d7457770af675e3',1,'core::Socket']]] + ['write_146',['write',['../classcore_1_1Socket.html#a1413c826307ef0f29d7457770af675e3',1,'core::Socket']]] ]; diff --git a/html/search/functions_c.js b/html/search/functions_c.js index e2d29ab..12d3f0e 100644 --- a/html/search/functions_c.js +++ b/html/search/functions_c.js @@ -1,7 +1,7 @@ var searchData= [ - ['_7eepoll_145',['~EPoll',['../classcore_1_1EPoll.html#a8e7a2496d684b745a6410f9bd3e88534',1,'core::EPoll']]], - ['_7esocket_146',['~Socket',['../classcore_1_1Socket.html#aa5003845f8ae464ad2fa206176381be0',1,'core::Socket']]], - ['_7etcpserver_147',['~TCPServer',['../classcore_1_1TCPServer.html#a7ccdc057c9eee8504fce796301f82088',1,'core::TCPServer']]], - ['_7etlsserver_148',['~TLSServer',['../classcore_1_1TLSServer.html#ac71db77c796a1bf65357409cb96054c7',1,'core::TLSServer']]] + ['_7eepoll_147',['~EPoll',['../classcore_1_1EPoll.html#a8e7a2496d684b745a6410f9bd3e88534',1,'core::EPoll']]], + ['_7esocket_148',['~Socket',['../classcore_1_1Socket.html#aa5003845f8ae464ad2fa206176381be0',1,'core::Socket']]], + ['_7etcpserver_149',['~TCPServer',['../classcore_1_1TCPServer.html#a7ccdc057c9eee8504fce796301f82088',1,'core::TCPServer']]], + ['_7etlsserver_150',['~TLSServer',['../classcore_1_1TLSServer.html#ac71db77c796a1bf65357409cb96054c7',1,'core::TLSServer']]] ]; diff --git a/html/search/variables_0.js b/html/search/variables_0.js index 8073e21..bbdc512 100644 --- a/html/search/variables_0.js +++ b/html/search/variables_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['blacklist_149',['blackList',['../classcore_1_1TCPServer.html#a82f6bf16e4ab20d8b30da09e034fffff',1,'core::TCPServer']]] + ['blacklist_151',['blackList',['../classcore_1_1TCPServer.html#a82f6bf16e4ab20d8b30da09e034fffff',1,'core::TCPServer']]] ]; diff --git a/html/search/variables_1.js b/html/search/variables_1.js index d79213f..a2cbace 100644 --- a/html/search/variables_1.js +++ b/html/search/variables_1.js @@ -1,4 +1,4 @@ var searchData= [ - ['commands_150',['commands',['../classcore_1_1CommandList.html#ad0aedf95828fe743908d8423f171ff36',1,'core::CommandList::commands()'],['../classcore_1_1TCPServer.html#afcc44802b988e2f4292504e804dccf8b',1,'core::TCPServer::commands()']]] + ['commands_152',['commands',['../classcore_1_1CommandList.html#ad0aedf95828fe743908d8423f171ff36',1,'core::CommandList::commands()'],['../classcore_1_1TCPServer.html#afcc44802b988e2f4292504e804dccf8b',1,'core::TCPServer::commands()']]] ]; diff --git a/html/search/variables_2.js b/html/search/variables_2.js index ff48095..e0c2e5b 100644 --- a/html/search/variables_2.js +++ b/html/search/variables_2.js @@ -1,4 +1,4 @@ var searchData= [ - ['maxsockets_151',['maxSockets',['../classcore_1_1EPoll.html#acfcef2513d94f7b9a191fed3dc744d90',1,'core::EPoll']]] + ['maxsockets_153',['maxSockets',['../classcore_1_1EPoll.html#acfcef2513d94f7b9a191fed3dc744d90',1,'core::EPoll']]] ]; diff --git a/html/search/variables_3.js b/html/search/variables_3.js index f0c5718..89d739b 100644 --- a/html/search/variables_3.js +++ b/html/search/variables_3.js @@ -1,4 +1,4 @@ var searchData= [ - ['out_152',['out',['../classcore_1_1TCPSession.html#abb302bbb3d7e7bc75490c736364f0d4d',1,'core::TCPSession::out()'],['../classcore_1_1TCPSession2.html#a6b8005e611b6007a00ad3288973a522d',1,'core::TCPSession2::out()']]] + ['out_154',['out',['../classcore_1_1TCPSession.html#abb302bbb3d7e7bc75490c736364f0d4d',1,'core::TCPSession::out()'],['../classcore_1_1TCPSession2.html#a6b8005e611b6007a00ad3288973a522d',1,'core::TCPSession2::out()']]] ]; diff --git a/html/search/variables_4.js b/html/search/variables_4.js index 820fa2d..b5b7456 100644 --- a/html/search/variables_4.js +++ b/html/search/variables_4.js @@ -1,5 +1,5 @@ var searchData= [ - ['sessions_153',['sessions',['../classcore_1_1TCPServer.html#aeed1bc55d099667ccda51cd682bfc633',1,'core::TCPServer']]], - ['subscriptions_154',['subscriptions',['../classcore_1_1TCPServer.html#a28302dd844cfc971ee41de2000d24aa0',1,'core::TCPServer']]] + ['sessions_155',['sessions',['../classcore_1_1TCPServer.html#aeed1bc55d099667ccda51cd682bfc633',1,'core::TCPServer']]], + ['subscriptions_156',['subscriptions',['../classcore_1_1TCPServer.html#a28302dd844cfc971ee41de2000d24aa0',1,'core::TCPServer']]] ]; diff --git a/html/search/variables_5.js b/html/search/variables_5.js index d255991..360a04d 100644 --- a/html/search/variables_5.js +++ b/html/search/variables_5.js @@ -1,4 +1,4 @@ var searchData= [ - ['whitelist_155',['whiteList',['../classcore_1_1TCPServer.html#abad6300b6234ca8b69cef9128755342e',1,'core::TCPServer']]] + ['whitelist_157',['whiteList',['../classcore_1_1TCPServer.html#abad6300b6234ca8b69cef9128755342e',1,'core::TCPServer']]] ]; diff --git a/latex/annotated.tex b/latex/annotated.tex index 35b1b42..a64fb49 100644 --- a/latex/annotated.tex +++ b/latex/annotated.tex @@ -12,6 +12,7 @@ Here are the classes, structs, unions and interfaces with brief descriptions\+:\ \item\contentsline{section}{\mbox{\hyperlink{classcore_1_1SessionFilter}{core\+::\+Session\+Filter}} }{\pageref{classcore_1_1SessionFilter}}{} \item\contentsline{section}{\mbox{\hyperlink{classcore_1_1Socket}{core\+::\+Socket}} }{\pageref{classcore_1_1Socket}}{} \item\contentsline{section}{\mbox{\hyperlink{classcore_1_1Subscription}{core\+::\+Subscription}} }{\pageref{classcore_1_1Subscription}}{} +\item\contentsline{section}{\mbox{\hyperlink{classcore_1_1SubscriptionHandler}{core\+::\+Subscription\+Handler}} }{\pageref{classcore_1_1SubscriptionHandler}}{} \item\contentsline{section}{\mbox{\hyperlink{classcore_1_1SubscriptionManager}{core\+::\+Subscription\+Manager}} }{\pageref{classcore_1_1SubscriptionManager}}{} \item\contentsline{section}{\mbox{\hyperlink{classcore_1_1TCPServer}{core\+::\+TCPServer}} }{\pageref{classcore_1_1TCPServer}}{} \item\contentsline{section}{\mbox{\hyperlink{classcore_1_1TCPSession}{core\+::\+TCPSession}} }{\pageref{classcore_1_1TCPSession}}{} diff --git a/latex/classcore_1_1Subscription.tex b/latex/classcore_1_1Subscription.tex index cddcce1..718aec4 100644 --- a/latex/classcore_1_1Subscription.tex +++ b/latex/classcore_1_1Subscription.tex @@ -2,7 +2,8 @@ \label{classcore_1_1Subscription}\index{core::Subscription@{core::Subscription}} -Collaboration diagram for core\+::Subscription\+:\nopagebreak +Collaboration diagram for core\+::Subscription\+: +\nopagebreak \begin{figure}[H] \begin{center} \leavevmode @@ -15,8 +16,11 @@ Collaboration diagram for core\+::Subscription\+:\nopagebreak \mbox{\Hypertarget{classcore_1_1Subscription_a348a4ec8232ada37f5be2b6f756f01f3}\label{classcore_1_1Subscription_a348a4ec8232ada37f5be2b6f756f01f3}} {\bfseries Subscription} (std\+::string id, std\+::string mode=\char`\"{}$\ast$AUTHOR\char`\"{}) \item -\mbox{\Hypertarget{classcore_1_1Subscription_a75e36b110e87138d4f5d8f0cbbaca4c1}\label{classcore_1_1Subscription_a75e36b110e87138d4f5d8f0cbbaca4c1}} -{\bfseries Subscription} (std\+::string id, \mbox{\hyperlink{classcore_1_1TCPSession}{TCPSession}} \&session, std\+::string mode=\char`\"{}$\ast$AUTHOR\char`\"{}) +\mbox{\Hypertarget{classcore_1_1Subscription_a1b993509cd113d8ed564d710955c94a0}\label{classcore_1_1Subscription_a1b993509cd113d8ed564d710955c94a0}} +{\bfseries Subscription} (std\+::string id, \mbox{\hyperlink{classcore_1_1TCPSession}{TCPSession}} \&session, std\+::string mode) +\item +\mbox{\Hypertarget{classcore_1_1Subscription_ae21b7a4a1084da8959cd8022fa138c0e}\label{classcore_1_1Subscription_ae21b7a4a1084da8959cd8022fa138c0e}} +{\bfseries Subscription} (std\+::string id, \mbox{\hyperlink{classcore_1_1TCPSession}{TCPSession}} \&session, std\+::string mode, \mbox{\hyperlink{classcore_1_1SubscriptionHandler}{Subscription\+Handler}} $\ast$handler) \item \mbox{\Hypertarget{classcore_1_1Subscription_a57c23d7c49328eecf8358f84b485f7cb}\label{classcore_1_1Subscription_a57c23d7c49328eecf8358f84b485f7cb}} int {\bfseries subscribe} (\mbox{\hyperlink{classcore_1_1TCPSession}{TCPSession}} \&session) @@ -48,6 +52,9 @@ std\+::string {\bfseries mode} \mbox{\Hypertarget{classcore_1_1Subscription_a5526427600aa4a5b180f76f201e85f58}\label{classcore_1_1Subscription_a5526427600aa4a5b180f76f201e85f58}} \mbox{\hyperlink{classcore_1_1TCPSession}{TCPSession}} $\ast$ {\bfseries owner} \item +\mbox{\Hypertarget{classcore_1_1Subscription_ab4f020e6bdee846121f508fcdb6f7aeb}\label{classcore_1_1Subscription_ab4f020e6bdee846121f508fcdb6f7aeb}} +\mbox{\hyperlink{classcore_1_1SubscriptionHandler}{Subscription\+Handler}} $\ast$ {\bfseries handler} +\item \mbox{\Hypertarget{classcore_1_1Subscription_ad1a5c1a3e5a6e253eb34795f43d4f9be}\label{classcore_1_1Subscription_ad1a5c1a3e5a6e253eb34795f43d4f9be}} std\+::vector$<$ \mbox{\hyperlink{classcore_1_1TCPSession}{TCPSession}} $\ast$ $>$ {\bfseries subscribers} \end{DoxyCompactItemize} diff --git a/latex/classcore_1_1SubscriptionHandler.tex b/latex/classcore_1_1SubscriptionHandler.tex new file mode 100644 index 0000000..5d0b0f4 --- /dev/null +++ b/latex/classcore_1_1SubscriptionHandler.tex @@ -0,0 +1,16 @@ +\hypertarget{classcore_1_1SubscriptionHandler}{}\doxysection{core\+::Subscription\+Handler Class Reference} +\label{classcore_1_1SubscriptionHandler}\index{core::SubscriptionHandler@{core::SubscriptionHandler}} +\doxysubsection*{Public Member Functions} +\begin{DoxyCompactItemize} +\item +\mbox{\Hypertarget{classcore_1_1SubscriptionHandler_a652ee5183fda91877b274617d585a28b}\label{classcore_1_1SubscriptionHandler_a652ee5183fda91877b274617d585a28b}} +virtual int {\bfseries process} (coreutils\+::\+ZString \&request, std\+::stringstream \&out, \mbox{\hyperlink{classcore_1_1TCPSession}{TCPSession}} \&session) +\item +\mbox{\Hypertarget{classcore_1_1SubscriptionHandler_ac969757e0ea9552e505eb483ea30a8a0}\label{classcore_1_1SubscriptionHandler_ac969757e0ea9552e505eb483ea30a8a0}} +virtual int {\bfseries on\+Subscribe} (\mbox{\hyperlink{classcore_1_1TCPSession}{TCPSession}} \&session) +\end{DoxyCompactItemize} + + +The documentation for this class was generated from the following file\+:\begin{DoxyCompactItemize} +\item +Subscription\+Handler.\+h\end{DoxyCompactItemize} diff --git a/latex/classcore_1_1SubscriptionManager.tex b/latex/classcore_1_1SubscriptionManager.tex index 321cb86..9018bbc 100644 --- a/latex/classcore_1_1SubscriptionManager.tex +++ b/latex/classcore_1_1SubscriptionManager.tex @@ -24,6 +24,9 @@ Collaboration diagram for core\+::Subscription\+Manager\+:\nopagebreak \mbox{\Hypertarget{classcore_1_1SubscriptionManager_ad1a021be5d55d1e9f0944c97f79ae9e2}\label{classcore_1_1SubscriptionManager_ad1a021be5d55d1e9f0944c97f79ae9e2}} int {\bfseries add} (\mbox{\hyperlink{classcore_1_1Subscription}{Subscription}} \&subscription) \item +\mbox{\Hypertarget{classcore_1_1SubscriptionManager_af5a8acc8762c035e90e18c61574fb798}\label{classcore_1_1SubscriptionManager_af5a8acc8762c035e90e18c61574fb798}} +int {\bfseries add\+Handler} (std\+::string name, \mbox{\hyperlink{classcore_1_1SubscriptionHandler}{Subscription\+Handler}} $\ast$handler) +\item \mbox{\Hypertarget{classcore_1_1SubscriptionManager_aed407c183c390f4459bb6527b30c8198}\label{classcore_1_1SubscriptionManager_aed407c183c390f4459bb6527b30c8198}} int {\bfseries remove\+Session\+Subscriptions} (\mbox{\hyperlink{classcore_1_1TCPSession}{TCPSession}} \&session) \item diff --git a/latex/classcore_1_1Subscription__coll__graph.md5 b/latex/classcore_1_1Subscription__coll__graph.md5 index 59c55fd..b62f218 100644 --- a/latex/classcore_1_1Subscription__coll__graph.md5 +++ b/latex/classcore_1_1Subscription__coll__graph.md5 @@ -1 +1 @@ -2729f4733c58f8e25137c8d4e188b60b \ No newline at end of file +5d837105a904709e1aad4a643144222e \ No newline at end of file diff --git a/latex/classcore_1_1Subscription__coll__graph.pdf b/latex/classcore_1_1Subscription__coll__graph.pdf index 33d7f0b..837981e 100644 Binary files a/latex/classcore_1_1Subscription__coll__graph.pdf and b/latex/classcore_1_1Subscription__coll__graph.pdf differ diff --git a/latex/hierarchy.tex b/latex/hierarchy.tex index 51a5a07..ee601b4 100644 --- a/latex/hierarchy.tex +++ b/latex/hierarchy.tex @@ -45,5 +45,6 @@ This inheritance list is sorted roughly, but not completely, alphabetically\+:\b \end{DoxyCompactList} \end{DoxyCompactList} \item \contentsline{section}{core\+::Subscription}{\pageref{classcore_1_1Subscription}}{} +\item \contentsline{section}{core\+::Subscription\+Handler}{\pageref{classcore_1_1SubscriptionHandler}}{} \item \contentsline{section}{core\+::Thread\+Scope}{\pageref{classcore_1_1ThreadScope}}{} \end{DoxyCompactList} diff --git a/latex/refman.tex b/latex/refman.tex index 30d4715..b660669 100644 --- a/latex/refman.tex +++ b/latex/refman.tex @@ -188,6 +188,7 @@ \input{classcore_1_1SessionFilter} \input{classcore_1_1Socket} \input{classcore_1_1Subscription} +\input{classcore_1_1SubscriptionHandler} \input{classcore_1_1SubscriptionManager} \input{classcore_1_1TCPServer} \input{classcore_1_1TCPSession} diff --git a/output/main b/output/main index 71318cc..89da3b0 100755 Binary files a/output/main and b/output/main differ