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

merged in publish handlers.

Browse Source
This commit is contained in:
Brad Arant 2023-02-09 11:38:09 -08:00
commit d8eb3d7bb2
160 changed files with 1141 additions and 11240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@ -9,3 +9,6 @@ docs/latex/
docs/html
*/*.ipch
*/mmap_address.bin
.history/*
html
latex

100
.history/SubscriptionManager_20221013230931.cpp
View File

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

127
.history/SubscriptionManager_20221013231054.cpp
View File

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

127
.history/SubscriptionManager_20221013232529.cpp
View File

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

128
.history/SubscriptionManager_20221013232559.cpp
View File

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

128
.history/SubscriptionManager_20221013232603.cpp
View File

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

128
.history/SubscriptionManager_20221013232637.cpp
View File

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

128
.history/SubscriptionManager_20221013232709.cpp
View File

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

127
.history/SubscriptionManager_20221013232718.cpp
View File

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

141
.history/SubscriptionManager_20221014001552.cpp
View File

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

141
.history/SubscriptionManager_20221014001640.cpp
View File

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

141
.history/SubscriptionManager_20221014001750.cpp
View File

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

141
.history/SubscriptionManager_20221014001801.cpp
View File

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

141
.history/SubscriptionManager_20221014001829.cpp
View File

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

141
.history/SubscriptionManager_20221014001848.cpp
View File

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

141
.history/SubscriptionManager_20221014002019.cpp
View File

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

141
.history/SubscriptionManager_20221014002052.cpp
View File

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

141
.history/SubscriptionManager_20221014002112.cpp
View File

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

141
.history/SubscriptionManager_20221014002118.cpp
View File

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

141
.history/SubscriptionManager_20221014002130.cpp
View File

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

141
.history/SubscriptionManager_20221014002136.cpp
View File

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

142
.history/SubscriptionManager_20221014002203.cpp
View File

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

142
.history/SubscriptionManager_20221014002300.cpp
View File

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

142
.history/SubscriptionManager_20221014002351.cpp
View File

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

142
.history/SubscriptionManager_20221014002355.cpp
View File

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

142
.history/SubscriptionManager_20221014002404.cpp
View File

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

142
.history/SubscriptionManager_20221014002416.cpp
View File

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

142
.history/SubscriptionManager_20221014002543.cpp
View File

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

142
.history/SubscriptionManager_20221014002547.cpp
View File

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

142
.history/SubscriptionManager_20221014002751.cpp
View File

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

142
.history/SubscriptionManager_20221014002909.cpp
View File

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

142
.history/SubscriptionManager_20221014002931.cpp
View File

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

141
.history/SubscriptionManager_20221014002952.cpp
View File

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

146
.history/SubscriptionManager_20221014003012.cpp
View File

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

146
.history/SubscriptionManager_20221014003016.cpp
View File

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

146
.history/SubscriptionManager_20221014003032.cpp
View File

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

146
.history/SubscriptionManager_20221014003110.cpp
View File

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

146
.history/SubscriptionManager_20221014003112.cpp
View File

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

146
.history/SubscriptionManager_20221014003118.cpp
View File

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

142
.history/SubscriptionManager_20221014003740.cpp
View File

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

142
.history/SubscriptionManager_20221014003842.cpp
View File

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

142
.history/SubscriptionManager_20221014224510.cpp
View File

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

142
.history/SubscriptionManager_20221015132404.cpp
View File

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

146
.history/SubscriptionManager_20221015135839.cpp
View File

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

146
.history/SubscriptionManager_20221015140050.cpp
View File

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

146
.history/SubscriptionManager_20221015140147.cpp
View File

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

146
.history/SubscriptionManager_20221015140432.cpp
View File

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

146
.history/SubscriptionManager_20221015140547.cpp
View File

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

146
.history/SubscriptionManager_20221015140637.cpp
View File

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

146
.history/SubscriptionManager_20221015140703.cpp
View File

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

146
.history/SubscriptionManager_20221015140849.cpp
View File

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

146
.history/SubscriptionManager_20221015140915.cpp
View File

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

146
.history/SubscriptionManager_20221015141339.cpp
View File

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

146
.history/SubscriptionManager_20221015141418.cpp
View File

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

147
.history/SubscriptionManager_20221015141638.cpp
View File

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

146
.history/SubscriptionManager_20221015180125.cpp
View File

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

146
.history/SubscriptionManager_20221015181249.cpp
View File

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

146
.history/SubscriptionManager_20221015181639.cpp
View File

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

146
.history/SubscriptionManager_20221015181912.cpp
View File

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

143
.history/SubscriptionManager_20221015182122.cpp
View File

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

143
.history/SubscriptionManager_20221015183109.cpp
View File

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

144
.history/SubscriptionManager_20221015183204.cpp
View File

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

146
.history/SubscriptionManager_20221015183209.cpp
View File

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

146
.history/SubscriptionManager_20221015183518.cpp
View File

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

147
.history/SubscriptionManager_20221015191146.cpp
View File

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

147
.history/SubscriptionManager_20221015193901.cpp
View File

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

147
.history/SubscriptionManager_20221015200446.cpp
View File

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

147
.history/SubscriptionManager_20221015200502.cpp
View File

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

147
.history/SubscriptionManager_20221015201500.cpp
View File

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

147
.history/SubscriptionManager_20221015201542.cpp
View File

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

147
.history/SubscriptionManager_20221015201557.cpp
View File

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

148
.history/SubscriptionManager_20221016174159.cpp
View File

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

148
.history/SubscriptionManager_20221016174206.cpp
View File

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

148
.history/SubscriptionManager_20221016175448.cpp
View File

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

148
.history/SubscriptionManager_20221016180238.cpp
View File

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

15
SessionFilter.h
View File

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

74
Socket.cpp
View File

@ -1,14 +1,16 @@
#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) {
coreutils::Log(coreutils::LOG_DEBUG_2) << "Socket object created [" << text << "].";
buffer = (char *)malloc(4096);
length = 4096;
}
@ -17,21 +19,22 @@ namespace core {
shutDown = true;
onUnregister();
ePoll.unregisterSocket(this);
coreutils::Log(coreutils::LOG_DEBUG_4) << "Free on socket " << descriptor;
free(buffer);
if(descriptor == -1)
return;
close(descriptor);
coreutils::Log(coreutils::LOG_DEBUG_1) << text << " has ended (" << descriptor << ").";
sleep(1);
}
void Socket::setDescriptor(int descriptor) {
if((descriptor == -1) && (errno == 24)) {
shutdown("Too many files open");
throw coreutils::Exception("Too many files open. Refusing connection.");
void Socket::setDescriptor(int descriptor)
{
if ((descriptor == -1) && (errno == 24))
{
shutdown("Too many files open");
throw coreutils::Exception("Too many files open. Refusing connection.");
}
coreutils::Log(coreutils::LOG_DEBUG_1) << text << " has started (" << descriptor << ").";
// coreutils::Log(coreutils::LOG_DEBUG_3) << "Descriptor set to " << descriptor << " for Socket.";
if(descriptor < 3)
throw coreutils::Exception("Descriptor out of range", __FILE__, __LINE__);
this->descriptor = descriptor;
@ -40,16 +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;
}
@ -70,7 +76,7 @@ namespace core {
}
if(event.events & EPOLLIN) {
coreutils::ZString zbuffer(buffer, length);
receiveData(zbuffer);
receiveData(zbuffer);
}
if(event.events & EPOLLWRNORM) {
writeSocket();
@ -83,11 +89,13 @@ namespace core {
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()));
}
@ -100,27 +108,29 @@ namespace core {
if((len = ::read(getDescriptor(), buffer.getData(), buffer.getLength())) >= 0) {
coreutils::ZString zbuffer(buffer.getData(), len);
coreutils::Log(coreutils::LOG_DEBUG_1) << zbuffer;
onDataReceived(zbuffer);
onDataReceived(zbuffer);
}
else {
else
{
error = errno;
error = errno;
switch (error) {
switch (error)
{
// When a listening socket receives a connection
// request we get one of these.
//
case ENOTCONN:
// When a listening socket receives a connection
// request we get one of these.
//
case ENOTCONN:
onDataReceived(blank);
break;
case ECONNRESET:
break;
default:
case ECONNRESET:
break;
default:
throw coreutils::Exception("Error in read of data from socket.", __FILE__, __LINE__, error);
}
}
}
}
@ -130,7 +140,7 @@ namespace core {
if(!shutDown)
int rc = ::write(descriptor, fifo.front().c_str(), fifo.front().length());
fifo.pop();
outlock.unlock();
outlock.unlock();
}
}
@ -145,11 +155,13 @@ 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;
}

24
Subscription.cpp
View File

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

4
Subscription.h
View File

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

21
SubscriptionManager.cpp
View File

@ -1,6 +1,7 @@
#include "SubscriptionManager.h"
#include "Log.h"
#include "Subscription.h"
#include "TCPServer.h"
#include <algorithm>
namespace core
@ -60,8 +61,8 @@ namespace core
{
if (request[0].equals("publish"))
{
SubscriptionHandler *handler = handlers[request[3].str()];
newSubscription = new Subscription(request[1].str(), session, request[2].str(), handler);
SubscriptionHandler *handler = handlers[request[3].str()];
newSubscription = new Subscription(request[1].str(), session, request[2].str(), handler);
subscriptions.insert(std::make_pair(request[1].str(), newSubscription));
return 1;
@ -77,7 +78,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 +109,7 @@ namespace core
subscription->unsubscribe(session);
return 1;
}
else if (request[0].equals("event"))
{
std::stringstream out;
@ -113,6 +127,7 @@ namespace core
return 1;
}
}
else if (subscription->mode == "*AUTHOR")
{
if (subscription->owner == &session)

105
TCPServer.cpp
View File

@ -1,12 +1,14 @@
#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)
<<<<<<< HEAD
: TCPSocket(ePoll, text), commands(delimiter, depth) {
commands.add(subscriptions, "publish");
@ -27,8 +29,32 @@ namespace core {
throw coreutils::Exception("Error on listen to socket");
}
=======
: TCPSocket(ePoll, text), commands(delimiter, depth)
{
>>>>>>> subscription
TCPServer::~TCPServer() {
commands.add(subscriptions, "publish");
commands.add(subscriptions, "unpublish");
commands.add(subscriptions, "subscribe");
commands.add(subscriptions, "unsubscribe");
commands.add(subscriptions, "catalog");
commands.add(subscriptions, "event");
commands.add(subscriptions, "invite");
setDescriptor(socket(AF_INET, SOCK_STREAM, 0));
int yes = 1;
setsockopt(getDescriptor(), SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
if (bind(getDescriptor(), address.getPointer(), address.addressLength) < 0)
throw coreutils::Exception("Error on bind to socket: " + std::to_string(errno));
if (listen(getDescriptor(), 20) < 0)
throw coreutils::Exception("Error on listen to socket");
}
TCPServer::~TCPServer()
{
coreutils::Log(coreutils::LOG_DEBUG_2) << "Closing server socket " << getDescriptor() << ".";
close(getDescriptor());
}
@ -36,8 +62,8 @@ namespace core {
void TCPServer::onDataReceived(std::string data) {
lock.lock();
TCPSession *session = accept();
if(session)
sessions.push_back(session);
if (session)
sessions.push_back(session);
lock.unlock();
}
@ -47,22 +73,24 @@ namespace core {
TCPSession *session = getSocketAccept(ePoll);
session->setDescriptor(::accept(getDescriptor(), (struct sockaddr *)&session->ipAddress.addr, &session->ipAddress.addressLength));
// if(blackList && blackList->contains(session->ipAddress.getClientAddress())) {
// session->shutdown();
// Log(LOG_WARN) << "Client at IP address " << session->ipAddress.getClientAddress() << " is blacklisted and was denied a connection.";
// return NULL;
// }
// if(whiteList && !whiteList->contains(session->ipAddress.getClientAddress())) {
// session->shutdown();
// Log(LOG_WARN) << "Client at IP address " << session->ipAddress.getClientAddress() << " is not authorized and was denied a connection.";
// return NULL;
// }
// if(blackList && blackList->contains(session->ipAddress.getClientAddress())) {
// session->shutdown();
// Log(LOG_WARN) << "Client at IP address " << session->ipAddress.getClientAddress() << " is blacklisted and was denied a connection.";
// return NULL;
// }
// if(whiteList && !whiteList->contains(session->ipAddress.getClientAddress())) {
// session->shutdown();
// Log(LOG_WARN) << "Client at IP address " << session->ipAddress.getClientAddress() << " is not authorized and was denied a connection.";
// return NULL;
// }
return session;
}
catch(coreutils::Exception e) {
catch (coreutils::Exception e)
{
coreutils::Log(coreutils::LOG_EXCEPT) << "Major error on session initialization. Error is '" << e.text << "'.";
}
catch(...) {
catch (...)
{
coreutils::Log(coreutils::LOG_EXCEPT) << "Unnspecified error on session initialization.";
}
return NULL;
@ -93,7 +121,8 @@ namespace core {
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,25 +130,41 @@ namespace core {
return 1;
}
void TCPServer::sendToAll(std::stringstream &data) {
for(auto session : sessions)
session->write(data.str(), NULL);
void TCPServer::sendToAll(std::stringstream &data)
{
for (auto session : sessions)
session->write(data.str());
data.str("");
}
void TCPServer::sendToAll(std::stringstream &data, TCPSession &sender) {
for(auto session : sessions)
if(session != &sender)
session->write(data.str(), &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) {
for(auto session : sessions)
if(filter.test(*session))
if(session != &sender)
session->write(data.str(), &sender);
void TCPServer::sendToAll(std::stringstream &data, TCPSession &sender, SessionFilter filter)
{
for (auto session : sessions)
if (filter.test(*session))
if (session != &sender)
session->write(data.str());
data.str("");
}
TCPSession *TCPServer::getSessionByAlias(void *alias)
{
coreutils::Log(coreutils::LOG_DEBUG_1) << alias;
for (auto session : sessions)
if (compareAlias(session->alias, alias))
return session;
return NULL;
}
bool TCPServer::compareAlias(void *alias, void *compare)
{
return alias == compare;
}
}

219
TCPServer.h
View File

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

122
TCPSession.cpp
View File

@ -1,84 +1,111 @@
#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(server.commands.processRequest(data, *this) == 0)
coreutils::Log(coreutils::LOG_DEBUG_1) << "Received data could not be parsed: " << getDescriptor() << " [" << data.str() << "]";
void TCPSession::protocol(coreutils::ZString &data)
{
if (data.getLength() != 0)
{
if (!server.commands.processRequest(data, *this))
{
coreutils::Log(coreutils::LOG_DEBUG_1) << "Received data could not be parsed: " << data.str();
}
}
}
void TCPSession::onRegistered() {
void TCPSession::onRegistered()
{
onConnected();
// coreutils::ZString blank("");
// protocol(blank);
send();
if(term)
shutdown("termination requested");
if (term)
shutdown("termination requested");
}
void TCPSession::onConnected() {}
void TCPSession::onDataReceived(coreutils::ZString &data) {
if(data.getLength() > 0) {
lineBuffer = (char *)realloc(lineBuffer, lineBufferSize + data.getLength());
memcpy(lineBuffer + lineBufferSize, data.getData(), data.getLength());
lineBufferSize += data.getLength();
while(lineBufferSize > 0) {
if(blockSize == 0) {
lineLength = strcspn(lineBuffer, "\r\n");
if(lineLength == lineBufferSize)
break;
void TCPSession::onDataReceived(coreutils::ZString &data)
{
if (data.getLength() > 0)
{
lineBuffer = (char *)realloc(lineBuffer, lineBufferSize + data.getLength());
memcpy(lineBuffer + lineBufferSize, data.getData(), data.getLength());
lineBufferSize += data.getLength();
while (lineBufferSize > 0)
{
if (blockSize == 0)
{
lineLength = strcspn(lineBuffer, "\r\n");
if (lineLength == lineBufferSize)
break;
coreutils::ZString zLine(lineBuffer, lineLength);
onLineReceived(zLine);
if(lineBuffer[lineLength] == '\r')
++lineLength;
if(lineBuffer[lineLength] == '\n')
++lineLength;
lineBufferSize -= lineLength;
if(lineBufferSize > 0)
memmove(lineBuffer, lineBuffer + lineLength, lineBufferSize);
lineBuffer = (char *)realloc(lineBuffer, lineBufferSize);
} else if(lineBufferSize >= blockLength) {
coreutils::ZString zBlock(lineBuffer, blockLength);
onBlockReceived(zBlock);
lineBufferSize -= blockLength;
if(lineBufferSize > 0)
memmove(lineBuffer, lineBuffer + blockLength, lineBufferSize);
lineBuffer = (char *)realloc(lineBuffer, lineBufferSize);
}
}
onLineReceived(zLine);
if (lineBuffer[lineLength] == '\r')
++lineLength;
if (lineBuffer[lineLength] == '\n')
++lineLength;
lineBufferSize -= lineLength;
if (lineBufferSize > 0)
memmove(lineBuffer, lineBuffer + lineLength, lineBufferSize);
lineBuffer = (char *)realloc(lineBuffer, lineBufferSize);
}
else if (lineBufferSize >= blockLength)
{
coreutils::ZString zBlock(lineBuffer, blockLength);
onBlockReceived(zBlock);
lineBufferSize -= blockLength;
if (lineBufferSize > 0)
memmove(lineBuffer, lineBuffer + blockLength, lineBufferSize);
lineBuffer = (char *)realloc(lineBuffer, lineBufferSize);
}
}
}
}
void TCPSession::setBlockSize(int blockSize) {
void TCPSession::setBlockSize(int blockSize)
{
this->blockSize = blockSize;
}
void TCPSession::onLineReceived(coreutils::ZString &line) {
void TCPSession::onLineReceived(coreutils::ZString &line)
{
protocol(line);
send();
if(term)
shutdown("termination requested");
if (term)
shutdown("termination requested");
}
void TCPSession::onBlockReceived(coreutils::ZString &block) {
void TCPSession::onBlockReceived(coreutils::ZString &block)
{
coreutils::Log(coreutils::LOG_DEBUG_3) << "[" << block.getLength() << "]";
if(term)
shutdown("termination requested");
if (term)
shutdown("termination requested");
}
void TCPSession::send() {
@ -87,7 +114,8 @@ namespace core {
out.str("");
}
void TCPSession::terminate() {
void TCPSession::terminate()
{
term = true;
}

207
TCPSession.h
View File

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

2
html/CommandList_8h_source.html
View File

@ -119,7 +119,7 @@ $(function() {
<div class="ttc" id="aclasscore_1_1CommandList_html_abcfb26e37e1ee6ff5655ebc3d33b1818"><div class="ttname"><a href="classcore_1_1CommandList.html#abcfb26e37e1ee6ff5655ebc3d33b1818">core::CommandList::processRequest</a></div><div class="ttdeci">int processRequest(coreutils::ZString &amp;request, TCPSession &amp;session)</div><div class="ttdef"><b>Definition:</b> CommandList.cpp:14</div></div>
<div class="ttc" id="aclasscore_1_1CommandList_html_ad0aedf95828fe743908d8423f171ff36"><div class="ttname"><a href="classcore_1_1CommandList.html#ad0aedf95828fe743908d8423f171ff36">core::CommandList::commands</a></div><div class="ttdeci">std::map&lt; std::string, Command * &gt; commands</div><div class="ttdef"><b>Definition:</b> CommandList.h:71</div></div>
<div class="ttc" id="aclasscore_1_1Command_html"><div class="ttname"><a href="classcore_1_1Command.html">core::Command</a></div><div class="ttdef"><b>Definition:</b> Command.h:22</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:24</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:26</div></div>
</div><!-- fragment --></div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>

2
html/Command_8h_source.html
View File

@ -98,7 +98,7 @@ $(function() {
<div class="ttc" id="aclasscore_1_1Command_html"><div class="ttname"><a href="classcore_1_1Command.html">core::Command</a></div><div class="ttdef"><b>Definition:</b> Command.h:22</div></div>
<div class="ttc" id="aclasscore_1_1Command_html_a95176f2532c38ee14e3fee40ee28b1bd"><div class="ttname"><a href="classcore_1_1Command.html#a95176f2532c38ee14e3fee40ee28b1bd">core::Command::processCommand</a></div><div class="ttdeci">virtual int processCommand(coreutils::ZString &amp;request, TCPSession &amp;session)</div><div class="ttdef"><b>Definition:</b> Command.cpp:7</div></div>
<div class="ttc" id="aclasscore_1_1Command_html_ab6352ce5650e70a5c76c3d6e4eefd292"><div class="ttname"><a href="classcore_1_1Command.html#ab6352ce5650e70a5c76c3d6e4eefd292">core::Command::output</a></div><div class="ttdeci">virtual void output(std::stringstream &amp;out)</div><div class="ttdef"><b>Definition:</b> Command.cpp:11</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:24</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:26</div></div>
</div><!-- fragment --></div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>

4
html/ConsoleServer_8h_source.html
View File

@ -107,8 +107,8 @@ $(function() {
<div class="ttc" id="aclasscore_1_1ConsoleServer_html_a80d9ea7f3fc5e07c50d5b9e0d4943ca8"><div class="ttname"><a href="classcore_1_1ConsoleServer.html#a80d9ea7f3fc5e07c50d5b9e0d4943ca8">core::ConsoleServer::getSocketAccept</a></div><div class="ttdeci">TCPSession * getSocketAccept(EPoll &amp;ePoll) override</div><div class="ttdef"><b>Definition:</b> ConsoleServer.cpp:17</div></div>
<div class="ttc" id="aclasscore_1_1EPoll_html"><div class="ttname"><a href="classcore_1_1EPoll.html">core::EPoll</a></div><div class="ttdef"><b>Definition:</b> EPoll.h:31</div></div>
<div class="ttc" id="aclasscore_1_1IPAddress_html"><div class="ttname"><a href="classcore_1_1IPAddress.html">core::IPAddress</a></div><div class="ttdef"><b>Definition:</b> IPAddress.h:9</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html"><div class="ttname"><a href="classcore_1_1TCPServer.html">core::TCPServer</a></div><div class="ttdef"><b>Definition:</b> TCPServer.h:25</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:24</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html"><div class="ttname"><a href="classcore_1_1TCPServer.html">core::TCPServer</a></div><div class="ttdef"><b>Definition:</b> TCPServer.h:28</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:26</div></div>
</div><!-- fragment --></div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>

2
html/ConsoleSession_8h_source.html
View File

@ -102,7 +102,7 @@ $(function() {
<div class="ttc" id="aclasscore_1_1ConsoleSession_html"><div class="ttname"><a href="classcore_1_1ConsoleSession.html">core::ConsoleSession</a></div><div class="ttdef"><b>Definition:</b> ConsoleSession.h:20</div></div>
<div class="ttc" id="aclasscore_1_1ConsoleSession_html_aa1818efcd33a4152d2089aa545f08833"><div class="ttname"><a href="classcore_1_1ConsoleSession.html#aa1818efcd33a4152d2089aa545f08833">core::ConsoleSession::protocol</a></div><div class="ttdeci">void protocol(coreutils::ZString &amp;data) override</div><div class="ttdef"><b>Definition:</b> ConsoleSession.cpp:11</div></div>
<div class="ttc" id="aclasscore_1_1EPoll_html"><div class="ttname"><a href="classcore_1_1EPoll.html">core::EPoll</a></div><div class="ttdef"><b>Definition:</b> EPoll.h:31</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html"><div class="ttname"><a href="classcore_1_1TCPServer.html">core::TCPServer</a></div><div class="ttdef"><b>Definition:</b> TCPServer.h:25</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html"><div class="ttname"><a href="classcore_1_1TCPServer.html">core::TCPServer</a></div><div class="ttdef"><b>Definition:</b> TCPServer.h:28</div></div>
<div class="ttc" id="aclasscore_1_1TerminalSession_html"><div class="ttname"><a href="classcore_1_1TerminalSession.html">core::TerminalSession</a></div><div class="ttdef"><b>Definition:</b> TerminalSession.h:30</div></div>
</div><!-- fragment --></div><!-- contents -->
<!-- start footer part -->

2
html/EPoll_8h_source.html
View File

@ -147,7 +147,7 @@ $(function() {
<div class="ttc" id="aclasscore_1_1EPoll_html_aaefe2caef75eb538af90cb34682d277b"><div class="ttname"><a href="classcore_1_1EPoll.html#aaefe2caef75eb538af90cb34682d277b">core::EPoll::start</a></div><div class="ttdeci">bool start(int numberOfThreads, int maxSockets)</div><div class="ttdoc">Start the BMAEPoll processing.</div><div class="ttdef"><b>Definition:</b> EPoll.cpp:20</div></div>
<div class="ttc" id="aclasscore_1_1EPoll_html_acfcef2513d94f7b9a191fed3dc744d90"><div class="ttname"><a href="classcore_1_1EPoll.html#acfcef2513d94f7b9a191fed3dc744d90">core::EPoll::maxSockets</a></div><div class="ttdeci">int maxSockets</div><div class="ttdoc">The maximum number of socket allowed.</div><div class="ttdef"><b>Definition:</b> EPoll.h:100</div></div>
<div class="ttc" id="aclasscore_1_1Socket_html"><div class="ttname"><a href="classcore_1_1Socket.html">core::Socket</a></div><div class="ttdef"><b>Definition:</b> Socket.h:34</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:24</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:26</div></div>
</div><!-- fragment --></div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>

37
html/SessionFilter_8h_source.html
View File

@ -69,26 +69,29 @@ $(function() {
<div class="line"><a name="l00002"></a><span class="lineno"> 2</span>&#160;<span class="preprocessor">#define __SessionFilter_h__</span></div>
<div class="line"><a name="l00003"></a><span class="lineno"> 3</span>&#160; </div>
<div class="line"><a name="l00004"></a><span class="lineno"> 4</span>&#160;<span class="comment">//#include &quot;Session.h&quot;</span></div>
<div class="line"><a name="l00005"></a><span class="lineno"> 5</span>&#160; </div>
<div class="line"><a name="l00006"></a><span class="lineno"> 6</span>&#160;<span class="keyword">namespace </span>core {</div>
<div class="line"><a name="l00007"></a><span class="lineno"> 7</span>&#160; </div>
<div class="line"><a name="l00008"></a><span class="lineno"> 8</span>&#160; <span class="keyword">class </span>TCPSession;</div>
<div class="line"><a name="l00005"></a><span class="lineno"> 5</span>&#160;<span class="preprocessor">#include &quot;Object.h&quot;</span></div>
<div class="line"><a name="l00006"></a><span class="lineno"> 6</span>&#160; </div>
<div class="line"><a name="l00007"></a><span class="lineno"> 7</span>&#160;<span class="keyword">namespace </span>core</div>
<div class="line"><a name="l00008"></a><span class="lineno"> 8</span>&#160;{</div>
<div class="line"><a name="l00009"></a><span class="lineno"> 9</span>&#160; </div>
<div class="line"><a name="l00010"></a><span class="lineno"><a class="line" href="classcore_1_1SessionFilter.html"> 10</a></span>&#160; <span class="keyword">class </span><a class="code" href="classcore_1_1SessionFilter.html">SessionFilter</a> : <span class="keyword">public</span> <a class="code" href="classcore_1_1Object.html">Object</a> {</div>
<div class="line"><a name="l00010"></a><span class="lineno"> 10</span>&#160; <span class="keyword">class </span>TCPSession;</div>
<div class="line"><a name="l00011"></a><span class="lineno"> 11</span>&#160; </div>
<div class="line"><a name="l00012"></a><span class="lineno"> 12</span>&#160; <span class="keyword">public</span>:</div>
<div class="line"><a name="l00013"></a><span class="lineno"> 13</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">bool</span> test(<a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> &amp;session) {</div>
<div class="line"><a name="l00014"></a><span class="lineno"> 14</span>&#160; <span class="keywordflow">return</span> <span class="keyword">true</span>;</div>
<div class="line"><a name="l00015"></a><span class="lineno"> 15</span>&#160; }</div>
<div class="line"><a name="l00016"></a><span class="lineno"> 16</span>&#160; </div>
<div class="line"><a name="l00017"></a><span class="lineno"> 17</span>&#160; };</div>
<div class="line"><a name="l00018"></a><span class="lineno"> 18</span>&#160; </div>
<div class="line"><a name="l00019"></a><span class="lineno"> 19</span>&#160;}</div>
<div class="line"><a name="l00020"></a><span class="lineno"> 20</span>&#160; </div>
<div class="line"><a name="l00021"></a><span class="lineno"> 21</span>&#160;<span class="preprocessor">#endif</span></div>
<div class="line"><a name="l00012"></a><span class="lineno"><a class="line" href="classcore_1_1SessionFilter.html"> 12</a></span>&#160; <span class="keyword">class </span><a class="code" href="classcore_1_1SessionFilter.html">SessionFilter</a> : <span class="keyword">public</span> <a class="code" href="classcore_1_1Object.html">Object</a></div>
<div class="line"><a name="l00013"></a><span class="lineno"> 13</span>&#160; {</div>
<div class="line"><a name="l00014"></a><span class="lineno"> 14</span>&#160; </div>
<div class="line"><a name="l00015"></a><span class="lineno"> 15</span>&#160; <span class="keyword">public</span>:</div>
<div class="line"><a name="l00016"></a><span class="lineno"> 16</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">bool</span> test(<a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> &amp;session)</div>
<div class="line"><a name="l00017"></a><span class="lineno"> 17</span>&#160; {</div>
<div class="line"><a name="l00018"></a><span class="lineno"> 18</span>&#160; <span class="keywordflow">return</span> <span class="keyword">true</span>;</div>
<div class="line"><a name="l00019"></a><span class="lineno"> 19</span>&#160; }</div>
<div class="line"><a name="l00020"></a><span class="lineno"> 20</span>&#160; };</div>
<div class="line"><a name="l00021"></a><span class="lineno"> 21</span>&#160; </div>
<div class="line"><a name="l00022"></a><span class="lineno"> 22</span>&#160;}</div>
<div class="line"><a name="l00023"></a><span class="lineno"> 23</span>&#160; </div>
<div class="line"><a name="l00024"></a><span class="lineno"> 24</span>&#160;<span class="preprocessor">#endif</span></div>
<div class="ttc" id="aclasscore_1_1Object_html"><div class="ttname"><a href="classcore_1_1Object.html">core::Object</a></div><div class="ttdef"><b>Definition:</b> Object.h:8</div></div>
<div class="ttc" id="aclasscore_1_1SessionFilter_html"><div class="ttname"><a href="classcore_1_1SessionFilter.html">core::SessionFilter</a></div><div class="ttdef"><b>Definition:</b> SessionFilter.h:10</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:24</div></div>
<div class="ttc" id="aclasscore_1_1SessionFilter_html"><div class="ttname"><a href="classcore_1_1SessionFilter.html">core::SessionFilter</a></div><div class="ttdef"><b>Definition:</b> SessionFilter.h:13</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:26</div></div>
</div><!-- fragment --></div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>

15
html/Socket_8h_source.html
View File

@ -178,6 +178,7 @@ $(function() {
<div class="line"><a name="l00198"></a><span class="lineno"> 198</span>&#160; </div>
<div class="ttc" id="aclasscore_1_1EPoll_html"><div class="ttname"><a href="classcore_1_1EPoll.html">core::EPoll</a></div><div class="ttdef"><b>Definition:</b> EPoll.h:31</div></div>
<div class="ttc" id="aclasscore_1_1Socket_html"><div class="ttname"><a href="classcore_1_1Socket.html">core::Socket</a></div><div class="ttdef"><b>Definition:</b> Socket.h:34</div></div>
<<<<<<< HEAD
<div class="ttc" id="aclasscore_1_1Socket_html_a06ba54744530439d4131e6aba4623d08"><div class="ttname"><a href="classcore_1_1Socket.html#a06ba54744530439d4131e6aba4623d08">core::Socket::getDescriptor</a></div><div class="ttdeci">int getDescriptor()</div><div class="ttdoc">Get the descriptor for the socket.</div><div class="ttdef"><b>Definition:</b> Socket.cpp:43</div></div>
<div class="ttc" id="aclasscore_1_1Socket_html_a1a045e15fb5851d666a21be05ac4c5d7"><div class="ttname"><a href="classcore_1_1Socket.html#a1a045e15fb5851d666a21be05ac4c5d7">core::Socket::eventReceived</a></div><div class="ttdeci">bool eventReceived(struct epoll_event event, long long eventId)</div><div class="ttdoc">Parse epoll event and call specified callbacks.</div><div class="ttdef"><b>Definition:</b> Socket.cpp:64</div></div>
<div class="ttc" id="aclasscore_1_1Socket_html_a23b9824653bbe4652a716acb828665b1"><div class="ttname"><a href="classcore_1_1Socket.html#a23b9824653bbe4652a716acb828665b1">core::Socket::onRegistered</a></div><div class="ttdeci">virtual void onRegistered()</div><div class="ttdoc">Called after the socket has been registered with epoll processing.</div><div class="ttdef"><b>Definition:</b> Socket.cpp:58</div></div>
@ -190,6 +191,20 @@ $(function() {
<div class="ttc" id="aclasscore_1_1Socket_html_ac8d6a2c54696eb6fc2024cf6bcf6b4e5"><div class="ttname"><a href="classcore_1_1Socket.html#ac8d6a2c54696eb6fc2024cf6bcf6b4e5">core::Socket::onDataReceived</a></div><div class="ttdeci">virtual void onDataReceived(std::string data)</div><div class="ttdoc">Called when data is received from the socket.</div><div class="ttdef"><b>Definition:</b> Socket.cpp:86</div></div>
<div class="ttc" id="aclasscore_1_1Socket_html_ae9be59697c2b2e5efb19aaae3ba943d2"><div class="ttname"><a href="classcore_1_1Socket.html#ae9be59697c2b2e5efb19aaae3ba943d2">core::Socket::onUnregistered</a></div><div class="ttdeci">virtual void onUnregistered()</div><div class="ttdoc">Called when the socket has finished unregistering for the epoll processing.</div><div class="ttdef"><b>Definition:</b> Socket.cpp:62</div></div>
<div class="ttc" id="aclasscore_1_1Socket_html_af2d1b6de7a64a9d446b0305b6ec47b31"><div class="ttname"><a href="classcore_1_1Socket.html#af2d1b6de7a64a9d446b0305b6ec47b31">core::Socket::shutdown</a></div><div class="ttdeci">void shutdown(std::string text=&quot;unknown&quot;)</div><div class="ttdef"><b>Definition:</b> Socket.cpp:156</div></div>
=======
<div class="ttc" id="aclasscore_1_1Socket_html_a06ba54744530439d4131e6aba4623d08"><div class="ttname"><a href="classcore_1_1Socket.html#a06ba54744530439d4131e6aba4623d08">core::Socket::getDescriptor</a></div><div class="ttdeci">int getDescriptor()</div><div class="ttdoc">Get the descriptor for the socket.</div><div class="ttdef"><b>Definition:</b> Socket.cpp:46</div></div>
<div class="ttc" id="aclasscore_1_1Socket_html_a1413c826307ef0f29d7457770af675e3"><div class="ttname"><a href="classcore_1_1Socket.html#a1413c826307ef0f29d7457770af675e3">core::Socket::write</a></div><div class="ttdeci">int write(std::string data)</div><div class="ttdef"><b>Definition:</b> Socket.cpp:146</div></div>
<div class="ttc" id="aclasscore_1_1Socket_html_a1a045e15fb5851d666a21be05ac4c5d7"><div class="ttname"><a href="classcore_1_1Socket.html#a1a045e15fb5851d666a21be05ac4c5d7">core::Socket::eventReceived</a></div><div class="ttdeci">bool eventReceived(struct epoll_event event, long long eventId)</div><div class="ttdoc">Parse epoll event and call specified callbacks.</div><div class="ttdef"><b>Definition:</b> Socket.cpp:70</div></div>
<div class="ttc" id="aclasscore_1_1Socket_html_a23b9824653bbe4652a716acb828665b1"><div class="ttname"><a href="classcore_1_1Socket.html#a23b9824653bbe4652a716acb828665b1">core::Socket::onRegistered</a></div><div class="ttdeci">virtual void onRegistered()</div><div class="ttdoc">Called after the socket has been registered with epoll processing.</div><div class="ttdef"><b>Definition:</b> Socket.cpp:64</div></div>
<div class="ttc" id="aclasscore_1_1Socket_html_a46ed2e240852d3fa949979ebbc4ac875"><div class="ttname"><a href="classcore_1_1Socket.html#a46ed2e240852d3fa949979ebbc4ac875">core::Socket::receiveData</a></div><div class="ttdeci">virtual void receiveData(coreutils::ZString &amp;buffer)</div><div class="ttdef"><b>Definition:</b> Socket.cpp:101</div></div>
<div class="ttc" id="aclasscore_1_1Socket_html_a4c3f87fd1de3c9eab4bf5efbb30ce87d"><div class="ttname"><a href="classcore_1_1Socket.html#a4c3f87fd1de3c9eab4bf5efbb30ce87d">core::Socket::Socket</a></div><div class="ttdeci">Socket(EPoll &amp;ePoll, std::string text=&quot;&quot;)</div><div class="ttdef"><b>Definition:</b> Socket.cpp:12</div></div>
<div class="ttc" id="aclasscore_1_1Socket_html_a81e5ee3e17834166d97c6e8b7dfe0da0"><div class="ttname"><a href="classcore_1_1Socket.html#a81e5ee3e17834166d97c6e8b7dfe0da0">core::Socket::onRegister</a></div><div class="ttdeci">virtual void onRegister()</div><div class="ttdoc">Called before the socket has registered with the epoll processing.</div><div class="ttdef"><b>Definition:</b> Socket.cpp:62</div></div>
<div class="ttc" id="aclasscore_1_1Socket_html_aa5003845f8ae464ad2fa206176381be0"><div class="ttname"><a href="classcore_1_1Socket.html#aa5003845f8ae464ad2fa206176381be0">core::Socket::~Socket</a></div><div class="ttdeci">virtual ~Socket()</div><div class="ttdef"><b>Definition:</b> Socket.cpp:18</div></div>
<div class="ttc" id="aclasscore_1_1Socket_html_ac44f6ae3196a8a3e09a6a85fcf495762"><div class="ttname"><a href="classcore_1_1Socket.html#ac44f6ae3196a8a3e09a6a85fcf495762">core::Socket::setDescriptor</a></div><div class="ttdeci">void setDescriptor(int descriptor)</div><div class="ttdoc">Set the descriptor for the socket.</div><div class="ttdef"><b>Definition:</b> Socket.cpp:30</div></div>
<div class="ttc" id="aclasscore_1_1Socket_html_ac8d6a2c54696eb6fc2024cf6bcf6b4e5"><div class="ttname"><a href="classcore_1_1Socket.html#ac8d6a2c54696eb6fc2024cf6bcf6b4e5">core::Socket::onDataReceived</a></div><div class="ttdeci">virtual void onDataReceived(std::string data)</div><div class="ttdoc">Called when data is received from the socket.</div><div class="ttdef"><b>Definition:</b> Socket.cpp:91</div></div>
<div class="ttc" id="aclasscore_1_1Socket_html_ae9be59697c2b2e5efb19aaae3ba943d2"><div class="ttname"><a href="classcore_1_1Socket.html#ae9be59697c2b2e5efb19aaae3ba943d2">core::Socket::onUnregistered</a></div><div class="ttdeci">virtual void onUnregistered()</div><div class="ttdoc">Called when the socket has finished unregistering for the epoll processing.</div><div class="ttdef"><b>Definition:</b> Socket.cpp:68</div></div>
<div class="ttc" id="aclasscore_1_1Socket_html_af2d1b6de7a64a9d446b0305b6ec47b31"><div class="ttname"><a href="classcore_1_1Socket.html#af2d1b6de7a64a9d446b0305b6ec47b31">core::Socket::shutdown</a></div><div class="ttdeci">void shutdown(std::string text=&quot;unknown&quot;)</div><div class="ttdef"><b>Definition:</b> Socket.cpp:167</div></div>
>>>>>>> subscription
</div><!-- fragment --></div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>

2
html/SubscriptionHandler_8h_source.html
View File

@ -91,7 +91,7 @@ $(function() {
<div class="line"><a name="l00024"></a><span class="lineno"> 24</span>&#160; </div>
<div class="line"><a name="l00025"></a><span class="lineno"> 25</span>&#160;<span class="preprocessor">#endif</span></div>
<div class="ttc" id="aclasscore_1_1SubscriptionHandler_html"><div class="ttname"><a href="classcore_1_1SubscriptionHandler.html">core::SubscriptionHandler</a></div><div class="ttdef"><b>Definition:</b> SubscriptionHandler.h:15</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:24</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:26</div></div>
</div><!-- fragment --></div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>

4
html/SubscriptionManager_8h_source.html
View File

@ -104,9 +104,9 @@ $(function() {
<div class="ttc" id="aclasscore_1_1Command_html"><div class="ttname"><a href="classcore_1_1Command.html">core::Command</a></div><div class="ttdef"><b>Definition:</b> Command.h:22</div></div>
<div class="ttc" id="aclasscore_1_1SubscriptionHandler_html"><div class="ttname"><a href="classcore_1_1SubscriptionHandler.html">core::SubscriptionHandler</a></div><div class="ttdef"><b>Definition:</b> SubscriptionHandler.h:15</div></div>
<div class="ttc" id="aclasscore_1_1SubscriptionManager_html"><div class="ttname"><a href="classcore_1_1SubscriptionManager.html">core::SubscriptionManager</a></div><div class="ttdef"><b>Definition:</b> SubscriptionManager.h:14</div></div>
<div class="ttc" id="aclasscore_1_1SubscriptionManager_html_aaa30bf772ad72b3f319a790662e4f8ae"><div class="ttname"><a href="classcore_1_1SubscriptionManager.html#aaa30bf772ad72b3f319a790662e4f8ae">core::SubscriptionManager::processCommand</a></div><div class="ttdeci">int processCommand(coreutils::ZString &amp;request, TCPSession &amp;session) override</div><div class="ttdef"><b>Definition:</b> SubscriptionManager.cpp:59</div></div>
<div class="ttc" id="aclasscore_1_1SubscriptionManager_html_aaa30bf772ad72b3f319a790662e4f8ae"><div class="ttname"><a href="classcore_1_1SubscriptionManager.html#aaa30bf772ad72b3f319a790662e4f8ae">core::SubscriptionManager::processCommand</a></div><div class="ttdeci">int processCommand(coreutils::ZString &amp;request, TCPSession &amp;session) override</div><div class="ttdef"><b>Definition:</b> SubscriptionManager.cpp:60</div></div>
<div class="ttc" id="aclasscore_1_1Subscription_html"><div class="ttname"><a href="classcore_1_1Subscription.html">core::Subscription</a></div><div class="ttdef"><b>Definition:</b> Subscription.h:15</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:24</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:26</div></div>
</div><!-- fragment --></div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>

28
html/Subscription_8h_source.html
View File

@ -98,24 +98,26 @@ $(function() {
<div class="line"><a name="l00031"></a><span class="lineno"> 31</span>&#160; </div>
<div class="line"><a name="l00032"></a><span class="lineno"> 32</span>&#160; <span class="keywordtype">bool</span> ifSubscriber(<a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> &amp;session);</div>
<div class="line"><a name="l00033"></a><span class="lineno"> 33</span>&#160; </div>
<div class="line"><a name="l00034"></a><span class="lineno"> 34</span>&#160;<span class="comment">// void setHandler(SubscriptionHandler *handlers);</span></div>
<div class="line"><a name="l00034"></a><span class="lineno"> 34</span>&#160; <span class="keywordtype">bool</span> subInvite(<a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> &amp;session);</div>
<div class="line"><a name="l00035"></a><span class="lineno"> 35</span>&#160; </div>
<div class="line"><a name="l00036"></a><span class="lineno"> 36</span>&#160; <span class="comment">// int processCommand(coreutils::ZString &amp;request, TCPSession &amp;session) override;</span></div>
<div class="line"><a name="l00036"></a><span class="lineno"> 36</span>&#160; <span class="comment">// void setHandler(SubscriptionHandler *handlers);</span></div>
<div class="line"><a name="l00037"></a><span class="lineno"> 37</span>&#160; </div>
<div class="line"><a name="l00038"></a><span class="lineno"> 38</span>&#160; std::string id;</div>
<div class="line"><a name="l00039"></a><span class="lineno"> 39</span>&#160; std::string mode;</div>
<div class="line"><a name="l00040"></a><span class="lineno"> 40</span>&#160; <a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> *owner;</div>
<div class="line"><a name="l00041"></a><span class="lineno"> 41</span>&#160; </div>
<div class="line"><a name="l00042"></a><span class="lineno"> 42</span>&#160; <a class="code" href="classcore_1_1SubscriptionHandler.html">SubscriptionHandler</a> *handler;</div>
<div class="line"><a name="l00038"></a><span class="lineno"> 38</span>&#160; <span class="comment">// int processCommand(coreutils::ZString &amp;request, TCPSession &amp;session) override;</span></div>
<div class="line"><a name="l00039"></a><span class="lineno"> 39</span>&#160; </div>
<div class="line"><a name="l00040"></a><span class="lineno"> 40</span>&#160; std::string id;</div>
<div class="line"><a name="l00041"></a><span class="lineno"> 41</span>&#160; std::string mode;</div>
<div class="line"><a name="l00042"></a><span class="lineno"> 42</span>&#160; <a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> *owner;</div>
<div class="line"><a name="l00043"></a><span class="lineno"> 43</span>&#160; </div>
<div class="line"><a name="l00044"></a><span class="lineno"> 44</span>&#160; std::vector&lt;TCPSession *&gt; subscribers;</div>
<div class="line"><a name="l00045"></a><span class="lineno"> 45</span>&#160; };</div>
<div class="line"><a name="l00046"></a><span class="lineno"> 46</span>&#160;}</div>
<div class="line"><a name="l00047"></a><span class="lineno"> 47</span>&#160; </div>
<div class="line"><a name="l00048"></a><span class="lineno"> 48</span>&#160;<span class="preprocessor">#endif</span></div>
<div class="line"><a name="l00044"></a><span class="lineno"> 44</span>&#160; <a class="code" href="classcore_1_1SubscriptionHandler.html">SubscriptionHandler</a> *handler;</div>
<div class="line"><a name="l00045"></a><span class="lineno"> 45</span>&#160; </div>
<div class="line"><a name="l00046"></a><span class="lineno"> 46</span>&#160; std::vector&lt;TCPSession *&gt; subscribers;</div>
<div class="line"><a name="l00047"></a><span class="lineno"> 47</span>&#160; };</div>
<div class="line"><a name="l00048"></a><span class="lineno"> 48</span>&#160;}</div>
<div class="line"><a name="l00049"></a><span class="lineno"> 49</span>&#160; </div>
<div class="line"><a name="l00050"></a><span class="lineno"> 50</span>&#160;<span class="preprocessor">#endif</span></div>
<div class="ttc" id="aclasscore_1_1SubscriptionHandler_html"><div class="ttname"><a href="classcore_1_1SubscriptionHandler.html">core::SubscriptionHandler</a></div><div class="ttdef"><b>Definition:</b> SubscriptionHandler.h:15</div></div>
<div class="ttc" id="aclasscore_1_1Subscription_html"><div class="ttname"><a href="classcore_1_1Subscription.html">core::Subscription</a></div><div class="ttdef"><b>Definition:</b> Subscription.h:15</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:24</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:26</div></div>
</div><!-- fragment --></div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>

139
html/TCPServer_8h_source.html
View File

@ -68,97 +68,100 @@ $(function() {
<div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span>&#160;<span class="preprocessor">#ifndef __TCPServer_h__</span></div>
<div class="line"><a name="l00002"></a><span class="lineno"> 2</span>&#160;<span class="preprocessor">#define __TCPServer_h__</span></div>
<div class="line"><a name="l00003"></a><span class="lineno"> 3</span>&#160; </div>
<div class="line"><a name="l00004"></a><span class="lineno"> 4</span>&#160;<span class="preprocessor">#include &quot;Socket.h&quot;</span></div>
<div class="line"><a name="l00005"></a><span class="lineno"> 5</span>&#160;<span class="preprocessor">#include &quot;TCPSocket.h&quot;</span></div>
<div class="line"><a name="l00004"></a><span class="lineno"> 4</span>&#160;<span class="preprocessor">#include &quot;Command.h&quot;</span></div>
<div class="line"><a name="l00005"></a><span class="lineno"> 5</span>&#160;<span class="preprocessor">#include &quot;CommandList.h&quot;</span></div>
<div class="line"><a name="l00006"></a><span class="lineno"> 6</span>&#160;<span class="preprocessor">#include &quot;IPAddressList.h&quot;</span></div>
<div class="line"><a name="l00007"></a><span class="lineno"> 7</span>&#160;<span class="preprocessor">#include &quot;Command.h&quot;</span></div>
<div class="line"><a name="l00008"></a><span class="lineno"> 8</span>&#160;<span class="preprocessor">#include &quot;CommandList.h&quot;</span></div>
<div class="line"><a name="l00009"></a><span class="lineno"> 9</span>&#160;<span class="preprocessor">#include &quot;SubscriptionManager.h&quot;</span></div>
<div class="line"><a name="l00010"></a><span class="lineno"> 10</span>&#160; </div>
<div class="line"><a name="l00011"></a><span class="lineno"> 11</span>&#160;<span class="keyword">namespace </span>core {</div>
<div class="line"><a name="l00012"></a><span class="lineno"> 12</span>&#160; </div>
<div class="line"><a name="l00024"></a><span class="lineno"> 24</span>&#160; </div>
<div class="line"><a name="l00025"></a><span class="lineno"><a class="line" href="classcore_1_1TCPServer.html"> 25</a></span>&#160; <span class="keyword">class </span><a class="code" href="classcore_1_1TCPServer.html">TCPServer</a> : <span class="keyword">public</span> <a class="code" href="classcore_1_1TCPSocket.html">TCPSocket</a>, <span class="keyword">public</span> <a class="code" href="classcore_1_1Command.html">Command</a> {</div>
<div class="line"><a name="l00007"></a><span class="lineno"> 7</span>&#160;<span class="preprocessor">#include &quot;Socket.h&quot;</span></div>
<div class="line"><a name="l00008"></a><span class="lineno"> 8</span>&#160;<span class="preprocessor">#include &quot;SubscriptionManager.h&quot;</span></div>
<div class="line"><a name="l00009"></a><span class="lineno"> 9</span>&#160;<span class="preprocessor">#include &quot;TCPSession.h&quot;</span></div>
<div class="line"><a name="l00010"></a><span class="lineno"> 10</span>&#160;<span class="preprocessor">#include &quot;TCPSocket.h&quot;</span></div>
<div class="line"><a name="l00011"></a><span class="lineno"> 11</span>&#160; </div>
<div class="line"><a name="l00012"></a><span class="lineno"> 12</span>&#160;<span class="keyword">namespace </span>core</div>
<div class="line"><a name="l00013"></a><span class="lineno"> 13</span>&#160;{</div>
<div class="line"><a name="l00014"></a><span class="lineno"> 14</span>&#160; </div>
<div class="line"><a name="l00026"></a><span class="lineno"> 26</span>&#160; </div>
<div class="line"><a name="l00027"></a><span class="lineno"> 27</span>&#160; <span class="keyword">public</span>:</div>
<div class="line"><a name="l00028"></a><span class="lineno"> 28</span>&#160; </div>
<div class="line"><a name="l00037"></a><span class="lineno"> 37</span>&#160; </div>
<div class="line"><a name="l00038"></a><span class="lineno"> 38</span>&#160; <a class="code" href="classcore_1_1TCPServer.html#abaecb97c336b757d1029d45277f9fc5b">TCPServer</a>(<a class="code" href="classcore_1_1EPoll.html">EPoll</a> &amp;ePoll, <a class="code" href="classcore_1_1IPAddress.html">IPAddress</a> address, std::string delimiter = <span class="stringliteral">&quot; &quot;</span>, <span class="keywordtype">int</span> depth = 10, std::string text = <span class="stringliteral">&quot;&quot;</span>);</div>
<div class="line"><a name="l00027"></a><span class="lineno"><a class="line" href="classcore_1_1TCPServer.html"> 27</a></span>&#160; <span class="keyword">class </span><a class="code" href="classcore_1_1TCPServer.html">TCPServer</a> : <span class="keyword">public</span> <a class="code" href="classcore_1_1TCPSocket.html">TCPSocket</a>, <span class="keyword">public</span> <a class="code" href="classcore_1_1Command.html">Command</a></div>
<div class="line"><a name="l00028"></a><span class="lineno"> 28</span>&#160; {</div>
<div class="line"><a name="l00029"></a><span class="lineno"> 29</span>&#160; </div>
<div class="line"><a name="l00030"></a><span class="lineno"> 30</span>&#160; <span class="keyword">public</span>:</div>
<div class="line"><a name="l00039"></a><span class="lineno"> 39</span>&#160; </div>
<div class="line"><a name="l00043"></a><span class="lineno"> 43</span>&#160; </div>
<div class="line"><a name="l00044"></a><span class="lineno"> 44</span>&#160; <span class="keyword">virtual</span> <a class="code" href="classcore_1_1TCPServer.html#a7ccdc057c9eee8504fce796301f82088">~TCPServer</a>();</div>
<div class="line"><a name="l00040"></a><span class="lineno"> 40</span>&#160; <a class="code" href="classcore_1_1TCPServer.html#abaecb97c336b757d1029d45277f9fc5b">TCPServer</a>(<a class="code" href="classcore_1_1EPoll.html">EPoll</a> &amp;ePoll, <a class="code" href="classcore_1_1IPAddress.html">IPAddress</a> address, std::string delimiter = <span class="stringliteral">&quot; &quot;</span>, <span class="keywordtype">int</span> depth = 10, std::string text = <span class="stringliteral">&quot;&quot;</span>);</div>
<div class="line"><a name="l00041"></a><span class="lineno"> 41</span>&#160; </div>
<div class="line"><a name="l00045"></a><span class="lineno"> 45</span>&#160; </div>
<div class="line"><a name="l00046"></a><span class="lineno"> 46</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">void</span> sessionErrorHandler(std::string errorString, std::stringstream &amp;out);</div>
<div class="line"><a name="l00046"></a><span class="lineno"> 46</span>&#160; <span class="keyword">virtual</span> <a class="code" href="classcore_1_1TCPServer.html#a7ccdc057c9eee8504fce796301f82088">~TCPServer</a>();</div>
<div class="line"><a name="l00047"></a><span class="lineno"> 47</span>&#160; </div>
<div class="line"><a name="l00055"></a><span class="lineno"> 55</span>&#160; </div>
<div class="line"><a name="l00056"></a><span class="lineno"> 56</span>&#160; <span class="keyword">virtual</span> <a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> * <a class="code" href="classcore_1_1TCPServer.html#a841f02799ad8529aad7cea132f4de8a9">getSocketAccept</a>(<a class="code" href="classcore_1_1EPoll.html">EPoll</a> &amp;epoll);</div>
<div class="line"><a name="l00048"></a><span class="lineno"> 48</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">void</span> sessionErrorHandler(std::string errorString, std::stringstream &amp;out);</div>
<div class="line"><a name="l00049"></a><span class="lineno"> 49</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">bool</span> compareAlias(<span class="keywordtype">void</span> *alias, <span class="keywordtype">void</span> *compare);</div>
<div class="line"><a name="l00057"></a><span class="lineno"> 57</span>&#160; </div>
<div class="line"><a name="l00061"></a><span class="lineno"> 61</span>&#160; </div>
<div class="line"><a name="l00062"></a><span class="lineno"><a class="line" href="classcore_1_1TCPServer.html#aeed1bc55d099667ccda51cd682bfc633"> 62</a></span>&#160; std::vector&lt;TCPSession *&gt; <a class="code" href="classcore_1_1TCPServer.html#aeed1bc55d099667ccda51cd682bfc633">sessions</a>;</div>
<div class="line"><a name="l00058"></a><span class="lineno"> 58</span>&#160; <span class="keyword">virtual</span> <a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> *<a class="code" href="classcore_1_1TCPServer.html#a841f02799ad8529aad7cea132f4de8a9">getSocketAccept</a>(<a class="code" href="classcore_1_1EPoll.html">EPoll</a> &amp;epoll);</div>
<div class="line"><a name="l00059"></a><span class="lineno"> 59</span>&#160; </div>
<div class="line"><a name="l00063"></a><span class="lineno"> 63</span>&#160; </div>
<div class="line"><a name="l00068"></a><span class="lineno"> 68</span>&#160; </div>
<div class="line"><a name="l00069"></a><span class="lineno"><a class="line" href="classcore_1_1TCPServer.html#afcc44802b988e2f4292504e804dccf8b"> 69</a></span>&#160; <a class="code" href="classcore_1_1CommandList.html">CommandList</a> <a class="code" href="classcore_1_1TCPServer.html#afcc44802b988e2f4292504e804dccf8b">commands</a>;</div>
<div class="line"><a name="l00064"></a><span class="lineno"><a class="line" href="classcore_1_1TCPServer.html#aeed1bc55d099667ccda51cd682bfc633"> 64</a></span>&#160; std::vector&lt;TCPSession *&gt; <a class="code" href="classcore_1_1TCPServer.html#aeed1bc55d099667ccda51cd682bfc633">sessions</a>;</div>
<div class="line"><a name="l00065"></a><span class="lineno"> 65</span>&#160; </div>
<div class="line"><a name="l00070"></a><span class="lineno"> 70</span>&#160; </div>
<div class="line"><a name="l00076"></a><span class="lineno"> 76</span>&#160; </div>
<div class="line"><a name="l00077"></a><span class="lineno"><a class="line" href="classcore_1_1TCPServer.html#a82f6bf16e4ab20d8b30da09e034fffff"> 77</a></span>&#160; <a class="code" href="classcore_1_1IPAddressList.html">IPAddressList</a> *<a class="code" href="classcore_1_1TCPServer.html#a82f6bf16e4ab20d8b30da09e034fffff">blackList</a>;</div>
<div class="line"><a name="l00071"></a><span class="lineno"><a class="line" href="classcore_1_1TCPServer.html#afcc44802b988e2f4292504e804dccf8b"> 71</a></span>&#160; <a class="code" href="classcore_1_1CommandList.html">CommandList</a> <a class="code" href="classcore_1_1TCPServer.html#afcc44802b988e2f4292504e804dccf8b">commands</a>;</div>
<div class="line"><a name="l00072"></a><span class="lineno"> 72</span>&#160; </div>
<div class="line"><a name="l00078"></a><span class="lineno"> 78</span>&#160; </div>
<div class="line"><a name="l00084"></a><span class="lineno"> 84</span>&#160; </div>
<div class="line"><a name="l00085"></a><span class="lineno"><a class="line" href="classcore_1_1TCPServer.html#abad6300b6234ca8b69cef9128755342e"> 85</a></span>&#160; <a class="code" href="classcore_1_1IPAddressList.html">IPAddressList</a> *<a class="code" href="classcore_1_1TCPServer.html#abad6300b6234ca8b69cef9128755342e">whiteList</a>;</div>
<div class="line"><a name="l00079"></a><span class="lineno"><a class="line" href="classcore_1_1TCPServer.html#a82f6bf16e4ab20d8b30da09e034fffff"> 79</a></span>&#160; <a class="code" href="classcore_1_1IPAddressList.html">IPAddressList</a> *<a class="code" href="classcore_1_1TCPServer.html#a82f6bf16e4ab20d8b30da09e034fffff">blackList</a>;</div>
<div class="line"><a name="l00080"></a><span class="lineno"> 80</span>&#160; </div>
<div class="line"><a name="l00086"></a><span class="lineno"> 86</span>&#160; </div>
<div class="line"><a name="l00087"></a><span class="lineno"> 87</span>&#160; <span class="keywordtype">void</span> removeFromSessionList(<a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> *session);</div>
<div class="line"><a name="l00087"></a><span class="lineno"><a class="line" href="classcore_1_1TCPServer.html#abad6300b6234ca8b69cef9128755342e"> 87</a></span>&#160; <a class="code" href="classcore_1_1IPAddressList.html">IPAddressList</a> *<a class="code" href="classcore_1_1TCPServer.html#abad6300b6234ca8b69cef9128755342e">whiteList</a>;</div>
<div class="line"><a name="l00088"></a><span class="lineno"> 88</span>&#160; </div>
<div class="line"><a name="l00089"></a><span class="lineno"> 89</span>&#160; <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPServer.html#a49e3ead1bf4e7830685780e73c4db5db">output</a>(std::stringstream &amp;out); </div>
<div class="line"><a name="l00089"></a><span class="lineno"> 89</span>&#160; <span class="keywordtype">void</span> removeFromSessionList(<a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> *session);</div>
<div class="line"><a name="l00090"></a><span class="lineno"> 90</span>&#160; </div>
<div class="line"><a name="l00094"></a><span class="lineno"> 94</span>&#160; </div>
<div class="line"><a name="l00095"></a><span class="lineno"> 95</span>&#160; <span class="keywordtype">void</span> sendToAll(std::stringstream &amp;out);</div>
<div class="line"><a name="l00091"></a><span class="lineno"> 91</span>&#160; <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPServer.html#a49e3ead1bf4e7830685780e73c4db5db">output</a>(std::stringstream &amp;out); </div>
<div class="line"><a name="l00092"></a><span class="lineno"> 92</span>&#160; </div>
<div class="line"><a name="l00096"></a><span class="lineno"> 96</span>&#160; </div>
<div class="line"><a name="l00101"></a><span class="lineno"> 101</span>&#160; </div>
<div class="line"><a name="l00102"></a><span class="lineno"> 102</span>&#160; <span class="keywordtype">void</span> sendToAll(std::stringstream &amp;out, <a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> &amp;sender, <a class="code" href="classcore_1_1SessionFilter.html">SessionFilter</a> filter);</div>
<div class="line"><a name="l00097"></a><span class="lineno"> 97</span>&#160; <span class="keywordtype">void</span> sendToAll(std::stringstream &amp;out);</div>
<div class="line"><a name="l00098"></a><span class="lineno"> 98</span>&#160; </div>
<div class="line"><a name="l00103"></a><span class="lineno"> 103</span>&#160; </div>
<div class="line"><a name="l00109"></a><span class="lineno"> 109</span>&#160; </div>
<div class="line"><a name="l00110"></a><span class="lineno"> 110</span>&#160; <span class="keywordtype">void</span> sendToAll(std::stringstream &amp;out, <a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> &amp;sender);</div>
<div class="line"><a name="l00104"></a><span class="lineno"> 104</span>&#160; <span class="keywordtype">void</span> sendToAll(std::stringstream &amp;out, <a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> &amp;sender, <a class="code" href="classcore_1_1SessionFilter.html">SessionFilter</a> filter);</div>
<div class="line"><a name="l00105"></a><span class="lineno"> 105</span>&#160; </div>
<div class="line"><a name="l00111"></a><span class="lineno"> 111</span>&#160; </div>
<div class="line"><a name="l00115"></a><span class="lineno"> 115</span>&#160; </div>
<div class="line"><a name="l00116"></a><span class="lineno"><a class="line" href="classcore_1_1TCPServer.html#a28302dd844cfc971ee41de2000d24aa0"> 116</a></span>&#160; <a class="code" href="classcore_1_1SubscriptionManager.html">SubscriptionManager</a> <a class="code" href="classcore_1_1TCPServer.html#a28302dd844cfc971ee41de2000d24aa0">subscriptions</a>;</div>
<div class="line"><a name="l00112"></a><span class="lineno"> 112</span>&#160; <span class="keywordtype">void</span> sendToAll(std::stringstream &amp;out, <a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> &amp;sender);</div>
<div class="line"><a name="l00113"></a><span class="lineno"> 113</span>&#160; </div>
<div class="line"><a name="l00117"></a><span class="lineno"> 117</span>&#160; </div>
<div class="line"><a name="l00118"></a><span class="lineno"> 118</span>&#160; <span class="keyword">protected</span>:</div>
<div class="line"><a name="l00118"></a><span class="lineno"><a class="line" href="classcore_1_1TCPServer.html#a28302dd844cfc971ee41de2000d24aa0"> 118</a></span>&#160; <a class="code" href="classcore_1_1SubscriptionManager.html">SubscriptionManager</a> <a class="code" href="classcore_1_1TCPServer.html#a28302dd844cfc971ee41de2000d24aa0">subscriptions</a>;</div>
<div class="line"><a name="l00119"></a><span class="lineno"> 119</span>&#160; </div>
<div class="line"><a name="l00129"></a><span class="lineno"> 129</span>&#160; </div>
<div class="line"><a name="l00130"></a><span class="lineno"> 130</span>&#160; <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPServer.html#a276ccbc8cb9b4380ebd78807b97f0159">onDataReceived</a>(std::string data) <span class="keyword">override</span>;</div>
<div class="line"><a name="l00131"></a><span class="lineno"> 131</span>&#160; </div>
<div class="line"><a name="l00138"></a><span class="lineno"> 138</span>&#160; </div>
<div class="line"><a name="l00139"></a><span class="lineno"> 139</span>&#160; <span class="keywordtype">int</span> <a class="code" href="classcore_1_1TCPServer.html#a6b7a7e1ac4132942fcaf418ed41c1437">processCommand</a>(coreutils::ZString &amp;request, <a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> &amp;session) <span class="keyword">override</span>;</div>
<div class="line"><a name="l00140"></a><span class="lineno"> 140</span>&#160; </div>
<div class="line"><a name="l00141"></a><span class="lineno"> 141</span>&#160; <span class="keyword">private</span>:</div>
<div class="line"><a name="l00142"></a><span class="lineno"> 142</span>&#160; </div>
<div class="line"><a name="l00143"></a><span class="lineno"> 143</span>&#160; <a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> * accept();</div>
<div class="line"><a name="l00144"></a><span class="lineno"> 144</span>&#160; std::mutex lock;</div>
<div class="line"><a name="l00145"></a><span class="lineno"> 145</span>&#160; </div>
<div class="line"><a name="l00146"></a><span class="lineno"> 146</span>&#160; };</div>
<div class="line"><a name="l00147"></a><span class="lineno"> 147</span>&#160; </div>
<div class="line"><a name="l00148"></a><span class="lineno"> 148</span>&#160;}</div>
<div class="line"><a name="l00149"></a><span class="lineno"> 149</span>&#160; </div>
<div class="line"><a name="l00150"></a><span class="lineno"> 150</span>&#160;<span class="preprocessor">#endif</span></div>
<div class="line"><a name="l00124"></a><span class="lineno"> 124</span>&#160; </div>
<div class="line"><a name="l00125"></a><span class="lineno"> 125</span>&#160; <a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> *<a class="code" href="classcore_1_1TCPServer.html#a9042281193e227a6cd8dab3ff8b46a40">getSessionByAlias</a>(<span class="keywordtype">void</span> *alias);</div>
<div class="line"><a name="l00126"></a><span class="lineno"> 126</span>&#160; </div>
<div class="line"><a name="l00127"></a><span class="lineno"> 127</span>&#160; <span class="keyword">protected</span>:</div>
<div class="line"><a name="l00137"></a><span class="lineno"> 137</span>&#160; </div>
<div class="line"><a name="l00138"></a><span class="lineno"> 138</span>&#160; <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPServer.html#a276ccbc8cb9b4380ebd78807b97f0159">onDataReceived</a>(std::string data) <span class="keyword">override</span>;</div>
<div class="line"><a name="l00139"></a><span class="lineno"> 139</span>&#160; </div>
<div class="line"><a name="l00146"></a><span class="lineno"> 146</span>&#160; </div>
<div class="line"><a name="l00147"></a><span class="lineno"> 147</span>&#160; <span class="keywordtype">int</span> <a class="code" href="classcore_1_1TCPServer.html#a6b7a7e1ac4132942fcaf418ed41c1437">processCommand</a>(coreutils::ZString &amp;request, <a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> &amp;session) <span class="keyword">override</span>;</div>
<div class="line"><a name="l00148"></a><span class="lineno"> 148</span>&#160; </div>
<div class="line"><a name="l00149"></a><span class="lineno"> 149</span>&#160; <span class="keyword">private</span>:</div>
<div class="line"><a name="l00150"></a><span class="lineno"> 150</span>&#160; <a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> *accept();</div>
<div class="line"><a name="l00151"></a><span class="lineno"> 151</span>&#160; std::mutex lock;</div>
<div class="line"><a name="l00152"></a><span class="lineno"> 152</span>&#160; };</div>
<div class="line"><a name="l00154"></a><span class="lineno"> 154</span>&#160; </div>
<div class="line"><a name="l00155"></a><span class="lineno"> 155</span>&#160;}</div>
<div class="line"><a name="l00156"></a><span class="lineno"> 156</span>&#160; </div>
<div class="line"><a name="l00157"></a><span class="lineno"> 157</span>&#160;<span class="preprocessor">#endif</span></div>
<div class="ttc" id="aclasscore_1_1CommandList_html"><div class="ttname"><a href="classcore_1_1CommandList.html">core::CommandList</a></div><div class="ttdef"><b>Definition:</b> CommandList.h:18</div></div>
<div class="ttc" id="aclasscore_1_1Command_html"><div class="ttname"><a href="classcore_1_1Command.html">core::Command</a></div><div class="ttdef"><b>Definition:</b> Command.h:22</div></div>
<div class="ttc" id="aclasscore_1_1EPoll_html"><div class="ttname"><a href="classcore_1_1EPoll.html">core::EPoll</a></div><div class="ttdef"><b>Definition:</b> EPoll.h:31</div></div>
<div class="ttc" id="aclasscore_1_1IPAddressList_html"><div class="ttname"><a href="classcore_1_1IPAddressList.html">core::IPAddressList</a></div><div class="ttdef"><b>Definition:</b> IPAddressList.h:9</div></div>
<div class="ttc" id="aclasscore_1_1IPAddress_html"><div class="ttname"><a href="classcore_1_1IPAddress.html">core::IPAddress</a></div><div class="ttdef"><b>Definition:</b> IPAddress.h:9</div></div>
<div class="ttc" id="aclasscore_1_1SessionFilter_html"><div class="ttname"><a href="classcore_1_1SessionFilter.html">core::SessionFilter</a></div><div class="ttdef"><b>Definition:</b> SessionFilter.h:10</div></div>
<div class="ttc" id="aclasscore_1_1SessionFilter_html"><div class="ttname"><a href="classcore_1_1SessionFilter.html">core::SessionFilter</a></div><div class="ttdef"><b>Definition:</b> SessionFilter.h:13</div></div>
<div class="ttc" id="aclasscore_1_1SubscriptionManager_html"><div class="ttname"><a href="classcore_1_1SubscriptionManager.html">core::SubscriptionManager</a></div><div class="ttdef"><b>Definition:</b> SubscriptionManager.h:14</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html"><div class="ttname"><a href="classcore_1_1TCPServer.html">core::TCPServer</a></div><div class="ttdef"><b>Definition:</b> TCPServer.h:25</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_a276ccbc8cb9b4380ebd78807b97f0159"><div class="ttname"><a href="classcore_1_1TCPServer.html#a276ccbc8cb9b4380ebd78807b97f0159">core::TCPServer::onDataReceived</a></div><div class="ttdeci">void onDataReceived(std::string data) override</div><div class="ttdef"><b>Definition:</b> TCPServer.cpp:36</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_a28302dd844cfc971ee41de2000d24aa0"><div class="ttname"><a href="classcore_1_1TCPServer.html#a28302dd844cfc971ee41de2000d24aa0">core::TCPServer::subscriptions</a></div><div class="ttdeci">SubscriptionManager subscriptions</div><div class="ttdef"><b>Definition:</b> TCPServer.h:116</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_a49e3ead1bf4e7830685780e73c4db5db"><div class="ttname"><a href="classcore_1_1TCPServer.html#a49e3ead1bf4e7830685780e73c4db5db">core::TCPServer::output</a></div><div class="ttdeci">void output(std::stringstream &amp;out)</div><div class="ttdoc">Output the consoles array to the console.</div><div class="ttdef"><b>Definition:</b> TCPServer.cpp:90</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_a6b7a7e1ac4132942fcaf418ed41c1437"><div class="ttname"><a href="classcore_1_1TCPServer.html#a6b7a7e1ac4132942fcaf418ed41c1437">core::TCPServer::processCommand</a></div><div class="ttdeci">int processCommand(coreutils::ZString &amp;request, TCPSession &amp;session) override</div><div class="ttdef"><b>Definition:</b> TCPServer.cpp:94</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_a7ccdc057c9eee8504fce796301f82088"><div class="ttname"><a href="classcore_1_1TCPServer.html#a7ccdc057c9eee8504fce796301f82088">core::TCPServer::~TCPServer</a></div><div class="ttdeci">virtual ~TCPServer()</div><div class="ttdef"><b>Definition:</b> TCPServer.cpp:31</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_a82f6bf16e4ab20d8b30da09e034fffff"><div class="ttname"><a href="classcore_1_1TCPServer.html#a82f6bf16e4ab20d8b30da09e034fffff">core::TCPServer::blackList</a></div><div class="ttdeci">IPAddressList * blackList</div><div class="ttdef"><b>Definition:</b> TCPServer.h:77</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_a841f02799ad8529aad7cea132f4de8a9"><div class="ttname"><a href="classcore_1_1TCPServer.html#a841f02799ad8529aad7cea132f4de8a9">core::TCPServer::getSocketAccept</a></div><div class="ttdeci">virtual TCPSession * getSocketAccept(EPoll &amp;epoll)</div><div class="ttdef"><b>Definition:</b> TCPServer.cpp:86</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_abad6300b6234ca8b69cef9128755342e"><div class="ttname"><a href="classcore_1_1TCPServer.html#abad6300b6234ca8b69cef9128755342e">core::TCPServer::whiteList</a></div><div class="ttdeci">IPAddressList * whiteList</div><div class="ttdef"><b>Definition:</b> TCPServer.h:85</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_abaecb97c336b757d1029d45277f9fc5b"><div class="ttname"><a href="classcore_1_1TCPServer.html#abaecb97c336b757d1029d45277f9fc5b">core::TCPServer::TCPServer</a></div><div class="ttdeci">TCPServer(EPoll &amp;ePoll, IPAddress address, std::string delimiter=&quot; &quot;, int depth=10, std::string text=&quot;&quot;)</div><div class="ttdef"><b>Definition:</b> TCPServer.cpp:9</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_aeed1bc55d099667ccda51cd682bfc633"><div class="ttname"><a href="classcore_1_1TCPServer.html#aeed1bc55d099667ccda51cd682bfc633">core::TCPServer::sessions</a></div><div class="ttdeci">std::vector&lt; TCPSession * &gt; sessions</div><div class="ttdef"><b>Definition:</b> TCPServer.h:62</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_afcc44802b988e2f4292504e804dccf8b"><div class="ttname"><a href="classcore_1_1TCPServer.html#afcc44802b988e2f4292504e804dccf8b">core::TCPServer::commands</a></div><div class="ttdeci">CommandList commands</div><div class="ttdef"><b>Definition:</b> TCPServer.h:69</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:24</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html"><div class="ttname"><a href="classcore_1_1TCPServer.html">core::TCPServer</a></div><div class="ttdef"><b>Definition:</b> TCPServer.h:28</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_a276ccbc8cb9b4380ebd78807b97f0159"><div class="ttname"><a href="classcore_1_1TCPServer.html#a276ccbc8cb9b4380ebd78807b97f0159">core::TCPServer::onDataReceived</a></div><div class="ttdeci">void onDataReceived(std::string data) override</div><div class="ttdef"><b>Definition:</b> TCPServer.cpp:39</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_a28302dd844cfc971ee41de2000d24aa0"><div class="ttname"><a href="classcore_1_1TCPServer.html#a28302dd844cfc971ee41de2000d24aa0">core::TCPServer::subscriptions</a></div><div class="ttdeci">SubscriptionManager subscriptions</div><div class="ttdef"><b>Definition:</b> TCPServer.h:118</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_a49e3ead1bf4e7830685780e73c4db5db"><div class="ttname"><a href="classcore_1_1TCPServer.html#a49e3ead1bf4e7830685780e73c4db5db">core::TCPServer::output</a></div><div class="ttdeci">void output(std::stringstream &amp;out)</div><div class="ttdoc">Output the consoles array to the console.</div><div class="ttdef"><b>Definition:</b> TCPServer.cpp:99</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_a6b7a7e1ac4132942fcaf418ed41c1437"><div class="ttname"><a href="classcore_1_1TCPServer.html#a6b7a7e1ac4132942fcaf418ed41c1437">core::TCPServer::processCommand</a></div><div class="ttdeci">int processCommand(coreutils::ZString &amp;request, TCPSession &amp;session) override</div><div class="ttdef"><b>Definition:</b> TCPServer.cpp:104</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_a7ccdc057c9eee8504fce796301f82088"><div class="ttname"><a href="classcore_1_1TCPServer.html#a7ccdc057c9eee8504fce796301f82088">core::TCPServer::~TCPServer</a></div><div class="ttdeci">virtual ~TCPServer()</div><div class="ttdef"><b>Definition:</b> TCPServer.cpp:33</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_a82f6bf16e4ab20d8b30da09e034fffff"><div class="ttname"><a href="classcore_1_1TCPServer.html#a82f6bf16e4ab20d8b30da09e034fffff">core::TCPServer::blackList</a></div><div class="ttdeci">IPAddressList * blackList</div><div class="ttdef"><b>Definition:</b> TCPServer.h:79</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_a841f02799ad8529aad7cea132f4de8a9"><div class="ttname"><a href="classcore_1_1TCPServer.html#a841f02799ad8529aad7cea132f4de8a9">core::TCPServer::getSocketAccept</a></div><div class="ttdeci">virtual TCPSession * getSocketAccept(EPoll &amp;epoll)</div><div class="ttdef"><b>Definition:</b> TCPServer.cpp:94</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_a9042281193e227a6cd8dab3ff8b46a40"><div class="ttname"><a href="classcore_1_1TCPServer.html#a9042281193e227a6cd8dab3ff8b46a40">core::TCPServer::getSessionByAlias</a></div><div class="ttdeci">TCPSession * getSessionByAlias(void *alias)</div><div class="ttdef"><b>Definition:</b> TCPServer.cpp:140</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_abad6300b6234ca8b69cef9128755342e"><div class="ttname"><a href="classcore_1_1TCPServer.html#abad6300b6234ca8b69cef9128755342e">core::TCPServer::whiteList</a></div><div class="ttdeci">IPAddressList * whiteList</div><div class="ttdef"><b>Definition:</b> TCPServer.h:87</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_abaecb97c336b757d1029d45277f9fc5b"><div class="ttname"><a href="classcore_1_1TCPServer.html#abaecb97c336b757d1029d45277f9fc5b">core::TCPServer::TCPServer</a></div><div class="ttdeci">TCPServer(EPoll &amp;ePoll, IPAddress address, std::string delimiter=&quot; &quot;, int depth=10, std::string text=&quot;&quot;)</div><div class="ttdef"><b>Definition:</b> TCPServer.cpp:10</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_aeed1bc55d099667ccda51cd682bfc633"><div class="ttname"><a href="classcore_1_1TCPServer.html#aeed1bc55d099667ccda51cd682bfc633">core::TCPServer::sessions</a></div><div class="ttdeci">std::vector&lt; TCPSession * &gt; sessions</div><div class="ttdef"><b>Definition:</b> TCPServer.h:64</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html_afcc44802b988e2f4292504e804dccf8b"><div class="ttname"><a href="classcore_1_1TCPServer.html#afcc44802b988e2f4292504e804dccf8b">core::TCPServer::commands</a></div><div class="ttdeci">CommandList commands</div><div class="ttdef"><b>Definition:</b> TCPServer.h:71</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:26</div></div>
<div class="ttc" id="aclasscore_1_1TCPSocket_html"><div class="ttname"><a href="classcore_1_1TCPSocket.html">core::TCPSocket</a></div><div class="ttdef"><b>Definition:</b> TCPSocket.h:20</div></div>
</div><!-- fragment --></div><!-- contents -->
<!-- start footer part -->

169
html/TCPSession_8h_source.html
View File

@ -66,94 +66,97 @@ $(function() {
</div><!--header-->
<div class="contents">
<div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno"> 1</span>&#160;<span class="preprocessor">#ifndef __Session_h__</span></div>
<div class="line"><a name="l00002"></a><span class="lineno"> 2</span>&#160;<span class="preprocessor"># define __Session_h__</span></div>
<div class="line"><a name="l00002"></a><span class="lineno"> 2</span>&#160;<span class="preprocessor">#define __Session_h__</span></div>
<div class="line"><a name="l00003"></a><span class="lineno"> 3</span>&#160; </div>
<div class="line"><a name="l00004"></a><span class="lineno"> 4</span>&#160;<span class="preprocessor">#include &quot;TCPSocket.h&quot;</span></div>
<div class="line"><a name="l00005"></a><span class="lineno"> 5</span>&#160;<span class="preprocessor">#include &quot;SessionFilter.h&quot;</span></div>
<div class="line"><a name="l00004"></a><span class="lineno"> 4</span>&#160;<span class="preprocessor">#include &quot;SessionFilter.h&quot;</span></div>
<div class="line"><a name="l00005"></a><span class="lineno"> 5</span>&#160;<span class="preprocessor">#include &quot;TCPSocket.h&quot;</span></div>
<div class="line"><a name="l00006"></a><span class="lineno"> 6</span>&#160; </div>
<div class="line"><a name="l00007"></a><span class="lineno"> 7</span>&#160;<span class="keyword">namespace </span>core {</div>
<div class="line"><a name="l00008"></a><span class="lineno"> 8</span>&#160; </div>
<div class="line"><a name="l00009"></a><span class="lineno"> 9</span>&#160; <span class="keyword">class </span>Command;</div>
<div class="line"><a name="l00010"></a><span class="lineno"> 10</span>&#160; <span class="keyword">class </span>TCPServer;</div>
<div class="line"><a name="l00011"></a><span class="lineno"> 11</span>&#160; </div>
<div class="line"><a name="l00023"></a><span class="lineno"> 23</span>&#160; </div>
<div class="line"><a name="l00024"></a><span class="lineno"><a class="line" href="classcore_1_1TCPSession.html"> 24</a></span>&#160; <span class="keyword">class </span><a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> : <span class="keyword">public</span> <a class="code" href="classcore_1_1TCPSocket.html">TCPSocket</a> {</div>
<div class="line"><a name="l00025"></a><span class="lineno"> 25</span>&#160; </div>
<div class="line"><a name="l00026"></a><span class="lineno"> 26</span>&#160; <span class="keyword">public</span>:</div>
<div class="line"><a name="l00007"></a><span class="lineno"> 7</span>&#160;<span class="keyword">namespace </span>core</div>
<div class="line"><a name="l00008"></a><span class="lineno"> 8</span>&#160;{</div>
<div class="line"><a name="l00009"></a><span class="lineno"> 9</span>&#160; </div>
<div class="line"><a name="l00010"></a><span class="lineno"> 10</span>&#160; <span class="keyword">class </span>Command;</div>
<div class="line"><a name="l00011"></a><span class="lineno"> 11</span>&#160; <span class="keyword">class </span>TCPServer;</div>
<div class="line"><a name="l00012"></a><span class="lineno"> 12</span>&#160; </div>
<div class="line"><a name="l00024"></a><span class="lineno"> 24</span>&#160; </div>
<div class="line"><a name="l00025"></a><span class="lineno"><a class="line" href="classcore_1_1TCPSession.html"> 25</a></span>&#160; <span class="keyword">class </span><a class="code" href="classcore_1_1TCPSession.html">TCPSession</a> : <span class="keyword">public</span> <a class="code" href="classcore_1_1TCPSocket.html">TCPSocket</a></div>
<div class="line"><a name="l00026"></a><span class="lineno"> 26</span>&#160; {</div>
<div class="line"><a name="l00027"></a><span class="lineno"> 27</span>&#160; </div>
<div class="line"><a name="l00031"></a><span class="lineno"> 31</span>&#160; </div>
<div class="line"><a name="l00032"></a><span class="lineno"> 32</span>&#160; <a class="code" href="classcore_1_1TCPSession.html">TCPSession</a>(<a class="code" href="classcore_1_1EPoll.html">EPoll</a> &amp;ePoll, <a class="code" href="classcore_1_1TCPServer.html">TCPServer</a> &amp;server, std::string text = <span class="stringliteral">&quot;&quot;</span>);</div>
<div class="line"><a name="l00033"></a><span class="lineno"> 33</span>&#160; </div>
<div class="line"><a name="l00037"></a><span class="lineno"> 37</span>&#160; </div>
<div class="line"><a name="l00038"></a><span class="lineno"> 38</span>&#160; <span class="keyword">virtual</span> ~<a class="code" href="classcore_1_1TCPSession.html">TCPSession</a>();</div>
<div class="line"><a name="l00039"></a><span class="lineno"> 39</span>&#160; </div>
<div class="line"><a name="l00040"></a><span class="lineno"> 40</span>&#160; <a class="code" href="classcore_1_1Command.html">Command</a> *grab = NULL;</div>
<div class="line"><a name="l00041"></a><span class="lineno"> 41</span>&#160; </div>
<div class="line"><a name="l00042"></a><span class="lineno"> 42</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#a50037cbfc515650e04054e5481785981">output</a>(std::stringstream &amp;data);</div>
<div class="line"><a name="l00043"></a><span class="lineno"> 43</span>&#160; </div>
<div class="line"><a name="l00048"></a><span class="lineno"> 48</span>&#160; </div>
<div class="line"><a name="l00049"></a><span class="lineno"> 49</span>&#160; <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#a2b09eeafef5e44009a77d9da43e3b889">send</a>();</div>
<div class="line"><a name="l00050"></a><span class="lineno"> 50</span>&#160; </div>
<div class="line"><a name="l00054"></a><span class="lineno"> 54</span>&#160; </div>
<div class="line"><a name="l00055"></a><span class="lineno"> 55</span>&#160; <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#a34936745e8d7669d5400e78d353a56d3">terminate</a>();</div>
<div class="line"><a name="l00056"></a><span class="lineno"> 56</span>&#160; </div>
<div class="line"><a name="l00060"></a><span class="lineno"> 60</span>&#160; </div>
<div class="line"><a name="l00061"></a><span class="lineno"> 61</span>&#160; <a class="code" href="classcore_1_1TCPServer.html">TCPServer</a> &amp;server;</div>
<div class="line"><a name="l00062"></a><span class="lineno"> 62</span>&#160; </div>
<div class="line"><a name="l00066"></a><span class="lineno"> 66</span>&#160; </div>
<div class="line"><a name="l00067"></a><span class="lineno"><a class="line" href="classcore_1_1TCPSession.html#abb302bbb3d7e7bc75490c736364f0d4d"> 67</a></span>&#160; std::stringstream <a class="code" href="classcore_1_1TCPSession.html#abb302bbb3d7e7bc75490c736364f0d4d">out</a>;</div>
<div class="line"><a name="l00068"></a><span class="lineno"> 68</span>&#160; </div>
<div class="line"><a name="l00069"></a><span class="lineno"> 69</span>&#160; <span class="keyword">protected</span>:</div>
<div class="line"><a name="l00070"></a><span class="lineno"> 70</span>&#160; </div>
<div class="line"><a name="l00074"></a><span class="lineno"> 74</span>&#160; </div>
<div class="line"><a name="l00075"></a><span class="lineno"> 75</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#aed4ed499b978bcea57a8efefe929fc98">onRegistered</a>() <span class="keyword">override</span>;</div>
<div class="line"><a name="l00076"></a><span class="lineno"> 76</span>&#160; </div>
<div class="line"><a name="l00082"></a><span class="lineno"> 82</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#afc2d2a92bc65e1e5122a93d120253a1d">onDataReceived</a>(coreutils::ZString &amp;data) <span class="keyword">override</span>;</div>
<div class="line"><a name="l00083"></a><span class="lineno"> 83</span>&#160; </div>
<div class="line"><a name="l00090"></a><span class="lineno"> 90</span>&#160; </div>
<div class="line"><a name="l00091"></a><span class="lineno"> 91</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#a3d9e0f14e7d24357fd1950b3f9b4eaff">onLineReceived</a>(coreutils::ZString &amp;line);</div>
<div class="line"><a name="l00092"></a><span class="lineno"> 92</span>&#160; </div>
<div class="line"><a name="l00099"></a><span class="lineno"> 99</span>&#160; </div>
<div class="line"><a name="l00100"></a><span class="lineno"> 100</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#a9c996cbbfa2e592c23cf67ed8b15a32a">onBlockReceived</a>(coreutils::ZString &amp;block);</div>
<div class="line"><a name="l00101"></a><span class="lineno"> 101</span>&#160; </div>
<div class="line"><a name="l00107"></a><span class="lineno"> 107</span>&#160; </div>
<div class="line"><a name="l00108"></a><span class="lineno"> 108</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#a8719952f7bb00bf7239ec40aa2868626">onConnected</a>();</div>
<div class="line"><a name="l00109"></a><span class="lineno"> 109</span>&#160; </div>
<div class="line"><a name="l00119"></a><span class="lineno"> 119</span>&#160; </div>
<div class="line"><a name="l00120"></a><span class="lineno"> 120</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#a98a65da2346b79bee659fca6902e94c7">protocol</a>(coreutils::ZString &amp;data);</div>
<div class="line"><a name="l00121"></a><span class="lineno"> 121</span>&#160; </div>
<div class="line"><a name="l00127"></a><span class="lineno"> 127</span>&#160; </div>
<div class="line"><a name="l00128"></a><span class="lineno"> 128</span>&#160; <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#a836fb3fd5ee543ebc93262a980ae88b5">setBlockSize</a>(<span class="keywordtype">int</span> size = 0);</div>
<div class="line"><a name="l00129"></a><span class="lineno"> 129</span>&#160; </div>
<div class="line"><a name="l00130"></a><span class="lineno"> 130</span>&#160; <span class="keyword">private</span>:</div>
<div class="line"><a name="l00131"></a><span class="lineno"> 131</span>&#160; <span class="keywordtype">char</span> *lineBuffer = NULL;</div>
<div class="line"><a name="l00132"></a><span class="lineno"> 132</span>&#160; <span class="keywordtype">int</span> lineBufferSize = 0;</div>
<div class="line"><a name="l00133"></a><span class="lineno"> 133</span>&#160; <span class="keywordtype">int</span> lineLength = 0;</div>
<div class="line"><a name="l00134"></a><span class="lineno"> 134</span>&#160; <span class="keywordtype">int</span> blockLength = 0;</div>
<div class="line"><a name="l00135"></a><span class="lineno"> 135</span>&#160; std::mutex mtx;</div>
<div class="line"><a name="l00136"></a><span class="lineno"> 136</span>&#160; <span class="keywordtype">bool</span> term = <span class="keyword">false</span>;</div>
<div class="line"><a name="l00137"></a><span class="lineno"> 137</span>&#160; <span class="keywordtype">int</span> blockSize = 0;</div>
<div class="line"><a name="l00138"></a><span class="lineno"> 138</span>&#160; </div>
<div class="line"><a name="l00139"></a><span class="lineno"> 139</span>&#160; };</div>
<div class="line"><a name="l00140"></a><span class="lineno"> 140</span>&#160; </div>
<div class="line"><a name="l00141"></a><span class="lineno"> 141</span>&#160;}</div>
<div class="line"><a name="l00142"></a><span class="lineno"> 142</span>&#160; </div>
<div class="line"><a name="l00143"></a><span class="lineno"> 143</span>&#160;<span class="preprocessor">#endif</span></div>
<div class="line"><a name="l00028"></a><span class="lineno"> 28</span>&#160; <span class="keyword">public</span>:</div>
<div class="line"><a name="l00032"></a><span class="lineno"> 32</span>&#160; </div>
<div class="line"><a name="l00033"></a><span class="lineno"> 33</span>&#160; <a class="code" href="classcore_1_1TCPSession.html">TCPSession</a>(<a class="code" href="classcore_1_1EPoll.html">EPoll</a> &amp;ePoll, <a class="code" href="classcore_1_1TCPServer.html">TCPServer</a> &amp;server, std::string text = <span class="stringliteral">&quot;&quot;</span>);</div>
<div class="line"><a name="l00034"></a><span class="lineno"> 34</span>&#160; </div>
<div class="line"><a name="l00038"></a><span class="lineno"> 38</span>&#160; </div>
<div class="line"><a name="l00039"></a><span class="lineno"> 39</span>&#160; <span class="keyword">virtual</span> ~<a class="code" href="classcore_1_1TCPSession.html">TCPSession</a>();</div>
<div class="line"><a name="l00040"></a><span class="lineno"> 40</span>&#160; </div>
<div class="line"><a name="l00041"></a><span class="lineno"> 41</span>&#160; <a class="code" href="classcore_1_1Command.html">Command</a> *grab = NULL;</div>
<div class="line"><a name="l00042"></a><span class="lineno"> 42</span>&#160; </div>
<div class="line"><a name="l00043"></a><span class="lineno"> 43</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#a50037cbfc515650e04054e5481785981">output</a>(std::stringstream &amp;data);</div>
<div class="line"><a name="l00044"></a><span class="lineno"> 44</span>&#160; </div>
<div class="line"><a name="l00049"></a><span class="lineno"> 49</span>&#160; </div>
<div class="line"><a name="l00050"></a><span class="lineno"> 50</span>&#160; <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#a2b09eeafef5e44009a77d9da43e3b889">send</a>();</div>
<div class="line"><a name="l00051"></a><span class="lineno"> 51</span>&#160; </div>
<div class="line"><a name="l00055"></a><span class="lineno"> 55</span>&#160; </div>
<div class="line"><a name="l00056"></a><span class="lineno"> 56</span>&#160; <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#a34936745e8d7669d5400e78d353a56d3">terminate</a>();</div>
<div class="line"><a name="l00057"></a><span class="lineno"> 57</span>&#160; </div>
<div class="line"><a name="l00061"></a><span class="lineno"> 61</span>&#160; </div>
<div class="line"><a name="l00062"></a><span class="lineno"> 62</span>&#160; <a class="code" href="classcore_1_1TCPServer.html">TCPServer</a> &amp;server;</div>
<div class="line"><a name="l00063"></a><span class="lineno"> 63</span>&#160; </div>
<div class="line"><a name="l00067"></a><span class="lineno"> 67</span>&#160; </div>
<div class="line"><a name="l00068"></a><span class="lineno"><a class="line" href="classcore_1_1TCPSession.html#abb302bbb3d7e7bc75490c736364f0d4d"> 68</a></span>&#160; std::stringstream <a class="code" href="classcore_1_1TCPSession.html#abb302bbb3d7e7bc75490c736364f0d4d">out</a>;</div>
<div class="line"><a name="l00069"></a><span class="lineno"> 69</span>&#160; </div>
<div class="line"><a name="l00070"></a><span class="lineno"> 70</span>&#160; <span class="keywordtype">char</span> uuid[37];</div>
<div class="line"><a name="l00071"></a><span class="lineno"> 71</span>&#160; </div>
<div class="line"><a name="l00072"></a><span class="lineno"> 72</span>&#160; <span class="keywordtype">void</span> *alias;</div>
<div class="line"><a name="l00073"></a><span class="lineno"> 73</span>&#160; </div>
<div class="line"><a name="l00074"></a><span class="lineno"> 74</span>&#160; <span class="keyword">protected</span>:</div>
<div class="line"><a name="l00078"></a><span class="lineno"> 78</span>&#160; </div>
<div class="line"><a name="l00079"></a><span class="lineno"> 79</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#aed4ed499b978bcea57a8efefe929fc98">onRegistered</a>() <span class="keyword">override</span>;</div>
<div class="line"><a name="l00080"></a><span class="lineno"> 80</span>&#160; </div>
<div class="line"><a name="l00086"></a><span class="lineno"> 86</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#afc2d2a92bc65e1e5122a93d120253a1d">onDataReceived</a>(coreutils::ZString &amp;data) <span class="keyword">override</span>;</div>
<div class="line"><a name="l00087"></a><span class="lineno"> 87</span>&#160; </div>
<div class="line"><a name="l00094"></a><span class="lineno"> 94</span>&#160; </div>
<div class="line"><a name="l00095"></a><span class="lineno"> 95</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#a3d9e0f14e7d24357fd1950b3f9b4eaff">onLineReceived</a>(coreutils::ZString &amp;line);</div>
<div class="line"><a name="l00096"></a><span class="lineno"> 96</span>&#160; </div>
<div class="line"><a name="l00103"></a><span class="lineno"> 103</span>&#160; </div>
<div class="line"><a name="l00104"></a><span class="lineno"> 104</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#a9c996cbbfa2e592c23cf67ed8b15a32a">onBlockReceived</a>(coreutils::ZString &amp;block);</div>
<div class="line"><a name="l00105"></a><span class="lineno"> 105</span>&#160; </div>
<div class="line"><a name="l00111"></a><span class="lineno"> 111</span>&#160; </div>
<div class="line"><a name="l00112"></a><span class="lineno"> 112</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#a8719952f7bb00bf7239ec40aa2868626">onConnected</a>();</div>
<div class="line"><a name="l00113"></a><span class="lineno"> 113</span>&#160; </div>
<div class="line"><a name="l00123"></a><span class="lineno"> 123</span>&#160; </div>
<div class="line"><a name="l00124"></a><span class="lineno"> 124</span>&#160; <span class="keyword">virtual</span> <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#a98a65da2346b79bee659fca6902e94c7">protocol</a>(coreutils::ZString &amp;data);</div>
<div class="line"><a name="l00125"></a><span class="lineno"> 125</span>&#160; </div>
<div class="line"><a name="l00131"></a><span class="lineno"> 131</span>&#160; </div>
<div class="line"><a name="l00132"></a><span class="lineno"> 132</span>&#160; <span class="keywordtype">void</span> <a class="code" href="classcore_1_1TCPSession.html#a836fb3fd5ee543ebc93262a980ae88b5">setBlockSize</a>(<span class="keywordtype">int</span> size = 0);</div>
<div class="line"><a name="l00133"></a><span class="lineno"> 133</span>&#160; </div>
<div class="line"><a name="l00134"></a><span class="lineno"> 134</span>&#160; <span class="keyword">private</span>:</div>
<div class="line"><a name="l00135"></a><span class="lineno"> 135</span>&#160; <span class="keywordtype">char</span> *lineBuffer = NULL;</div>
<div class="line"><a name="l00136"></a><span class="lineno"> 136</span>&#160; <span class="keywordtype">int</span> lineBufferSize = 0;</div>
<div class="line"><a name="l00137"></a><span class="lineno"> 137</span>&#160; <span class="keywordtype">int</span> lineLength = 0;</div>
<div class="line"><a name="l00138"></a><span class="lineno"> 138</span>&#160; <span class="keywordtype">int</span> blockLength = 0;</div>
<div class="line"><a name="l00139"></a><span class="lineno"> 139</span>&#160; std::mutex mtx;</div>
<div class="line"><a name="l00140"></a><span class="lineno"> 140</span>&#160; <span class="keywordtype">bool</span> term = <span class="keyword">false</span>;</div>
<div class="line"><a name="l00141"></a><span class="lineno"> 141</span>&#160; <span class="keywordtype">int</span> blockSize = 0;</div>
<div class="line"><a name="l00142"></a><span class="lineno"> 142</span>&#160; };</div>
<div class="line"><a name="l00143"></a><span class="lineno"> 143</span>&#160; </div>
<div class="line"><a name="l00144"></a><span class="lineno"> 144</span>&#160;}</div>
<div class="line"><a name="l00145"></a><span class="lineno"> 145</span>&#160; </div>
<div class="line"><a name="l00146"></a><span class="lineno"> 146</span>&#160;<span class="preprocessor">#endif</span></div>
<div class="ttc" id="aclasscore_1_1Command_html"><div class="ttname"><a href="classcore_1_1Command.html">core::Command</a></div><div class="ttdef"><b>Definition:</b> Command.h:22</div></div>
<div class="ttc" id="aclasscore_1_1EPoll_html"><div class="ttname"><a href="classcore_1_1EPoll.html">core::EPoll</a></div><div class="ttdef"><b>Definition:</b> EPoll.h:31</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html"><div class="ttname"><a href="classcore_1_1TCPServer.html">core::TCPServer</a></div><div class="ttdef"><b>Definition:</b> TCPServer.h:25</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:24</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_a2b09eeafef5e44009a77d9da43e3b889"><div class="ttname"><a href="classcore_1_1TCPSession.html#a2b09eeafef5e44009a77d9da43e3b889">core::TCPSession::send</a></div><div class="ttdeci">void send()</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:84</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_a34936745e8d7669d5400e78d353a56d3"><div class="ttname"><a href="classcore_1_1TCPSession.html#a34936745e8d7669d5400e78d353a56d3">core::TCPSession::terminate</a></div><div class="ttdeci">void terminate()</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:90</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_a3d9e0f14e7d24357fd1950b3f9b4eaff"><div class="ttname"><a href="classcore_1_1TCPSession.html#a3d9e0f14e7d24357fd1950b3f9b4eaff">core::TCPSession::onLineReceived</a></div><div class="ttdeci">virtual void onLineReceived(coreutils::ZString &amp;line)</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:71</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_a50037cbfc515650e04054e5481785981"><div class="ttname"><a href="classcore_1_1TCPSession.html#a50037cbfc515650e04054e5481785981">core::TCPSession::output</a></div><div class="ttdeci">virtual void output(std::stringstream &amp;data)</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:15</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_a836fb3fd5ee543ebc93262a980ae88b5"><div class="ttname"><a href="classcore_1_1TCPSession.html#a836fb3fd5ee543ebc93262a980ae88b5">core::TCPSession::setBlockSize</a></div><div class="ttdeci">void setBlockSize(int size=0)</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:67</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_a8719952f7bb00bf7239ec40aa2868626"><div class="ttname"><a href="classcore_1_1TCPSession.html#a8719952f7bb00bf7239ec40aa2868626">core::TCPSession::onConnected</a></div><div class="ttdeci">virtual void onConnected()</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:33</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_a98a65da2346b79bee659fca6902e94c7"><div class="ttname"><a href="classcore_1_1TCPSession.html#a98a65da2346b79bee659fca6902e94c7">core::TCPSession::protocol</a></div><div class="ttdeci">virtual void protocol(coreutils::ZString &amp;data)</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:19</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_a9c996cbbfa2e592c23cf67ed8b15a32a"><div class="ttname"><a href="classcore_1_1TCPSession.html#a9c996cbbfa2e592c23cf67ed8b15a32a">core::TCPSession::onBlockReceived</a></div><div class="ttdeci">virtual void onBlockReceived(coreutils::ZString &amp;block)</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:78</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_abb302bbb3d7e7bc75490c736364f0d4d"><div class="ttname"><a href="classcore_1_1TCPSession.html#abb302bbb3d7e7bc75490c736364f0d4d">core::TCPSession::out</a></div><div class="ttdeci">std::stringstream out</div><div class="ttdef"><b>Definition:</b> TCPSession.h:67</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_aed4ed499b978bcea57a8efefe929fc98"><div class="ttname"><a href="classcore_1_1TCPSession.html#aed4ed499b978bcea57a8efefe929fc98">core::TCPSession::onRegistered</a></div><div class="ttdeci">virtual void onRegistered() override</div><div class="ttdoc">Called after the socket has been registered with epoll processing.</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:24</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_afc2d2a92bc65e1e5122a93d120253a1d"><div class="ttname"><a href="classcore_1_1TCPSession.html#afc2d2a92bc65e1e5122a93d120253a1d">core::TCPSession::onDataReceived</a></div><div class="ttdeci">virtual void onDataReceived(coreutils::ZString &amp;data) override</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:35</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html"><div class="ttname"><a href="classcore_1_1TCPServer.html">core::TCPServer</a></div><div class="ttdef"><b>Definition:</b> TCPServer.h:28</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:26</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_a2b09eeafef5e44009a77d9da43e3b889"><div class="ttname"><a href="classcore_1_1TCPSession.html#a2b09eeafef5e44009a77d9da43e3b889">core::TCPSession::send</a></div><div class="ttdeci">void send()</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:111</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_a34936745e8d7669d5400e78d353a56d3"><div class="ttname"><a href="classcore_1_1TCPSession.html#a34936745e8d7669d5400e78d353a56d3">core::TCPSession::terminate</a></div><div class="ttdeci">void terminate()</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:118</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_a3d9e0f14e7d24357fd1950b3f9b4eaff"><div class="ttname"><a href="classcore_1_1TCPSession.html#a3d9e0f14e7d24357fd1950b3f9b4eaff">core::TCPSession::onLineReceived</a></div><div class="ttdeci">virtual void onLineReceived(coreutils::ZString &amp;line)</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:96</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_a50037cbfc515650e04054e5481785981"><div class="ttname"><a href="classcore_1_1TCPSession.html#a50037cbfc515650e04054e5481785981">core::TCPSession::output</a></div><div class="ttdeci">virtual void output(std::stringstream &amp;data)</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:25</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_a836fb3fd5ee543ebc93262a980ae88b5"><div class="ttname"><a href="classcore_1_1TCPSession.html#a836fb3fd5ee543ebc93262a980ae88b5">core::TCPSession::setBlockSize</a></div><div class="ttdeci">void setBlockSize(int size=0)</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:91</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_a8719952f7bb00bf7239ec40aa2868626"><div class="ttname"><a href="classcore_1_1TCPSession.html#a8719952f7bb00bf7239ec40aa2868626">core::TCPSession::onConnected</a></div><div class="ttdeci">virtual void onConnected()</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:51</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_a98a65da2346b79bee659fca6902e94c7"><div class="ttname"><a href="classcore_1_1TCPSession.html#a98a65da2346b79bee659fca6902e94c7">core::TCPSession::protocol</a></div><div class="ttdeci">virtual void protocol(coreutils::ZString &amp;data)</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:30</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_a9c996cbbfa2e592c23cf67ed8b15a32a"><div class="ttname"><a href="classcore_1_1TCPSession.html#a9c996cbbfa2e592c23cf67ed8b15a32a">core::TCPSession::onBlockReceived</a></div><div class="ttdeci">virtual void onBlockReceived(coreutils::ZString &amp;block)</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:104</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_abb302bbb3d7e7bc75490c736364f0d4d"><div class="ttname"><a href="classcore_1_1TCPSession.html#abb302bbb3d7e7bc75490c736364f0d4d">core::TCPSession::out</a></div><div class="ttdeci">std::stringstream out</div><div class="ttdef"><b>Definition:</b> TCPSession.h:68</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_aed4ed499b978bcea57a8efefe929fc98"><div class="ttname"><a href="classcore_1_1TCPSession.html#aed4ed499b978bcea57a8efefe929fc98">core::TCPSession::onRegistered</a></div><div class="ttdeci">virtual void onRegistered() override</div><div class="ttdoc">Called after the socket has been registered with epoll processing.</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:41</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_afc2d2a92bc65e1e5122a93d120253a1d"><div class="ttname"><a href="classcore_1_1TCPSession.html#afc2d2a92bc65e1e5122a93d120253a1d">core::TCPSession::onDataReceived</a></div><div class="ttdeci">virtual void onDataReceived(coreutils::ZString &amp;data) override</div><div class="ttdef"><b>Definition:</b> TCPSession.cpp:53</div></div>
<div class="ttc" id="aclasscore_1_1TCPSocket_html"><div class="ttname"><a href="classcore_1_1TCPSocket.html">core::TCPSocket</a></div><div class="ttdef"><b>Definition:</b> TCPSocket.h:20</div></div>
</div><!-- fragment --></div><!-- contents -->
<!-- start footer part -->

4
html/TLSServer_8h_source.html
View File

@ -104,8 +104,8 @@ $(function() {
<div class="line"><a name="l00054"></a><span class="lineno"> 54</span>&#160;<span class="preprocessor">#endif</span></div>
<div class="ttc" id="aclasscore_1_1EPoll_html"><div class="ttname"><a href="classcore_1_1EPoll.html">core::EPoll</a></div><div class="ttdef"><b>Definition:</b> EPoll.h:31</div></div>
<div class="ttc" id="aclasscore_1_1IPAddress_html"><div class="ttname"><a href="classcore_1_1IPAddress.html">core::IPAddress</a></div><div class="ttdef"><b>Definition:</b> IPAddress.h:9</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html"><div class="ttname"><a href="classcore_1_1TCPServer.html">core::TCPServer</a></div><div class="ttdef"><b>Definition:</b> TCPServer.h:25</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:24</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html"><div class="ttname"><a href="classcore_1_1TCPServer.html">core::TCPServer</a></div><div class="ttdef"><b>Definition:</b> TCPServer.h:28</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:26</div></div>
<div class="ttc" id="aclasscore_1_1TLSServer_html"><div class="ttname"><a href="classcore_1_1TLSServer.html">core::TLSServer</a></div><div class="ttdef"><b>Definition:</b> TLSServer.h:19</div></div>
<div class="ttc" id="aclasscore_1_1TLSServer_html_a6460f9872936015efdfd0b8de04aa2fe"><div class="ttname"><a href="classcore_1_1TLSServer.html#a6460f9872936015efdfd0b8de04aa2fe">core::TLSServer::TLSServer</a></div><div class="ttdeci">TLSServer(EPoll &amp;ePoll, IPAddress address)</div><div class="ttdef"><b>Definition:</b> TLSServer.cpp:22</div></div>
<div class="ttc" id="aclasscore_1_1TLSServer_html_ac71db77c796a1bf65357409cb96054c7"><div class="ttname"><a href="classcore_1_1TLSServer.html#ac71db77c796a1bf65357409cb96054c7">core::TLSServer::~TLSServer</a></div><div class="ttdeci">~TLSServer()</div><div class="ttdef"><b>Definition:</b> TLSServer.cpp:58</div></div>

6
html/TLSSession_8h_source.html
View File

@ -104,9 +104,9 @@ $(function() {
<div class="line"><a name="l00052"></a><span class="lineno"> 52</span>&#160; </div>
<div class="line"><a name="l00053"></a><span class="lineno"> 53</span>&#160;<span class="preprocessor">#endif</span></div>
<div class="ttc" id="aclasscore_1_1EPoll_html"><div class="ttname"><a href="classcore_1_1EPoll.html">core::EPoll</a></div><div class="ttdef"><b>Definition:</b> EPoll.h:31</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html"><div class="ttname"><a href="classcore_1_1TCPServer.html">core::TCPServer</a></div><div class="ttdef"><b>Definition:</b> TCPServer.h:25</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:24</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_abb302bbb3d7e7bc75490c736364f0d4d"><div class="ttname"><a href="classcore_1_1TCPSession.html#abb302bbb3d7e7bc75490c736364f0d4d">core::TCPSession::out</a></div><div class="ttdeci">std::stringstream out</div><div class="ttdef"><b>Definition:</b> TCPSession.h:67</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html"><div class="ttname"><a href="classcore_1_1TCPServer.html">core::TCPServer</a></div><div class="ttdef"><b>Definition:</b> TCPServer.h:28</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:26</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html_abb302bbb3d7e7bc75490c736364f0d4d"><div class="ttname"><a href="classcore_1_1TCPSession.html#abb302bbb3d7e7bc75490c736364f0d4d">core::TCPSession::out</a></div><div class="ttdeci">std::stringstream out</div><div class="ttdef"><b>Definition:</b> TCPSession.h:68</div></div>
<div class="ttc" id="aclasscore_1_1TLSSession_html"><div class="ttname"><a href="classcore_1_1TLSSession.html">core::TLSSession</a></div><div class="ttdef"><b>Definition:</b> TLSSession.h:23</div></div>
<div class="ttc" id="aclasscore_1_1TLSSession_html_a208145cc1fcdc14054602aacc2c51d91"><div class="ttname"><a href="classcore_1_1TLSSession.html#a208145cc1fcdc14054602aacc2c51d91">core::TLSSession::protocol</a></div><div class="ttdeci">virtual void protocol(coreutils::ZString &amp;data) override</div><div class="ttdef"><b>Definition:</b> TLSSession.cpp:83</div></div>
<div class="ttc" id="aclasscore_1_1TLSSession_html_a76cec7cf4851eb27abe77a2339344c6d"><div class="ttname"><a href="classcore_1_1TLSSession.html#a76cec7cf4851eb27abe77a2339344c6d">core::TLSSession::onRegister</a></div><div class="ttdeci">void onRegister()</div><div class="ttdoc">Called before the socket has registered with the epoll processing.</div><div class="ttdef"><b>Definition:</b> TLSSession.cpp:36</div></div>

4
html/TerminalSession_8h_source.html
View File

@ -124,8 +124,8 @@ $(function() {
<div class="line"><a name="l00066"></a><span class="lineno"> 66</span>&#160; </div>
<div class="line"><a name="l00067"></a><span class="lineno"> 67</span>&#160;<span class="preprocessor">#endif</span></div>
<div class="ttc" id="aclasscore_1_1EPoll_html"><div class="ttname"><a href="classcore_1_1EPoll.html">core::EPoll</a></div><div class="ttdef"><b>Definition:</b> EPoll.h:31</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html"><div class="ttname"><a href="classcore_1_1TCPServer.html">core::TCPServer</a></div><div class="ttdef"><b>Definition:</b> TCPServer.h:25</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:24</div></div>
<div class="ttc" id="aclasscore_1_1TCPServer_html"><div class="ttname"><a href="classcore_1_1TCPServer.html">core::TCPServer</a></div><div class="ttdef"><b>Definition:</b> TCPServer.h:28</div></div>
<div class="ttc" id="aclasscore_1_1TCPSession_html"><div class="ttname"><a href="classcore_1_1TCPSession.html">core::TCPSession</a></div><div class="ttdef"><b>Definition:</b> TCPSession.h:26</div></div>
<div class="ttc" id="aclasscore_1_1TerminalSession_html"><div class="ttname"><a href="classcore_1_1TerminalSession.html">core::TerminalSession</a></div><div class="ttdef"><b>Definition:</b> TerminalSession.h:30</div></div>
<div class="ttc" id="aclasscore_1_1TerminalSession_html_a42bb06857891220a831da04248233935"><div class="ttname"><a href="classcore_1_1TerminalSession.html#a42bb06857891220a831da04248233935">core::TerminalSession::clear</a></div><div class="ttdeci">void clear()</div><div class="ttdef"><b>Definition:</b> TerminalSession.cpp:17</div></div>
<div class="ttc" id="aclasscore_1_1TerminalSession_html_aa660768eed03b0b996a749e8a146446c"><div class="ttname"><a href="classcore_1_1TerminalSession.html#aa660768eed03b0b996a749e8a146446c">core::TerminalSession::clearEOL</a></div><div class="ttdeci">void clearEOL()</div><div class="ttdef"><b>Definition:</b> TerminalSession.cpp:21</div></div>

18
html/classcore_1_1ConsoleServer-members.html
View File

@ -74,12 +74,14 @@ $(function() {
<table class="directory">
<tr class="even"><td class="entry"><a class="el" href="classcore_1_1TCPServer.html#a82f6bf16e4ab20d8b30da09e034fffff">blackList</a></td><td class="entry"><a class="el" href="classcore_1_1TCPServer.html">core::TCPServer</a></td><td class="entry"></td></tr>
<tr><td class="entry"><a class="el" href="classcore_1_1TCPServer.html#afcc44802b988e2f4292504e804dccf8b">commands</a></td><td class="entry"><a class="el" href="classcore_1_1TCPServer.html">core::TCPServer</a></td><td class="entry"></td></tr>
<tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>connect</b>(IPAddress &amp;address) (defined in <a class="el" href="classcore_1_1TCPSocket.html">core::TCPSocket</a>)</td><td class="entry"><a class="el" href="classcore_1_1TCPSocket.html">core::TCPSocket</a></td><td class="entry"></td></tr>
<tr bgcolor="#f0f0f0"><td class="entry"><b>ConsoleServer</b>(EPoll &amp;ePoll, IPAddress address) (defined in <a class="el" href="classcore_1_1ConsoleServer.html">core::ConsoleServer</a>)</td><td class="entry"><a class="el" href="classcore_1_1ConsoleServer.html">core::ConsoleServer</a></td><td class="entry"></td></tr>
<tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>ePoll</b> (defined in <a class="el" href="classcore_1_1Socket.html">core::Socket</a>)</td><td class="entry"><a class="el" href="classcore_1_1Socket.html">core::Socket</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
<tr><td class="entry"><a class="el" href="classcore_1_1Socket.html#a1a045e15fb5851d666a21be05ac4c5d7">eventReceived</a>(struct epoll_event event, long long eventId)</td><td class="entry"><a class="el" href="classcore_1_1Socket.html">core::Socket</a></td><td class="entry"></td></tr>
<tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>getBufferSize</b>() (defined in <a class="el" href="classcore_1_1Socket.html">core::Socket</a>)</td><td class="entry"><a class="el" href="classcore_1_1Socket.html">core::Socket</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
<tr><td class="entry"><a class="el" href="classcore_1_1Socket.html#a06ba54744530439d4131e6aba4623d08">getDescriptor</a>()</td><td class="entry"><a class="el" href="classcore_1_1Socket.html">core::Socket</a></td><td class="entry"></td></tr>
<tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>compareAlias</b>(void *alias, void *compare) (defined in <a class="el" href="classcore_1_1TCPServer.html">core::TCPServer</a>)</td><td class="entry"><a class="el" href="classcore_1_1TCPServer.html">core::TCPServer</a></td><td class="entry"><span class="mlabel">virtual</span></td></tr>
<tr bgcolor="#f0f0f0"><td class="entry"><b>connect</b>(IPAddress &amp;address) (defined in <a class="el" href="classcore_1_1TCPSocket.html">core::TCPSocket</a>)</td><td class="entry"><a class="el" href="classcore_1_1TCPSocket.html">core::TCPSocket</a></td><td class="entry"></td></tr>
<tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>ConsoleServer</b>(EPoll &amp;ePoll, IPAddress address) (defined in <a class="el" href="classcore_1_1ConsoleServer.html">core::ConsoleServer</a>)</td><td class="entry"><a class="el" href="classcore_1_1ConsoleServer.html">core::ConsoleServer</a></td><td class="entry"></td></tr>
<tr bgcolor="#f0f0f0"><td class="entry"><b>ePoll</b> (defined in <a class="el" href="classcore_1_1Socket.html">core::Socket</a>)</td><td class="entry"><a class="el" href="classcore_1_1Socket.html">core::Socket</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
<tr class="even"><td class="entry"><a class="el" href="classcore_1_1Socket.html#a1a045e15fb5851d666a21be05ac4c5d7">eventReceived</a>(struct epoll_event event, long long eventId)</td><td class="entry"><a class="el" href="classcore_1_1Socket.html">core::Socket</a></td><td class="entry"></td></tr>
<tr bgcolor="#f0f0f0"><td class="entry"><b>getBufferSize</b>() (defined in <a class="el" href="classcore_1_1Socket.html">core::Socket</a>)</td><td class="entry"><a class="el" href="classcore_1_1Socket.html">core::Socket</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
<tr class="even"><td class="entry"><a class="el" href="classcore_1_1Socket.html#a06ba54744530439d4131e6aba4623d08">getDescriptor</a>()</td><td class="entry"><a class="el" href="classcore_1_1Socket.html">core::Socket</a></td><td class="entry"></td></tr>
<tr><td class="entry"><a class="el" href="classcore_1_1TCPServer.html#a9042281193e227a6cd8dab3ff8b46a40">getSessionByAlias</a>(void *alias)</td><td class="entry"><a class="el" href="classcore_1_1TCPServer.html">core::TCPServer</a></td><td class="entry"></td></tr>
<tr class="even"><td class="entry"><a class="el" href="classcore_1_1ConsoleServer.html#a80d9ea7f3fc5e07c50d5b9e0d4943ca8">getSocketAccept</a>(EPoll &amp;ePoll) override</td><td class="entry"><a class="el" href="classcore_1_1ConsoleServer.html">core::ConsoleServer</a></td><td class="entry"><span class="mlabel">virtual</span></td></tr>
<tr bgcolor="#f0f0f0"><td class="entry"><b>ipAddress</b> (defined in <a class="el" href="classcore_1_1TCPSocket.html">core::TCPSocket</a>)</td><td class="entry"><a class="el" href="classcore_1_1TCPSocket.html">core::TCPSocket</a></td><td class="entry"></td></tr>
<tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>logSend</b>(std::string out) override (defined in <a class="el" href="classcore_1_1ConsoleServer.html">core::ConsoleServer</a>)</td><td class="entry"><a class="el" href="classcore_1_1ConsoleServer.html">core::ConsoleServer</a></td><td class="entry"></td></tr>
@ -102,8 +104,8 @@ $(function() {
<tr><td class="entry"><a class="el" href="classcore_1_1TCPServer.html#aeed1bc55d099667ccda51cd682bfc633">sessions</a></td><td class="entry"><a class="el" href="classcore_1_1TCPServer.html">core::TCPServer</a></td><td class="entry"></td></tr>
<tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>setBufferSize</b>(int length) (defined in <a class="el" href="classcore_1_1Socket.html">core::Socket</a>)</td><td class="entry"><a class="el" href="classcore_1_1Socket.html">core::Socket</a></td><td class="entry"><span class="mlabel">protected</span></td></tr>
<tr><td class="entry"><a class="el" href="classcore_1_1Socket.html#ac44f6ae3196a8a3e09a6a85fcf495762">setDescriptor</a>(int descriptor)</td><td class="entry"><a class="el" href="classcore_1_1Socket.html">core::Socket</a></td><td class="entry"></td></tr>
<tr class="even"><td class="entry"><a class="el" href="classcore_1_1Socket.html#af2d1b6de7a64a9d446b0305b6ec47b31">shutdown</a>(std::string text=&quot;unknown&quot;)</td><td class="entry"><a class="el" href="classcore_1_1Socket.html">core::Socket</a></td><td class="entry"></td></tr>
<tr bgcolor="#f0f0f0"><td class="entry"><b>shutDown</b> (defined in <a class="el" href="classcore_1_1Socket.html">core::Socket</a>)</td><td class="entry"><a class="el" href="classcore_1_1Socket.html">core::Socket</a></td><td class="entry"></td></tr>
<tr bgcolor="#f0f0f0" class="even"><td class="entry"><b>shutDown</b> (defined in <a class="el" href="classcore_1_1Socket.html">core::Socket</a>)</td><td class="entry"><a class="el" href="classcore_1_1Socket.html">core::Socket</a></td><td class="entry"></td></tr>
<tr><td class="entry"><a class="el" href="classcore_1_1Socket.html#af2d1b6de7a64a9d446b0305b6ec47b31">shutdown</a>(std::string text=&quot;unknown&quot;)</td><td class="entry"><a class="el" href="classcore_1_1Socket.html">core::Socket</a></td><td class="entry"></td></tr>
<tr class="even"><td class="entry"><a class="el" href="classcore_1_1Socket.html#a4c3f87fd1de3c9eab4bf5efbb30ce87d">Socket</a>(EPoll &amp;ePoll, std::string text=&quot;&quot;)</td><td class="entry"><a class="el" href="classcore_1_1Socket.html">core::Socket</a></td><td class="entry"></td></tr>
<tr><td class="entry"><a class="el" href="classcore_1_1TCPServer.html#a28302dd844cfc971ee41de2000d24aa0">subscriptions</a></td><td class="entry"><a class="el" href="classcore_1_1TCPServer.html">core::TCPServer</a></td><td class="entry"></td></tr>
<tr class="even"><td class="entry"><a class="el" href="classcore_1_1TCPServer.html#abaecb97c336b757d1029d45277f9fc5b">TCPServer</a>(EPoll &amp;ePoll, IPAddress address, std::string delimiter=&quot; &quot;, int depth=10, std::string text=&quot;&quot;)</td><td class="entry"><a class="el" href="classcore_1_1TCPServer.html">core::TCPServer</a></td><td class="entry"></td></tr>

Some files were not shown because too many files have changed in this diff Show More