From 69dcbae4284bff85bedc525586eacb5de4009b3d Mon Sep 17 00:00:00 2001 From: Brad Date: Thu, 13 Oct 2022 17:50:13 +0000 Subject: [PATCH 1/2] output/main and cpp sproperties. --- .vscode/c_cpp_properties.json | 2 +- output/main | Bin 106576 -> 33272 bytes 2 files changed, 1 insertion(+), 1 deletion(-) 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/output/main b/output/main index 71318ccd0a992ac70416356d3e4622123bf3d84d..89da3b05b6af1e05a2997300b9368c772d0ff315 100755 GIT binary patch literal 33272 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 literal 106576 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 Yf3NU|>=yIY_y5S=`D@vL?9b}|0E7n@n*aa+ From 001cd8c06cd8bc9c2777a3de59a1446374a2f57c Mon Sep 17 00:00:00 2001 From: Brad Date: Tue, 18 Oct 2022 02:37:46 +0000 Subject: [PATCH 2/2] Added SubscriptionHandler capability to Subscriptions. --- .../SubscriptionHandler_20221013185305.cpp | 68 ++++++++ .history/SubscriptionHandler_20221013191001.h | 24 +++ .history/SubscriptionHandler_20221013204338.h | 23 +++ .../SubscriptionHandler_20221013204409.cpp | 68 ++++++++ .history/SubscriptionHandler_20221013204504.h | 23 +++ .../SubscriptionHandler_20221013204612.cpp | 68 ++++++++ .history/SubscriptionHandler_20221014152050.h | 22 +++ .history/SubscriptionHandler_20221014152131.h | 22 +++ .history/SubscriptionHandler_20221014152241.h | 22 +++ .history/SubscriptionHandler_20221014152252.h | 22 +++ .history/SubscriptionHandler_20221014152513.h | 22 +++ .history/SubscriptionHandler_20221014153238.h | 23 +++ .history/SubscriptionManager_20221013225816.h | 33 ++++ .../SubscriptionManager_20221013230931.cpp | 100 ++++++++++++ .../SubscriptionManager_20221013231054.cpp | 127 +++++++++++++++ .history/SubscriptionManager_20221013231834.h | 34 ++++ .history/SubscriptionManager_20221013232252.h | 34 ++++ .history/SubscriptionManager_20221013232501.h | 34 ++++ .history/SubscriptionManager_20221013232513.h | 34 ++++ .history/SubscriptionManager_20221013232519.h | 34 ++++ .../SubscriptionManager_20221013232529.cpp | 127 +++++++++++++++ .../SubscriptionManager_20221013232559.cpp | 128 +++++++++++++++ .../SubscriptionManager_20221013232603.cpp | 128 +++++++++++++++ .../SubscriptionManager_20221013232637.cpp | 128 +++++++++++++++ .../SubscriptionManager_20221013232709.cpp | 128 +++++++++++++++ .../SubscriptionManager_20221013232718.cpp | 127 +++++++++++++++ .../SubscriptionManager_20221014001552.cpp | 141 +++++++++++++++++ .../SubscriptionManager_20221014001640.cpp | 141 +++++++++++++++++ .../SubscriptionManager_20221014001750.cpp | 141 +++++++++++++++++ .../SubscriptionManager_20221014001801.cpp | 141 +++++++++++++++++ .../SubscriptionManager_20221014001829.cpp | 141 +++++++++++++++++ .../SubscriptionManager_20221014001848.cpp | 141 +++++++++++++++++ .../SubscriptionManager_20221014002019.cpp | 141 +++++++++++++++++ .../SubscriptionManager_20221014002052.cpp | 141 +++++++++++++++++ .../SubscriptionManager_20221014002112.cpp | 141 +++++++++++++++++ .../SubscriptionManager_20221014002118.cpp | 141 +++++++++++++++++ .../SubscriptionManager_20221014002130.cpp | 141 +++++++++++++++++ .../SubscriptionManager_20221014002136.cpp | 141 +++++++++++++++++ .../SubscriptionManager_20221014002203.cpp | 142 +++++++++++++++++ .../SubscriptionManager_20221014002300.cpp | 142 +++++++++++++++++ .../SubscriptionManager_20221014002351.cpp | 142 +++++++++++++++++ .../SubscriptionManager_20221014002355.cpp | 142 +++++++++++++++++ .../SubscriptionManager_20221014002404.cpp | 142 +++++++++++++++++ .../SubscriptionManager_20221014002416.cpp | 142 +++++++++++++++++ .../SubscriptionManager_20221014002543.cpp | 142 +++++++++++++++++ .../SubscriptionManager_20221014002547.cpp | 142 +++++++++++++++++ .../SubscriptionManager_20221014002751.cpp | 142 +++++++++++++++++ .../SubscriptionManager_20221014002909.cpp | 142 +++++++++++++++++ .../SubscriptionManager_20221014002931.cpp | 142 +++++++++++++++++ .../SubscriptionManager_20221014002952.cpp | 141 +++++++++++++++++ .../SubscriptionManager_20221014003012.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221014003016.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221014003032.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221014003110.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221014003112.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221014003118.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221014003740.cpp | 142 +++++++++++++++++ .../SubscriptionManager_20221014003842.cpp | 142 +++++++++++++++++ .../SubscriptionManager_20221014224510.cpp | 142 +++++++++++++++++ .../SubscriptionManager_20221015132404.cpp | 142 +++++++++++++++++ .../SubscriptionManager_20221015135839.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221015140050.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221015140147.cpp | 146 +++++++++++++++++ .history/SubscriptionManager_20221015140418.h | 37 +++++ .../SubscriptionManager_20221015140432.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221015140547.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221015140637.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221015140703.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221015140849.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221015140915.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221015141339.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221015141418.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221015141638.cpp | 147 +++++++++++++++++ .../SubscriptionManager_20221015180125.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221015181249.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221015181639.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221015181912.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221015182122.cpp | 143 +++++++++++++++++ .../SubscriptionManager_20221015183109.cpp | 143 +++++++++++++++++ .../SubscriptionManager_20221015183204.cpp | 144 +++++++++++++++++ .../SubscriptionManager_20221015183209.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221015183518.cpp | 146 +++++++++++++++++ .../SubscriptionManager_20221015191146.cpp | 147 +++++++++++++++++ .../SubscriptionManager_20221015193901.cpp | 147 +++++++++++++++++ .../SubscriptionManager_20221015200446.cpp | 147 +++++++++++++++++ .../SubscriptionManager_20221015200502.cpp | 147 +++++++++++++++++ .history/SubscriptionManager_20221015201436.h | 38 +++++ .history/SubscriptionManager_20221015201440.h | 38 +++++ .../SubscriptionManager_20221015201500.cpp | 147 +++++++++++++++++ .../SubscriptionManager_20221015201542.cpp | 147 +++++++++++++++++ .../SubscriptionManager_20221015201557.cpp | 147 +++++++++++++++++ .../SubscriptionManager_20221016174159.cpp | 148 ++++++++++++++++++ .../SubscriptionManager_20221016174206.cpp | 148 ++++++++++++++++++ .../SubscriptionManager_20221016175448.cpp | 148 ++++++++++++++++++ .../SubscriptionManager_20221016180238.cpp | 148 ++++++++++++++++++ .history/SubscriptionManager_20221016180248.h | 38 +++++ .history/Subscription_20221013190812.h | 46 ++++++ .history/Subscription_20221013190943.cpp | 75 +++++++++ .history/Subscription_20221013204658.h | 47 ++++++ .history/Subscription_20221013204725.cpp | 76 +++++++++ .history/Subscription_20221013204753.cpp | 76 +++++++++ .history/Subscription_20221013205054.cpp | 76 +++++++++ .history/Subscription_20221014003150.h | 47 ++++++ .history/Subscription_20221014212452.h | 49 ++++++ .history/Subscription_20221014212457.h | 47 ++++++ .history/Subscription_20221014212653.h | 48 ++++++ .history/Subscription_20221014220951.cpp | 76 +++++++++ .history/Subscription_20221015131611.cpp | 76 +++++++++ .history/Subscription_20221015142023.cpp | 79 ++++++++++ .history/Subscription_20221015175629.cpp | 79 ++++++++++ .history/Subscription_20221015182553.h | 49 ++++++ .history/Subscription_20221015182613.h | 49 ++++++ .history/Subscription_20221015182633.cpp | 79 ++++++++++ .history/Subscription_20221015182644.cpp | 79 ++++++++++ .history/Subscription_20221015182655.h | 49 ++++++ .history/Subscription_20221015182706.cpp | 79 ++++++++++ .history/Subscription_20221015182712.cpp | 79 ++++++++++ .history/Subscription_20221015203632.h | 49 ++++++ .history/Subscription_20221015203643.cpp | 79 ++++++++++ .history/Subscription_20221015203655.cpp | 79 ++++++++++ .history/Subscription_20221015203702.cpp | 79 ++++++++++ .history/Subscription_20221015203734.h | 49 ++++++ .history/Subscription_20221015203735.cpp | 79 ++++++++++ .history/Subscription_20221015203805.cpp | 79 ++++++++++ .history/Subscription_20221015204939.cpp | 79 ++++++++++ .history/Subscription_20221016151339.cpp | 79 ++++++++++ .history/Subscription_20221016162014.cpp | 79 ++++++++++ .history/Subscription_20221016172637.cpp | 79 ++++++++++ .history/Subscription_20221016172643.cpp | 79 ++++++++++ .history/Subscription_20221016173312.cpp | 79 ++++++++++ .history/Subscription_20221016173458.cpp | 79 ++++++++++ .history/Subscription_20221016173903.cpp | 79 ++++++++++ .history/Subscription_20221016174406.cpp | 79 ++++++++++ .history/Subscription_20221016174556.cpp | 78 +++++++++ .history/Subscription_20221016174634.cpp | 78 +++++++++ .history/Subscription_20221016174652.cpp | 78 +++++++++ .history/Subscription_20221016174712.cpp | 78 +++++++++ .history/Subscription_20221016174852.h | 49 ++++++ .history/Subscription_20221016174910.h | 49 ++++++ .history/Subscription_20221016174913.h | 49 ++++++ .history/Subscription_20221016174921.cpp | 78 +++++++++ .history/Subscription_20221016174923.cpp | 78 +++++++++ .history/Subscription_20221016175152.cpp | 79 ++++++++++ .history/Subscription_20221016175838.cpp | 80 ++++++++++ .history/Subscription_20221016175855.cpp | 80 ++++++++++ .history/Subscription_20221016175911.cpp | 80 ++++++++++ .history/Subscription_20221016175912.cpp | 80 ++++++++++ Subscription.cpp | 29 +++- Subscription.h | 10 +- SubscriptionHandler.h | 25 +++ SubscriptionManager.cpp | 125 +++++++++------ SubscriptionManager.h | 29 ++-- 152 files changed, 15005 insertions(+), 64 deletions(-) create mode 100644 .history/SubscriptionHandler_20221013185305.cpp create mode 100644 .history/SubscriptionHandler_20221013191001.h create mode 100644 .history/SubscriptionHandler_20221013204338.h create mode 100644 .history/SubscriptionHandler_20221013204409.cpp create mode 100644 .history/SubscriptionHandler_20221013204504.h create mode 100644 .history/SubscriptionHandler_20221013204612.cpp create mode 100644 .history/SubscriptionHandler_20221014152050.h create mode 100644 .history/SubscriptionHandler_20221014152131.h create mode 100644 .history/SubscriptionHandler_20221014152241.h create mode 100644 .history/SubscriptionHandler_20221014152252.h create mode 100644 .history/SubscriptionHandler_20221014152513.h create mode 100644 .history/SubscriptionHandler_20221014153238.h create mode 100644 .history/SubscriptionManager_20221013225816.h create mode 100644 .history/SubscriptionManager_20221013230931.cpp create mode 100644 .history/SubscriptionManager_20221013231054.cpp create mode 100644 .history/SubscriptionManager_20221013231834.h create mode 100644 .history/SubscriptionManager_20221013232252.h create mode 100644 .history/SubscriptionManager_20221013232501.h create mode 100644 .history/SubscriptionManager_20221013232513.h create mode 100644 .history/SubscriptionManager_20221013232519.h create mode 100644 .history/SubscriptionManager_20221013232529.cpp create mode 100644 .history/SubscriptionManager_20221013232559.cpp create mode 100644 .history/SubscriptionManager_20221013232603.cpp create mode 100644 .history/SubscriptionManager_20221013232637.cpp create mode 100644 .history/SubscriptionManager_20221013232709.cpp create mode 100644 .history/SubscriptionManager_20221013232718.cpp create mode 100644 .history/SubscriptionManager_20221014001552.cpp create mode 100644 .history/SubscriptionManager_20221014001640.cpp create mode 100644 .history/SubscriptionManager_20221014001750.cpp create mode 100644 .history/SubscriptionManager_20221014001801.cpp create mode 100644 .history/SubscriptionManager_20221014001829.cpp create mode 100644 .history/SubscriptionManager_20221014001848.cpp create mode 100644 .history/SubscriptionManager_20221014002019.cpp create mode 100644 .history/SubscriptionManager_20221014002052.cpp create mode 100644 .history/SubscriptionManager_20221014002112.cpp create mode 100644 .history/SubscriptionManager_20221014002118.cpp create mode 100644 .history/SubscriptionManager_20221014002130.cpp create mode 100644 .history/SubscriptionManager_20221014002136.cpp create mode 100644 .history/SubscriptionManager_20221014002203.cpp create mode 100644 .history/SubscriptionManager_20221014002300.cpp create mode 100644 .history/SubscriptionManager_20221014002351.cpp create mode 100644 .history/SubscriptionManager_20221014002355.cpp create mode 100644 .history/SubscriptionManager_20221014002404.cpp create mode 100644 .history/SubscriptionManager_20221014002416.cpp create mode 100644 .history/SubscriptionManager_20221014002543.cpp create mode 100644 .history/SubscriptionManager_20221014002547.cpp create mode 100644 .history/SubscriptionManager_20221014002751.cpp create mode 100644 .history/SubscriptionManager_20221014002909.cpp create mode 100644 .history/SubscriptionManager_20221014002931.cpp create mode 100644 .history/SubscriptionManager_20221014002952.cpp create mode 100644 .history/SubscriptionManager_20221014003012.cpp create mode 100644 .history/SubscriptionManager_20221014003016.cpp create mode 100644 .history/SubscriptionManager_20221014003032.cpp create mode 100644 .history/SubscriptionManager_20221014003110.cpp create mode 100644 .history/SubscriptionManager_20221014003112.cpp create mode 100644 .history/SubscriptionManager_20221014003118.cpp create mode 100644 .history/SubscriptionManager_20221014003740.cpp create mode 100644 .history/SubscriptionManager_20221014003842.cpp create mode 100644 .history/SubscriptionManager_20221014224510.cpp create mode 100644 .history/SubscriptionManager_20221015132404.cpp create mode 100644 .history/SubscriptionManager_20221015135839.cpp create mode 100644 .history/SubscriptionManager_20221015140050.cpp create mode 100644 .history/SubscriptionManager_20221015140147.cpp create mode 100644 .history/SubscriptionManager_20221015140418.h create mode 100644 .history/SubscriptionManager_20221015140432.cpp create mode 100644 .history/SubscriptionManager_20221015140547.cpp create mode 100644 .history/SubscriptionManager_20221015140637.cpp create mode 100644 .history/SubscriptionManager_20221015140703.cpp create mode 100644 .history/SubscriptionManager_20221015140849.cpp create mode 100644 .history/SubscriptionManager_20221015140915.cpp create mode 100644 .history/SubscriptionManager_20221015141339.cpp create mode 100644 .history/SubscriptionManager_20221015141418.cpp create mode 100644 .history/SubscriptionManager_20221015141638.cpp create mode 100644 .history/SubscriptionManager_20221015180125.cpp create mode 100644 .history/SubscriptionManager_20221015181249.cpp create mode 100644 .history/SubscriptionManager_20221015181639.cpp create mode 100644 .history/SubscriptionManager_20221015181912.cpp create mode 100644 .history/SubscriptionManager_20221015182122.cpp create mode 100644 .history/SubscriptionManager_20221015183109.cpp create mode 100644 .history/SubscriptionManager_20221015183204.cpp create mode 100644 .history/SubscriptionManager_20221015183209.cpp create mode 100644 .history/SubscriptionManager_20221015183518.cpp create mode 100644 .history/SubscriptionManager_20221015191146.cpp create mode 100644 .history/SubscriptionManager_20221015193901.cpp create mode 100644 .history/SubscriptionManager_20221015200446.cpp create mode 100644 .history/SubscriptionManager_20221015200502.cpp create mode 100644 .history/SubscriptionManager_20221015201436.h create mode 100644 .history/SubscriptionManager_20221015201440.h create mode 100644 .history/SubscriptionManager_20221015201500.cpp create mode 100644 .history/SubscriptionManager_20221015201542.cpp create mode 100644 .history/SubscriptionManager_20221015201557.cpp create mode 100644 .history/SubscriptionManager_20221016174159.cpp create mode 100644 .history/SubscriptionManager_20221016174206.cpp create mode 100644 .history/SubscriptionManager_20221016175448.cpp create mode 100644 .history/SubscriptionManager_20221016180238.cpp create mode 100644 .history/SubscriptionManager_20221016180248.h create mode 100644 .history/Subscription_20221013190812.h create mode 100644 .history/Subscription_20221013190943.cpp create mode 100644 .history/Subscription_20221013204658.h create mode 100644 .history/Subscription_20221013204725.cpp create mode 100644 .history/Subscription_20221013204753.cpp create mode 100644 .history/Subscription_20221013205054.cpp create mode 100644 .history/Subscription_20221014003150.h create mode 100644 .history/Subscription_20221014212452.h create mode 100644 .history/Subscription_20221014212457.h create mode 100644 .history/Subscription_20221014212653.h create mode 100644 .history/Subscription_20221014220951.cpp create mode 100644 .history/Subscription_20221015131611.cpp create mode 100644 .history/Subscription_20221015142023.cpp create mode 100644 .history/Subscription_20221015175629.cpp create mode 100644 .history/Subscription_20221015182553.h create mode 100644 .history/Subscription_20221015182613.h create mode 100644 .history/Subscription_20221015182633.cpp create mode 100644 .history/Subscription_20221015182644.cpp create mode 100644 .history/Subscription_20221015182655.h create mode 100644 .history/Subscription_20221015182706.cpp create mode 100644 .history/Subscription_20221015182712.cpp create mode 100644 .history/Subscription_20221015203632.h create mode 100644 .history/Subscription_20221015203643.cpp create mode 100644 .history/Subscription_20221015203655.cpp create mode 100644 .history/Subscription_20221015203702.cpp create mode 100644 .history/Subscription_20221015203734.h create mode 100644 .history/Subscription_20221015203735.cpp create mode 100644 .history/Subscription_20221015203805.cpp create mode 100644 .history/Subscription_20221015204939.cpp create mode 100644 .history/Subscription_20221016151339.cpp create mode 100644 .history/Subscription_20221016162014.cpp create mode 100644 .history/Subscription_20221016172637.cpp create mode 100644 .history/Subscription_20221016172643.cpp create mode 100644 .history/Subscription_20221016173312.cpp create mode 100644 .history/Subscription_20221016173458.cpp create mode 100644 .history/Subscription_20221016173903.cpp create mode 100644 .history/Subscription_20221016174406.cpp create mode 100644 .history/Subscription_20221016174556.cpp create mode 100644 .history/Subscription_20221016174634.cpp create mode 100644 .history/Subscription_20221016174652.cpp create mode 100644 .history/Subscription_20221016174712.cpp create mode 100644 .history/Subscription_20221016174852.h create mode 100644 .history/Subscription_20221016174910.h create mode 100644 .history/Subscription_20221016174913.h create mode 100644 .history/Subscription_20221016174921.cpp create mode 100644 .history/Subscription_20221016174923.cpp create mode 100644 .history/Subscription_20221016175152.cpp create mode 100644 .history/Subscription_20221016175838.cpp create mode 100644 .history/Subscription_20221016175855.cpp create mode 100644 .history/Subscription_20221016175911.cpp create mode 100644 .history/Subscription_20221016175912.cpp create mode 100644 SubscriptionHandler.h 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/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 44c2468..29e1af0 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::removeSessionSubscriptions(TCPSession &session) { + + int SubscriptionManager::add(Subscription &subscription) { + 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)); + 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(); + 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