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;
}
}

11
SessionFilter.h
View File

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

80
Socket.cpp
View File

@ -1,20 +1,23 @@
#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;
@ -24,8 +27,10 @@ namespace core {
close(descriptor);
}
void Socket::setDescriptor(int descriptor) {
if((descriptor == -1) && (errno == 24)) {
void Socket::setDescriptor(int descriptor)
{
if ((descriptor == -1) && (errno == 24))
{
shutdown("Too many files open");
throw coreutils::Exception("Too many files open. Refusing connection.");
}
@ -38,17 +43,19 @@ namespace core {
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,35 +67,43 @@ namespace core {
void Socket::onUnregistered() {}
bool Socket::eventReceived(struct epoll_event event) {
bool Socket::eventReceived(struct epoll_event event)
{
inHandler = true;
if(event.events & EPOLLRDHUP) {
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);
}
else if(event.events & EPOLLWRNORM) {
else if (event.events & EPOLLWRNORM)
{
writeSocket();
}
else if(event.events & EPOLLHUP) {
else if (event.events & EPOLLHUP)
{
shutdown();
}
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("");
@ -98,16 +113,19 @@ namespace core {
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);
}
else {
else
{
error = errno;
switch (error) {
switch (error)
{
// When a listening socket receives a connection
// request we get one of these.
@ -125,8 +143,10 @@ namespace core {
}
}
void Socket::writeSocket() {
if(fifo.size() > 0) {
void Socket::writeSocket()
{
if (fifo.size() > 0)
{
outlock.lock();
if (!shutDown)
::write(descriptor, fifo.front().c_str(), fifo.front().length());
@ -135,7 +155,8 @@ namespace core {
}
}
int Socket::write(std::string data) {
int Socket::write(std::string data)
{
outlock.lock();
fifo.emplace(data);
outlock.unlock();
@ -144,15 +165,18 @@ namespace core {
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;

6
Subscription.cpp
View File

@ -76,6 +76,12 @@ namespace core
return 0;
}
bool Subscription::subInvite(TCPSession &session)
{
return 0;
}
// void Subscription::setHandler(SubscriptionHandler *handlers)
// {
// handler = handlers;

2
Subscription.h
View File

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

23
SubscriptionManager.cpp
View File

@ -1,6 +1,7 @@
#include "SubscriptionManager.h"
#include "Log.h"
#include "Subscription.h"
#include "TCPServer.h"
#include <algorithm>
namespace core
@ -8,14 +9,16 @@ 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;
@ -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)

71
TCPServer.cpp
View File

@ -1,13 +1,15 @@
#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");
@ -15,6 +17,7 @@ namespace core {
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;
@ -25,15 +28,16 @@ namespace core {
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)
@ -41,9 +45,11 @@ namespace core {
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));
@ -59,41 +65,50 @@ namespace core {
// }
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) {
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;
@ -101,20 +116,23 @@ namespace core {
return 1;
}
void TCPServer::sendToAll(std::stringstream &data) {
void TCPServer::sendToAll(std::stringstream &data)
{
for (auto session : sessions)
session->write(data.str());
data.str("");
}
void TCPServer::sendToAll(std::stringstream &data, TCPSession &sender) {
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) {
void TCPServer::sendToAll(std::stringstream &data, TCPSession &sender, SessionFilter filter)
{
for (auto session : sessions)
if (filter.test(*session))
if (session != &sender)
@ -122,4 +140,17 @@ namespace core {
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;
}
}

27
TCPServer.h
View File

@ -1,14 +1,16 @@
#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
@ -22,10 +24,10 @@ namespace core {
/// process commands to display status information.
///
class TCPServer : public TCPSocket, public Command {
class TCPServer : public TCPSocket, public Command
{
public:
///
/// The constructor for the TCPServer object.
///
@ -44,7 +46,7 @@ namespace core {
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.
@ -115,8 +117,14 @@ namespace core {
SubscriptionManager subscriptions;
protected:
///
/// Use the getSessionByAlias to retrieve a session pointer by the value
/// of the alias pointer.
///
TCPSession *getSessionByAlias(void *alias);
protected:
///
/// Override the virtual dataReceived since for the server these
/// are requests to accept the new connection socket.
@ -139,11 +147,10 @@ namespace core {
int processCommand(coreutils::ZString &request, TCPSession &session) override;
private:
TCPSession *accept();
std::mutex lock;
};
/// This method is called when you compare an alias of the character
}

64
TCPSession.cpp
View File

@ -1,30 +1,45 @@
#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)) {
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);
@ -35,13 +50,17 @@ namespace core {
void TCPSession::onConnected() {}
void TCPSession::onDataReceived(coreutils::ZString &data) {
if(data.getLength() > 0) {
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) {
while (lineBufferSize > 0)
{
if (blockSize == 0)
{
lineLength = strcspn(lineBuffer, "\r\n");
if (lineLength == lineBufferSize)
break;
@ -55,7 +74,9 @@ namespace core {
if (lineBufferSize > 0)
memmove(lineBuffer, lineBuffer + lineLength, lineBufferSize);
lineBuffer = (char *)realloc(lineBuffer, lineBufferSize);
} else if(lineBufferSize >= blockLength) {
}
else if (lineBufferSize >= blockLength)
{
coreutils::ZString zBlock(lineBuffer, blockLength);
onBlockReceived(zBlock);
lineBufferSize -= blockLength;
@ -67,30 +88,35 @@ namespace core {
}
}
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");
}
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");
}
void TCPSession::send() {
void TCPSession::send()
{
if (out.tellp() > 0)
write(out.str());
out.str("");
}
void TCPSession::terminate() {
void TCPSession::terminate()
{
term = true;
}

15
TCPSession.h
View File

@ -1,10 +1,11 @@
#ifndef __Session_h__
#define __Session_h__
#include "TCPSocket.h"
#include "SessionFilter.h"
#include "TCPSocket.h"
namespace core {
namespace core
{
class Command;
class TCPServer;
@ -21,10 +22,10 @@ namespace core {
///
///
class TCPSession : public TCPSocket {
class TCPSession : public TCPSocket
{
public:
///
///
///
@ -66,8 +67,11 @@ namespace core {
std::stringstream out;
protected:
char uuid[37];
void *alias;
protected:
///
///
///
@ -135,7 +139,6 @@ namespace core {
std::mutex mtx;
bool term = false;
int blockSize = 0;
};
}

BIN
output/main
View File

Binary file not shown.