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 = subscriptions[request[1].str()];
if (request[1].equals(subscription->id))
{
if (request[0].equals("unpublish"))
{
subscriptions.erase(request[1].str());
}
else if (request[0].equals("subscribe"))
{
subscription->subscribe(session);
return 1;
}
else if (request[0].equals("unsubscribe"))
{
subscription->unsubscribe(session);
return 1;
}
else if (request[0].equals("event"))
{
std::stringstream out;
subscription->process(request, out, session);
if (subscription->mode == "*ANYONE")
{
subscription->event(out);
return 1;
}
else if (subscription->mode == "*SUBSCRIBERS")
{
if (subscription->ifSubscriber(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_20221015141418.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());
subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
}
else
{
// newSubscription = new Subscription(request[1].str(), session, request[2].str());
}
return 1;
}
else if (request[0].equals("catalog"))
{
session.out << ":catalog:";
for (auto const &[key, subscription] : subscriptions)
{
session.out << subscription->id << ";";
}
session.out << std::endl;
return 1;
}
auto subscription = subscriptions[request[1].str()];
if (request[1].equals(subscription->id))
{
if (request[0].equals("unpublish"))
{
subscriptions.erase(request[1].str());
}
else if (request[0].equals("subscribe"))
{
subscription->subscribe(session);
return 1;
}
else if (request[0].equals("unsubscribe"))
{
subscription->unsubscribe(session);
return 1;
}
else if (request[0].equals("event"))
{
std::stringstream out;
subscription->process(request, out, session);
if (subscription->mode == "*ANYONE")
{
subscription->event(out);
return 1;
}
else if (subscription->mode == "*SUBSCRIBERS")
{
if (subscription->ifSubscriber(session))
{
subscription->event(out);
return 1;
}
}
else if (subscription->mode == "*AUTHOR")
{
if (subscription->owner == &session)
{
subscription->event(out);
return 1;
}
}
}
return 0;
}
return 0;
}
}

147
.history/SubscriptionManager_20221015141638.cpp
View File

@ -1,147 +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());
subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
}
else
{
newSubscription = new Subscription(request[1].str(), session, request[2].str());
subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
}
return 1;
}
else if (request[0].equals("catalog"))
{
session.out << ":catalog:";
for (auto const &[key, subscription] : subscriptions)
{
session.out << subscription->id << ";";
}
session.out << std::endl;
return 1;
}
auto subscription = subscriptions[request[1].str()];
if (request[1].equals(subscription->id))
{
if (request[0].equals("unpublish"))
{
subscriptions.erase(request[1].str());
}
else if (request[0].equals("subscribe"))
{
subscription->subscribe(session);
return 1;
}
else if (request[0].equals("unsubscribe"))
{
subscription->unsubscribe(session);
return 1;
}
else if (request[0].equals("event"))
{
std::stringstream out;
subscription->process(request, out, session);
if (subscription->mode == "*ANYONE")
{
subscription->event(out);
return 1;
}
else if (subscription->mode == "*SUBSCRIBERS")
{
if (subscription->ifSubscriber(session))
{
subscription->event(out);
return 1;
}
}
else if (subscription->mode == "*AUTHOR")
{
if (subscription->owner == &session)
{
subscription->event(out);
return 1;
}
}
}
return 0;
}
return 0;
}
}

146
.history/SubscriptionManager_20221015180125.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());
}
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_20221015181249.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() > 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_20221015181639.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());
}
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_20221015181912.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());
}
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;
}
}

143
.history/SubscriptionManager_20221015182122.cpp
View File

@ -1,143 +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());
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;
}
}

143
.history/SubscriptionManager_20221015183109.cpp
View File

@ -1,143 +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());
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;
}
}

144
.history/SubscriptionManager_20221015183204.cpp
View File

@ -1,144 +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());
}
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_20221015183209.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());
}
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_20221015183518.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;
}
}

147
.history/SubscriptionManager_20221015191146.cpp
View File

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

147
.history/SubscriptionManager_20221015193901.cpp
View File

@ -1,147 +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;
}
}

147
.history/SubscriptionManager_20221015200446.cpp
View File

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

147
.history/SubscriptionManager_20221015200502.cpp
View File

@ -1,147 +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;
}
}

147
.history/SubscriptionManager_20221015201500.cpp
View File

@ -1,147 +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;
}
}

147
.history/SubscriptionManager_20221015201542.cpp
View File

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

147
.history/SubscriptionManager_20221015201557.cpp
View File

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

148
.history/SubscriptionManager_20221016174159.cpp
View File

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

148
.history/SubscriptionManager_20221016174206.cpp
View File

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

148
.history/SubscriptionManager_20221016175448.cpp
View File

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

148
.history/SubscriptionManager_20221016180238.cpp
View File

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

15
SessionFilter.h
View File

@ -2,18 +2,21 @@
#define __SessionFilter_h__
//#include "Session.h"
#include "Object.h"
namespace core {
namespace core
{
class TCPSession;
class TCPSession;
class SessionFilter : public Object {
class SessionFilter : public Object
{
public:
virtual bool test(TCPSession &session) {
public:
virtual bool test(TCPSession &session)
{
return true;
}
};
}

138
Socket.cpp
View File

@ -1,54 +1,61 @@
#include "EPoll.h"
#include "Socket.h"
#include "EPoll.h"
#include "Exception.h"
#include "ZString.h"
#include "Log.h"
#include "ZString.h"
namespace core {
namespace core
{
void sigpipe_handler(int unused) {}
Socket::Socket(EPoll &ePoll, std::string text) : ePoll(ePoll), text(text) {
Socket::Socket(EPoll &ePoll, std::string text) : ePoll(ePoll), text(text)
{
coreutils::Log(coreutils::LOG_DEBUG_2) << "Socket object created [" << text << "].";
buffer = (char *)malloc(4096);
length = 4096;
}
Socket::~Socket() {
Socket::~Socket()
{
free(buffer);
if(descriptor == -1)
return;
if (descriptor == -1)
return;
onUnregister();
ePoll.unregisterSocket(this);
coreutils::Log(coreutils::LOG_DEBUG_3) << "Socket destroyed for socket " << descriptor << ".";
close(descriptor);
}
void Socket::setDescriptor(int descriptor) {
if((descriptor == -1) && (errno == 24)) {
shutdown("Too many files open");
throw coreutils::Exception("Too many files open. Refusing connection.");
void Socket::setDescriptor(int descriptor)
{
if ((descriptor == -1) && (errno == 24))
{
shutdown("Too many files open");
throw coreutils::Exception("Too many files open. Refusing connection.");
}
coreutils::Log(coreutils::LOG_DEBUG_3) << "Descriptor set to " << descriptor << " for Socket.";
if(descriptor < 3)
throw coreutils::Exception("Descriptor out of range", __FILE__, __LINE__);
if (descriptor < 3)
throw coreutils::Exception("Descriptor out of range", __FILE__, __LINE__);
this->descriptor = descriptor;
onRegister();
ePoll.registerSocket(this);
onRegistered();
}
int Socket::getDescriptor() {
int Socket::getDescriptor()
{
return descriptor;
}
void Socket::setBufferSize(int length) {
void Socket::setBufferSize(int length)
{
this->length = length;
buffer = (char *)realloc(buffer, length);
}
int Socket::getBufferSize() {
int Socket::getBufferSize()
{
return length;
}
@ -60,99 +67,116 @@ namespace core {
void Socket::onUnregistered() {}
bool Socket::eventReceived(struct epoll_event event) {
inHandler = true;
if(event.events & EPOLLRDHUP) {
bool Socket::eventReceived(struct epoll_event event)
{
inHandler = true;
if (event.events & EPOLLRDHUP)
{
readHangup = true;
shutdown("hangup received");
}
else if(event.events & EPOLLIN) {
else if (event.events & EPOLLIN)
{
coreutils::ZString zbuffer(buffer, length);
receiveData(zbuffer);
receiveData(zbuffer);
}
else if(event.events & EPOLLWRNORM) {
writeSocket();
else if (event.events & EPOLLWRNORM)
{
writeSocket();
}
else if(event.events & EPOLLHUP) {
else if (event.events & EPOLLHUP)
{
shutdown();
}
inHandler = false;
inHandler = false;
return !shutDown;
}
void Socket::onDataReceived(std::string data) {
void Socket::onDataReceived(std::string data)
{
throw coreutils::Exception("Need to override onDataReceived.", __FILE__, __LINE__, -1);
}
void Socket::onDataReceived(coreutils::ZString &data) {
void Socket::onDataReceived(coreutils::ZString &data)
{
onDataReceived(std::string(data.getData(), data.getLength()));
}
void Socket::receiveData(coreutils::ZString &buffer) {
void Socket::receiveData(coreutils::ZString &buffer)
{
coreutils::ZString blank("");
if(buffer.getLength() <= 0)
throw coreutils::Exception("Request to receive data with a zero buffer length.", __FILE__, __LINE__, -1);
if (buffer.getLength() <= 0)
throw coreutils::Exception("Request to receive data with a zero buffer length.", __FILE__, __LINE__, -1);
int len;
int error = -1;
if((len = ::read(getDescriptor(), buffer.getData(), buffer.getLength())) >= 0) {
if ((len = ::read(getDescriptor(), buffer.getData(), buffer.getLength())) >= 0)
{
coreutils::ZString zbuffer(buffer.getData(), len);
coreutils::Log(coreutils::LOG_DEBUG_1) << zbuffer;
onDataReceived(zbuffer);
onDataReceived(zbuffer);
}
else {
else
{
error = errno;
error = errno;
switch (error) {
switch (error)
{
// When a listening socket receives a connection
// request we get one of these.
//
case ENOTCONN:
// When a listening socket receives a connection
// request we get one of these.
//
case ENOTCONN:
onDataReceived(blank);
break;
case ECONNRESET:
break;
default:
case ECONNRESET:
break;
default:
throw coreutils::Exception("Error in read of data from socket.", __FILE__, __LINE__, error);
}
}
}
}
void Socket::writeSocket() {
if(fifo.size() > 0) {
outlock.lock();
if(!shutDown)
::write(descriptor, fifo.front().c_str(), fifo.front().length());
void Socket::writeSocket()
{
if (fifo.size() > 0)
{
outlock.lock();
if (!shutDown)
::write(descriptor, fifo.front().c_str(), fifo.front().length());
fifo.pop();
outlock.unlock();
outlock.unlock();
}
}
int Socket::write(std::string data) {
int Socket::write(std::string data)
{
outlock.lock();
fifo.emplace(data);
outlock.unlock();
if(!inHandler)
ePoll.resetSocket(this);
if (!inHandler)
ePoll.resetSocket(this);
return 1;
}
void Socket::output(std::stringstream &out) {
void Socket::output(std::stringstream &out)
{
out << "|" << descriptor << "|";
}
bool Socket::needsToWrite() {
bool Socket::needsToWrite()
{
return fifo.size() > 0;
}
void Socket::shutdown(std::string text) {
void Socket::shutdown(std::string text)
{
coreutils::Log(coreutils::LOG_DEBUG_2) << "Shutdown requested on socket " << descriptor << " with reason " << text << ".";
shutDown = true;
reset = false;

32
Subscription.cpp
View File

@ -7,13 +7,13 @@ namespace core
{
Subscription::Subscription(std::string id, std::string mode)
: id(id), mode(mode), owner(NULL), handler(NULL) {}
: id(id), mode(mode), owner(NULL), handler(NULL) {}
Subscription::Subscription(std::string id, TCPSession &session, std::string mode)
: id(id), mode(mode), owner(&session), handler(NULL) {}
: id(id), mode(mode), owner(&session), handler(NULL) {}
Subscription::Subscription(std::string id, TCPSession &session, std::string mode, SubscriptionHandler *handler)
: id(id), mode(mode), owner(&session), handler(handler) {}
: id(id), mode(mode), owner(&session), handler(handler) {}
Subscription::~Subscription()
{
@ -27,10 +27,10 @@ namespace core
int Subscription::subscribe(TCPSession &session)
{
if(handler)
handler->onSubscribe(session);
if (handler)
handler->onSubscribe(session);
else
onSubscribe(session);
onSubscribe(session);
subscribers.push_back(&session);
return 1;
@ -76,10 +76,16 @@ namespace core
return 0;
}
// void Subscription::setHandler(SubscriptionHandler *handlers)
// {
// handler = handlers;
bool Subscription::subInvite(TCPSession &session)
{
// coreutils::Log(coreutils::LOG_DEBUG_1) << "Test Test";
// }
return 0;
}
// void Subscription::setHandler(SubscriptionHandler *handlers)
// {
// handler = handlers;
// coreutils::Log(coreutils::LOG_DEBUG_1) << "Test Test";
// }
}

4
Subscription.h
View File

@ -31,7 +31,9 @@ namespace core
bool ifSubscriber(TCPSession &session);
// void setHandler(SubscriptionHandler *handlers);
bool subInvite(TCPSession &session);
// void setHandler(SubscriptionHandler *handlers);
// int processCommand(coreutils::ZString &request, TCPSession &session) override;

33
SubscriptionManager.cpp
View File

@ -1,28 +1,31 @@
#include "SubscriptionManager.h"
#include "Log.h"
#include "Subscription.h"
#include "TCPServer.h"
#include <algorithm>
namespace core
{
SubscriptionManager::SubscriptionManager() {}
int SubscriptionManager::add(Subscription &subscription) {
int SubscriptionManager::add(Subscription &subscription)
{
lock.lock();
subscriptions.insert(std::make_pair(subscription.id, &subscription));
lock.unlock();
return 1;
}
int SubscriptionManager::addHandler(std::string name, SubscriptionHandler *handler) {
int SubscriptionManager::addHandler(std::string name, SubscriptionHandler *handler)
{
lock.lock();
handlers.insert(std::make_pair(name, handler));
coreutils::Log(coreutils::LOG_DEBUG_1) << "Adding handler to SubscriptionManager for '" << name << "' (" << handler;
lock.unlock();
return 1;
}
int SubscriptionManager::removeSessionSubscriptions(TCPSession &session)
{
int countSubscribed = 0;
@ -60,8 +63,8 @@ namespace core
{
if (request[0].equals("publish"))
{
SubscriptionHandler *handler = handlers[request[3].str()];
newSubscription = new Subscription(request[1].str(), session, request[2].str(), handler);
SubscriptionHandler *handler = handlers[request[3].str()];
newSubscription = new Subscription(request[1].str(), session, request[2].str(), handler);
subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
return 1;
@ -77,7 +80,19 @@ namespace core
session.out << std::endl;
return 1;
}
else if (request[0].equals("invite"))
{
std::stringstream out;
coreutils::Log(coreutils::LOG_DEBUG_1) << request[2];
std::string invitee = request[2].str();
TCPSession *tempSession = session.server.getSessionByAlias(&invitee);
std::stringstream temp;
// We need to utilize invite for different ways, group with people,and to generally invite into anything pertaining interaction////
/// with another player//
temp << "invite:" << request[1] << ":" << *(std::string *)session.alias;
tempSession->write(temp.str());
return 1;
}
auto subscription = subscriptions[request[1].str()];
if (request[1].equals(subscription->id))
@ -96,6 +111,7 @@ namespace core
subscription->unsubscribe(session);
return 1;
}
else if (request[0].equals("event"))
{
std::stringstream out;
@ -113,6 +129,7 @@ namespace core
return 1;
}
}
else if (subscription->mode == "*AUTHOR")
{
if (subscription->owner == &session)

159
TCPServer.cpp
View File

@ -1,125 +1,156 @@
#include "TCPServer.h"
#include "EPoll.h"
#include "TCPSession.h"
#include "Exception.h"
#include "Log.h"
#include "TCPSession.h"
namespace core {
namespace core
{
TCPServer::TCPServer(EPoll &ePoll, IPAddress address, std::string delimiter, int depth, std::string text)
: TCPSocket(ePoll, text), commands(delimiter, depth) {
: TCPSocket(ePoll, text), commands(delimiter, depth)
{
commands.add(subscriptions, "publish");
commands.add(subscriptions, "unpublish");
commands.add(subscriptions, "subscribe");
commands.add(subscriptions, "unsubscribe");
commands.add(subscriptions, "catalog");
commands.add(subscriptions, "event");
commands.add(subscriptions, "publish");
commands.add(subscriptions, "unpublish");
commands.add(subscriptions, "subscribe");
commands.add(subscriptions, "unsubscribe");
commands.add(subscriptions, "catalog");
commands.add(subscriptions, "event");
commands.add(subscriptions, "invite");
setDescriptor(socket(AF_INET, SOCK_STREAM, 0));
int yes = 1;
setsockopt(getDescriptor(), SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
setDescriptor(socket(AF_INET, SOCK_STREAM, 0));
int yes = 1;
setsockopt(getDescriptor(), SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
if(bind(getDescriptor(), address.getPointer(), address.addressLength) < 0)
throw coreutils::Exception("Error on bind to socket: " + std::to_string(errno));
if(listen(getDescriptor(), 20) < 0)
throw coreutils::Exception("Error on listen to socket");
if (bind(getDescriptor(), address.getPointer(), address.addressLength) < 0)
throw coreutils::Exception("Error on bind to socket: " + std::to_string(errno));
if (listen(getDescriptor(), 20) < 0)
throw coreutils::Exception("Error on listen to socket");
}
TCPServer::~TCPServer() {
TCPServer::~TCPServer()
{
coreutils::Log(coreutils::LOG_DEBUG_2) << "Closing server socket " << getDescriptor() << ".";
close(getDescriptor());
}
void TCPServer::onDataReceived(std::string data) {
void TCPServer::onDataReceived(std::string data)
{
lock.lock();
TCPSession *session = accept();
if(session)
sessions.push_back(session);
if (session)
sessions.push_back(session);
lock.unlock();
}
TCPSession * TCPServer::accept() {
TCPSession *TCPServer::accept()
{
try {
try
{
TCPSession *session = getSocketAccept(ePoll);
session->setDescriptor(::accept(getDescriptor(), (struct sockaddr *)&session->ipAddress.addr, &session->ipAddress.addressLength));
// if(blackList && blackList->contains(session->ipAddress.getClientAddress())) {
// session->shutdown();
// Log(LOG_WARN) << "Client at IP address " << session->ipAddress.getClientAddress() << " is blacklisted and was denied a connection.";
// return NULL;
// }
// if(whiteList && !whiteList->contains(session->ipAddress.getClientAddress())) {
// session->shutdown();
// Log(LOG_WARN) << "Client at IP address " << session->ipAddress.getClientAddress() << " is not authorized and was denied a connection.";
// return NULL;
// }
// if(blackList && blackList->contains(session->ipAddress.getClientAddress())) {
// session->shutdown();
// Log(LOG_WARN) << "Client at IP address " << session->ipAddress.getClientAddress() << " is blacklisted and was denied a connection.";
// return NULL;
// }
// if(whiteList && !whiteList->contains(session->ipAddress.getClientAddress())) {
// session->shutdown();
// Log(LOG_WARN) << "Client at IP address " << session->ipAddress.getClientAddress() << " is not authorized and was denied a connection.";
// return NULL;
// }
return session;
}
catch(coreutils::Exception e) {
catch (coreutils::Exception e)
{
coreutils::Log(coreutils::LOG_EXCEPT) << "Major error on session initialization. Error is '" << e.text << "'.";
}
catch(...) {
catch (...)
{
coreutils::Log(coreutils::LOG_EXCEPT) << "Unnspecified error on session initialization.";
}
return NULL;
}
void TCPServer::removeFromSessionList(TCPSession *session) {
void TCPServer::removeFromSessionList(TCPSession *session)
{
std::vector<TCPSession *>::iterator cursor;
lock.lock();
for(cursor = sessions.begin(); cursor < sessions.end(); ++cursor)
if(*cursor == session) {
sessions.erase(cursor);
break;
}
lock.unlock();
lock.lock();
for (cursor = sessions.begin(); cursor < sessions.end(); ++cursor)
if (*cursor == session)
{
sessions.erase(cursor);
break;
}
lock.unlock();
}
void TCPServer::sessionErrorHandler(std::string errorString, std::stringstream &out) {
void TCPServer::sessionErrorHandler(std::string errorString, std::stringstream &out)
{
throw coreutils::Exception(errorString);
}
TCPSession * TCPServer::getSocketAccept(EPoll &ePoll) {
TCPSession *TCPServer::getSocketAccept(EPoll &ePoll)
{
return new TCPSession(ePoll, *this);
}
void TCPServer::output(std::stringstream &out) {
void TCPServer::output(std::stringstream &out)
{
out << "Use the 'help' command to list the commands for this server." << std::endl;
}
int TCPServer::processCommand(coreutils::ZString &request, TCPSession &session) {
int TCPServer::processCommand(coreutils::ZString &request, TCPSession &session)
{
int sequence = 0;
for(auto *sessionx : sessions) {
for (auto *sessionx : sessions)
{
session.out << "|" << ++sequence;
sessionx->output(session.out);
session.out << "|" << std::endl;
}
return 1;
}
void TCPServer::sendToAll(std::stringstream &data) {
for(auto session : sessions)
session->write(data.str());
void TCPServer::sendToAll(std::stringstream &data)
{
for (auto session : sessions)
session->write(data.str());
data.str("");
}
void TCPServer::sendToAll(std::stringstream &data, TCPSession &sender) {
for(auto session : sessions)
if(session != &sender)
session->write(data.str());
void TCPServer::sendToAll(std::stringstream &data, TCPSession &sender)
{
for (auto session : sessions)
if (session != &sender)
session->write(data.str());
data.str("");
}
void TCPServer::sendToAll(std::stringstream &data, TCPSession &sender, SessionFilter filter) {
for(auto session : sessions)
if(filter.test(*session))
if(session != &sender)
session->write(data.str());
void TCPServer::sendToAll(std::stringstream &data, TCPSession &sender, SessionFilter filter)
{
for (auto session : sessions)
if (filter.test(*session))
if (session != &sender)
session->write(data.str());
data.str("");
}
TCPSession *TCPServer::getSessionByAlias(void *alias)
{
coreutils::Log(coreutils::LOG_DEBUG_1) << alias;
for (auto session : sessions)
if (compareAlias(session->alias, alias))
return session;
return NULL;
}
bool TCPServer::compareAlias(void *alias, void *compare)
{
return true;
}
}

219
TCPServer.h
View File

@ -1,149 +1,156 @@
#ifndef __TCPServer_h__
#define __TCPServer_h__
#include "Socket.h"
#include "TCPSocket.h"
#include "IPAddressList.h"
#include "Command.h"
#include "CommandList.h"
#include "IPAddressList.h"
#include "Socket.h"
#include "SubscriptionManager.h"
#include "TCPSession.h"
#include "TCPSocket.h"
namespace core {
namespace core
{
///
/// TCPServer
///
/// Manage a socket connection as a TCP server type. Connections to the socket are processed through
/// the accept functionality.
///
/// A list of connections is maintained in a vector object.
///
/// This object extends the BMACommand object as well so it can be added to a Console object and
/// process commands to display status information.
///
///
/// TCPServer
///
/// Manage a socket connection as a TCP server type. Connections to the socket are processed through
/// the accept functionality.
///
/// A list of connections is maintained in a vector object.
///
/// This object extends the BMACommand object as well so it can be added to a Console object and
/// process commands to display status information.
///
class TCPServer : public TCPSocket, public Command {
class TCPServer : public TCPSocket, public Command
{
public:
public:
///
/// The constructor for the TCPServer object.
///
/// @param ePoll the EPoll instance that manages the socket.
/// @param url the IP address for the socket to receive connection requests.
/// @param port the port number that the socket will listen on.
/// @param commandName the name of the command used to invoke the status display for this object.
///
///
/// The constructor for the TCPServer object.
///
/// @param ePoll the EPoll instance that manages the socket.
/// @param url the IP address for the socket to receive connection requests.
/// @param port the port number that the socket will listen on.
/// @param commandName the name of the command used to invoke the status display for this object.
///
TCPServer(EPoll &ePoll, IPAddress address, std::string delimiter = " ", int depth = 10, std::string text = "");
TCPServer(EPoll &ePoll, IPAddress address, std::string delimiter = " ", int depth = 10, std::string text = "");
///
/// The destructor for this object.
///
///
/// The destructor for this object.
///
virtual ~TCPServer();
virtual ~TCPServer();
virtual void sessionErrorHandler(std::string errorString, std::stringstream &out);
virtual bool compareAlias(void *alias, void *compare);
///
/// getSocketAccept is designed to allow a polymorphic extension of this object to
/// return a type of object that extends the definition of the server socket.
/// Returning the appropriate session object that extends from Session provides
/// the mechanism where the server can select the protocol dialog for the desired
/// service.
///
virtual void sessionErrorHandler(std::string errorString, std::stringstream &out);
virtual TCPSession *getSocketAccept(EPoll &epoll);
///
/// getSocketAccept is designed to allow a polymorphic extension of this object to
/// return a type of object that extends the definition of the server socket.
/// Returning the appropriate session object that extends from Session provides
/// the mechanism where the server can select the protocol dialog for the desired
/// service.
///
///
/// The list of sessions that are currently open and being maintained by this object.
///
virtual TCPSession * getSocketAccept(EPoll &epoll);
std::vector<TCPSession *> sessions;
///
/// The list of sessions that are currently open and being maintained by this object.
///
///
/// The commands object is a CommandList and is used to store Command objects to be
/// parsed and run as data comes into the session.
///
std::vector<TCPSession *> sessions;
CommandList commands;
///
/// The commands object is a CommandList and is used to store Command objects to be
/// parsed and run as data comes into the session.
///
///
/// If not NULL the blacklist object can be assigned to this server socket and the server
/// IP addresses connecting to the server attempting to accept a socket are contained in
/// this list then the connection is rejected and no accept is granted.
///
CommandList commands;
IPAddressList *blackList;
///
/// If not NULL the blacklist object can be assigned to this server socket and the server
/// IP addresses connecting to the server attempting to accept a socket are contained in
/// this list then the connection is rejected and no accept is granted.
///
///
/// If not NULL the blacklist object can be assigned to this server socket and the server
/// IP addresses connecting to the server attempting to accept a socket are contained in
/// this list then the connection is rejected and no accept is granted.
///
IPAddressList *blackList;
IPAddressList *whiteList;
///
/// If not NULL the blacklist object can be assigned to this server socket and the server
/// IP addresses connecting to the server attempting to accept a socket are contained in
/// this list then the connection is rejected and no accept is granted.
///
void removeFromSessionList(TCPSession *session);
IPAddressList *whiteList;
void output(std::stringstream &out); ///< Output the consoles array to the console.
void removeFromSessionList(TCPSession *session);
///
///
///
void output(std::stringstream &out); ///<Output the consoles array to the console.
void sendToAll(std::stringstream &out);
///
///
///
///
/// Use this sendToAll method to output the contents of the out stream
/// to all the connections on the server excluding the sender session.
///
void sendToAll(std::stringstream &out);
void sendToAll(std::stringstream &out, TCPSession &sender, SessionFilter filter);
///
/// Use this sendToAll method to output the contents of the out stream
/// to all the connections on the server excluding the sender session.
///
///
/// Use this sendToAll method to output the contents of the out stream
/// to all the connections on the server excluding the sender session
/// and the entries identified by the passed in filter object.
///
void sendToAll(std::stringstream &out, TCPSession &sender, SessionFilter filter);
void sendToAll(std::stringstream &out, TCPSession &sender);
///
/// Use this sendToAll method to output the contents of the out stream
/// to all the connections on the server excluding the sender session
/// and the entries identified by the passed in filter object.
///
///
/// The Subscription Manager tracks all subscriptions on the server.
///
void sendToAll(std::stringstream &out, TCPSession &sender);
SubscriptionManager subscriptions;
///
/// The Subscription Manager tracks all subscriptions on the server.
///
///
/// Use the getSessionByAlias to retrieve a session pointer by the value
/// of the alias pointer.
///
SubscriptionManager subscriptions;
TCPSession *getSessionByAlias(void *alias);
protected:
protected:
///
/// Override the virtual dataReceived since for the server these
/// are requests to accept the new connection socket.
/// No data is to be read or written when this method is called. It is the response to
/// the fact that a new connection is coming into the system
///
/// @param data the pointer to the buffer containing the received data.
/// @param length the length of the associated data buffer.
///
///
/// Override the virtual dataReceived since for the server these
/// are requests to accept the new connection socket.
/// No data is to be read or written when this method is called. It is the response to
/// the fact that a new connection is coming into the system
///
/// @param data the pointer to the buffer containing the received data.
/// @param length the length of the associated data buffer.
///
void onDataReceived(std::string data) override;
void onDataReceived(std::string data) override;
///
/// This method is called when the Command associated with this object is requested
/// because a user has typed in the associated command name on a command entry line.
///
/// @param the session object to write the output to.
///
///
/// This method is called when the Command associated with this object is requested
/// because a user has typed in the associated command name on a command entry line.
///
/// @param the session object to write the output to.
///
int processCommand(coreutils::ZString &request, TCPSession &session) override;
int processCommand(coreutils::ZString &request, TCPSession &session) override;
private:
TCPSession * accept();
std::mutex lock;
};
private:
TCPSession *accept();
std::mutex lock;
};
/// This method is called when you compare an alias of the character
}

128
TCPSession.cpp
View File

@ -1,96 +1,122 @@
#include "TCPSession.h"
#include "TCPServer.h"
#include "Exception.h"
#include "Log.h"
#include "TCPServer.h"
#include "uuid/uuid.h"
namespace core {
namespace core
{
TCPSession::TCPSession(EPoll &ePoll, TCPServer &server, std::string text) : TCPSocket(ePoll, text), server(server) {}
TCPSession::TCPSession(EPoll &ePoll, TCPServer &server, std::string text) : TCPSocket(ePoll, text), server(server)
{
uuid_t uuidObject;
uuid_generate(uuidObject);
std::string aaUuid = {uuidObject, uuidObject + 16};
coreutils::Log(coreutils::LOG_DEBUG_1) << uuidObject;
alias = (void *)uuidObject;
}
TCPSession::~TCPSession() {
TCPSession::~TCPSession()
{
server.removeFromSessionList(this);
server.subscriptions.removeSessionSubscriptions(*this);
}
void TCPSession::output(std::stringstream &data) {
void TCPSession::output(std::stringstream &data)
{
data << "|" << ipAddress.getClientAddressAndPort();
}
void TCPSession::protocol(coreutils::ZString &data) {
if(data.getLength() != 0) {
if(!server.commands.processRequest(data, *this)) {
coreutils::Log(coreutils::LOG_DEBUG_1) << "Received data could not be parsed: " << data.str();
void TCPSession::protocol(coreutils::ZString &data)
{
if (data.getLength() != 0)
{
if (!server.commands.processRequest(data, *this))
{
coreutils::Log(coreutils::LOG_DEBUG_1) << "Received data could not be parsed: " << data.str();
}
}
}
void TCPSession::onRegistered() {
void TCPSession::onRegistered()
{
onConnected();
coreutils::ZString blank("");
protocol(blank);
send();
if(term)
shutdown("termination requested");
if (term)
shutdown("termination requested");
}
void TCPSession::onConnected() {}
void TCPSession::onDataReceived(coreutils::ZString &data) {
if(data.getLength() > 0) {
lineBuffer = (char *)realloc(lineBuffer, lineBufferSize + data.getLength());
memcpy(lineBuffer + lineBufferSize, data.getData(), data.getLength());
lineBufferSize += data.getLength();
while(lineBufferSize > 0) {
if(blockSize == 0) {
lineLength = strcspn(lineBuffer, "\r\n");
if(lineLength == lineBufferSize)
break;
void TCPSession::onDataReceived(coreutils::ZString &data)
{
if (data.getLength() > 0)
{
lineBuffer = (char *)realloc(lineBuffer, lineBufferSize + data.getLength());
memcpy(lineBuffer + lineBufferSize, data.getData(), data.getLength());
lineBufferSize += data.getLength();
while (lineBufferSize > 0)
{
if (blockSize == 0)
{
lineLength = strcspn(lineBuffer, "\r\n");
if (lineLength == lineBufferSize)
break;
coreutils::ZString zLine(lineBuffer, lineLength);
onLineReceived(zLine);
if(lineBuffer[lineLength] == '\r')
++lineLength;
if(lineBuffer[lineLength] == '\n')
++lineLength;
lineBufferSize -= lineLength;
if(lineBufferSize > 0)
memmove(lineBuffer, lineBuffer + lineLength, lineBufferSize);
lineBuffer = (char *)realloc(lineBuffer, lineBufferSize);
} else if(lineBufferSize >= blockLength) {
coreutils::ZString zBlock(lineBuffer, blockLength);
onBlockReceived(zBlock);
lineBufferSize -= blockLength;
if(lineBufferSize > 0)
memmove(lineBuffer, lineBuffer + blockLength, lineBufferSize);
lineBuffer = (char *)realloc(lineBuffer, lineBufferSize);
}
}
onLineReceived(zLine);
if (lineBuffer[lineLength] == '\r')
++lineLength;
if (lineBuffer[lineLength] == '\n')
++lineLength;
lineBufferSize -= lineLength;
if (lineBufferSize > 0)
memmove(lineBuffer, lineBuffer + lineLength, lineBufferSize);
lineBuffer = (char *)realloc(lineBuffer, lineBufferSize);
}
else if (lineBufferSize >= blockLength)
{
coreutils::ZString zBlock(lineBuffer, blockLength);
onBlockReceived(zBlock);
lineBufferSize -= blockLength;
if (lineBufferSize > 0)
memmove(lineBuffer, lineBuffer + blockLength, lineBufferSize);
lineBuffer = (char *)realloc(lineBuffer, lineBufferSize);
}
}
}
}
void TCPSession::setBlockSize(int blockSize) {
void TCPSession::setBlockSize(int blockSize)
{
this->blockSize = blockSize;
}
void TCPSession::onLineReceived(coreutils::ZString &line) {
void TCPSession::onLineReceived(coreutils::ZString &line)
{
protocol(line);
send();
if(term)
shutdown("termination requested");
if (term)
shutdown("termination requested");
}
void TCPSession::onBlockReceived(coreutils::ZString &block) {
void TCPSession::onBlockReceived(coreutils::ZString &block)
{
coreutils::Log(coreutils::LOG_DEBUG_3) << "[" << block.getLength() << "]";
if(term)
shutdown("termination requested");
if (term)
shutdown("termination requested");
}
void TCPSession::send() {
if(out.tellp() > 0)
write(out.str());
void TCPSession::send()
{
if (out.tellp() > 0)
write(out.str());
out.str("");
}
void TCPSession::terminate() {
void TCPSession::terminate()
{
term = true;
}

207
TCPSession.h
View File

@ -1,142 +1,145 @@
#ifndef __Session_h__
# define __Session_h__
#define __Session_h__
#include "TCPSocket.h"
#include "SessionFilter.h"
#include "TCPSocket.h"
namespace core {
namespace core
{
class Command;
class TCPServer;
class Command;
class TCPServer;
///
/// TCPSession
///
/// TCPSession defines the nature of the interaction with the client
/// and stores persistent data for a defined session. TCPSession objects
/// are not sockets but instead provide a communications control
/// mechanism. Protocol conversations are provided through extensions
/// from this object.
///
///
///
///
/// TCPSession
///
/// TCPSession defines the nature of the interaction with the client
/// and stores persistent data for a defined session. TCPSession objects
/// are not sockets but instead provide a communications control
/// mechanism. Protocol conversations are provided through extensions
/// from this object.
///
///
///
class TCPSession : public TCPSocket {
class TCPSession : public TCPSocket
{
public:
public:
///
///
///
///
///
///
TCPSession(EPoll &ePoll, TCPServer &server, std::string text = "");
TCPSession(EPoll &ePoll, TCPServer &server, std::string text = "");
///
///
///
///
///
///
virtual ~TCPSession();
virtual ~TCPSession();
Command *grab = NULL;
Command *grab = NULL;
virtual void output(std::stringstream &data);
virtual void output(std::stringstream &data);
///
/// The send method is used to output the contents of the out stream
/// to the session containing the stream.
///
///
/// The send method is used to output the contents of the out stream
/// to the session containing the stream.
///
void send();
void send();
///
/// Use this method to terminate this TCPSession.
///
///
/// Use this method to terminate this TCPSession.
///
void terminate();
void terminate();
///
///
///
///
///
///
TCPServer &server;
TCPServer &server;
///
/// Use out to send data to the session socket or other session sockets.
///
///
/// Use out to send data to the session socket or other session sockets.
///
std::stringstream out;
std::stringstream out;
char uuid[37];
protected:
void *alias;
///
///
///
protected:
///
///
///
virtual void onRegistered() override;
virtual void onRegistered() override;
///
/// Override this method to receive data directly from the socket as data is
/// received. If you need data split by line termination characters then
/// override the onLineReceived method instead.
///
virtual void onDataReceived(coreutils::ZString &data) override;
///
/// Override this method to receive data directly from the socket as data is
/// received. If you need data split by line termination characters then
/// override the onLineReceived method instead.
///
virtual void onDataReceived(coreutils::ZString &data) override;
///
/// Override the onLineReceived method to receive a string of characters that
/// represents a single line of data terminated by a LF or CRLF. If onDataReceived
/// was overriden this method will not be called unless the onDataReceived calls
/// this method explicitly using the class and member name.
///
///
/// Override the onLineReceived method to receive a string of characters that
/// represents a single line of data terminated by a LF or CRLF. If onDataReceived
/// was overriden this method will not be called unless the onDataReceived calls
/// this method explicitly using the class and member name.
///
virtual void onLineReceived(coreutils::ZString &line);
virtual void onLineReceived(coreutils::ZString &line);
///
/// Override the onBlockReceived method to receive a string of characters that
/// represents a single block of data of length determined by the block length value. If
/// onDataReceived was overriden this method will not be called unless the onDataReceived
/// calls this method explicitly using the class and member name.
///
///
/// Override the onBlockReceived method to receive a string of characters that
/// represents a single block of data of length determined by the block length value. If
/// onDataReceived was overriden this method will not be called unless the onDataReceived
/// calls this method explicitly using the class and member name.
///
virtual void onBlockReceived(coreutils::ZString &block);
virtual void onBlockReceived(coreutils::ZString &block);
///
/// This method is called from within the protocol method when protocol is called
/// on the initial connection where the data is an empty string. Use this method
/// to deliver a message to the connection upon connection.
///
///
/// This method is called from within the protocol method when protocol is called
/// on the initial connection where the data is an empty string. Use this method
/// to deliver a message to the connection upon connection.
///
virtual void onConnected();
virtual void onConnected();
///
/// Override the protocol method to manage and control the session communications
/// in your inherited session. If you do not override this method then the Session
/// default will process the 'commands' added to the server object using the
/// processRequest method on the session input.
///
/// When data is received within the session two modes are available to pass the
/// data through the protocol method: LINE or BLOCK.
///
///
/// Override the protocol method to manage and control the session communications
/// in your inherited session. If you do not override this method then the Session
/// default will process the 'commands' added to the server object using the
/// processRequest method on the session input.
///
/// When data is received within the session two modes are available to pass the
/// data through the protocol method: LINE or BLOCK.
///
virtual void protocol(coreutils::ZString &data);
virtual void protocol(coreutils::ZString &data);
///
/// Use setBlockSize to set the amount of data that should be read at once from the
/// session data buffer.
/// If this value is set to 0 then the data will be retrieved
///
///
/// Use setBlockSize to set the amount of data that should be read at once from the
/// session data buffer.
/// If this value is set to 0 then the data will be retrieved
///
void setBlockSize(int size = 0);
void setBlockSize(int size = 0);
private:
char *lineBuffer = NULL;
int lineBufferSize = 0;
int lineLength = 0;
int blockLength = 0;
std::mutex mtx;
bool term = false;
int blockSize = 0;
};
private:
char *lineBuffer = NULL;
int lineBufferSize = 0;
int lineLength = 0;
int blockLength = 0;
std::mutex mtx;
bool term = false;
int blockSize = 0;
};
}

BIN
output/main
View File

Binary file not shown.