barant/ServerCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

setup ignore update for .history files.

Browse Source
This commit is contained in:
Brad 2023-02-08 03:31:51 +00:00
parent 001cd8c06c
commit 1e76a7f49a
85 changed files with 528 additions and 10920 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -8,3 +8,4 @@ docs/latex/
docs/html
*/*.ipch
*/mmap_address.bin
.history/*

100
.history/SubscriptionManager_20221013230931.cpp
View File

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

127
.history/SubscriptionManager_20221013231054.cpp
View File

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

127
.history/SubscriptionManager_20221013232529.cpp
View File

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

128
.history/SubscriptionManager_20221013232559.cpp
View File

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

128
.history/SubscriptionManager_20221013232603.cpp
View File

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

128
.history/SubscriptionManager_20221013232637.cpp
View File

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

128
.history/SubscriptionManager_20221013232709.cpp
View File

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

127
.history/SubscriptionManager_20221013232718.cpp
View File

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

141
.history/SubscriptionManager_20221014001552.cpp
View File

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

141
.history/SubscriptionManager_20221014001640.cpp
View File

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

141
.history/SubscriptionManager_20221014001750.cpp
View File

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

141
.history/SubscriptionManager_20221014001801.cpp
View File

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

141
.history/SubscriptionManager_20221014001829.cpp
View File

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

141
.history/SubscriptionManager_20221014001848.cpp
View File

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

141
.history/SubscriptionManager_20221014002019.cpp
View File

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

141
.history/SubscriptionManager_20221014002052.cpp
View File

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

141
.history/SubscriptionManager_20221014002112.cpp
View File

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

141
.history/SubscriptionManager_20221014002118.cpp
View File

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

141
.history/SubscriptionManager_20221014002130.cpp
View File

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

141
.history/SubscriptionManager_20221014002136.cpp
View File

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

142
.history/SubscriptionManager_20221014002203.cpp
View File

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

142
.history/SubscriptionManager_20221014002300.cpp
View File

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

142
.history/SubscriptionManager_20221014002351.cpp
View File

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

142
.history/SubscriptionManager_20221014002355.cpp
View File

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

142
.history/SubscriptionManager_20221014002404.cpp
View File

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

142
.history/SubscriptionManager_20221014002416.cpp
View File

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

142
.history/SubscriptionManager_20221014002543.cpp
View File

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

142
.history/SubscriptionManager_20221014002547.cpp
View File

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

142
.history/SubscriptionManager_20221014002751.cpp
View File

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

142
.history/SubscriptionManager_20221014002909.cpp
View File

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

142
.history/SubscriptionManager_20221014002931.cpp
View File

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

141
.history/SubscriptionManager_20221014002952.cpp
View File

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

146
.history/SubscriptionManager_20221014003012.cpp
View File

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

146
.history/SubscriptionManager_20221014003016.cpp
View File

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

146
.history/SubscriptionManager_20221014003032.cpp
View File

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

146
.history/SubscriptionManager_20221014003110.cpp
View File

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

146
.history/SubscriptionManager_20221014003112.cpp
View File

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

146
.history/SubscriptionManager_20221014003118.cpp
View File

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

142
.history/SubscriptionManager_20221014003740.cpp
View File

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

142
.history/SubscriptionManager_20221014003842.cpp
View File

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

142
.history/SubscriptionManager_20221014224510.cpp
View File

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

142
.history/SubscriptionManager_20221015132404.cpp
View File

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

146
.history/SubscriptionManager_20221015135839.cpp
View File

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

146
.history/SubscriptionManager_20221015140050.cpp
View File

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

146
.history/SubscriptionManager_20221015140147.cpp
View File

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

146
.history/SubscriptionManager_20221015140432.cpp
View File

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

146
.history/SubscriptionManager_20221015140547.cpp
View File

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

146
.history/SubscriptionManager_20221015140637.cpp
View File

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

146
.history/SubscriptionManager_20221015140703.cpp
View File

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

146
.history/SubscriptionManager_20221015140849.cpp
View File

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

146
.history/SubscriptionManager_20221015140915.cpp
View File

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

146
.history/SubscriptionManager_20221015141339.cpp
View File

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