ifelse -> switch

include/includes.hpp

@@ -7,5 +7,4 @@
 #include <utils/functions.hpp>
 #include <iostream>
 #include <string>
-#include <memory>
 #endif

libs/gateway/Websocket.hpp

@@ -7,6 +7,14 @@ class EventEmitter {
 private:
     using eventHandlers = std::function<void(const nlohmann::json&)>;
     std::unordered_map<std::string, std::list<eventHandlers>> handlers;
+protected:
+    void emit(const std::string& event, const nlohmann::json& data) {
+        if (handlers.find(event) != handlers.end()) {
+            for (const auto& handler : handlers[event]) {
+                handler(data);
+            }
+        }
+    }
 public:
     void on(const std::string& event, eventHandlers handler) {
         handlers[event].emplace_back(handler);
@@ -18,13 +26,6 @@ public:
         };
         handlers[event].emplace_back(wrappedHandler);
     }
-    void emit(const std::string& event, const nlohmann::json& data) {
-        if (handlers.find(event) != handlers.end()) {
-            for (const auto& handler : handlers[event]) {
-                handler(data);
-            }
-        }
-    }
     void off(const std::string& event, eventHandlers handler) {
         if (handlers.find(event) != handlers.end()) {
             auto& vec = handlers[event];
@@ -60,7 +61,7 @@ private:
             {"presence", {
                 {"activities", nlohmann::json::array({
                     {
-                        {"name", "asdsadsadsadsa"},
+                        {"name", "meow"},
                         {"type", 2}
                     }
                 })},
@@ -72,48 +73,52 @@ private:
         };
         ix::initNetSystem();
         webSocket.setUrl("wss://gateway.discord.gg/?v=10&encoding=json");
-        webSocket.disableAutomaticReconnection();
+        //webSocket.disableAutomaticReconnection();
         Log::create(INFO, WEBSOCKET, "ixwebsocket init");
         webSocket.setOnMessageCallback([this, res = nlohmann::json(), heartbeat_interval = 0, connected = false, id](const ix::WebSocketMessagePtr& msg) mutable {
-            if (msg->type == ix::WebSocketMessageType::Message) {
+            switch (msg->type) {
-                res = nlohmann::json::parse(msg->str);
+                case ix::WebSocketMessageType::Message:
-                Log::create(INFO, WEBSOCKET, res["op"].dump() + " " + res["t"].dump());
+                    res = nlohmann::json::parse(msg->str);
-                switch (res["op"].get<int>()) {
+                    Log::create(INFO, WEBSOCKET, res["op"].dump() + " " + res["t"].dump());
-                    case 10:
+                    switch (res["op"].get<int>()) {
-                        heartbeat_interval = res["d"]["heartbeat_interval"].get<int>();
+                        case 10:
-                        !connected ? connected = true, webSocket.send(id.dump()) : 0;
+                            heartbeat_interval = res["d"]["heartbeat_interval"].get<int>();
-                        std::thread([this, &heartbeat_interval, &connected]() {
+                            !connected ? connected = true, webSocket.send(id.dump()) : 0;
-                            while (connected && heartbeat_interval != -1) {
+                            std::thread([this, &heartbeat_interval, &connected]() {
-                                Log::create(INFO, WEBSOCKET, "Heartbeat " + std::to_string(heartbeat_interval));
+                                while (connected && heartbeat_interval != -1) {
-                                std::this_thread::sleep_for(std::chrono::milliseconds(heartbeat_interval));
+                                    Log::create(INFO, WEBSOCKET, "Heartbeat " + std::to_string(heartbeat_interval));
-                                webSocket.send(payload.dump());
+                                    std::this_thread::sleep_for(std::chrono::milliseconds(heartbeat_interval));
-                            }
+                                    webSocket.send(payload.dump());
-                        }).detach();
+                                }
-                        break;
+                            }).detach();
-                    case 0: emit(res["t"].get<std::string>(), res); break;
+                            break;
-                }
+                        case 0: emit(res["t"].get<std::string>(), res); break;
-            } else if (msg->type == ix::WebSocketMessageType::Error) {
+                    }
-                std::cout << msg->errorInfo.reason << std::endl;
+                    break;
-                exit(-1);
+                case ix::WebSocketMessageType::Error:
+                    std::cout << msg->errorInfo.reason << std::endl;
+                    exit(-1);
+                    break;
+                default:
+                    break;
             }
         });
         webSocket.start();
     }
 public:
-    /*
+    [[maybe_unused]]
-    void sendPresenceUpdate(int statusType, const std::string& activityName) {
+    void sendPresenceUpdate(const int& statusType, const std::string& activityName) {
-        json prsUpdate = {
+        nlohmann::json prsUpdate = {
             {"op", 3},
             {"d", {
                 {"since", 0},
-                {"activities", json::array({{"name", activityName}, {"type", 2}})},
+                {"activities", nlohmann::json::array({{"name", activityName}, {"type", 2}})},
                 {"status", statusType == 1 ? "online" : "idle"},
                 {"afk", false}
             }}
         };
         webSocket.send(prsUpdate.dump());
     }
-    */
     static WebSocket& getInstance(const std::string& token = "", const int& intents = 0, const bool& bot = true) {
         Log::create(INFO, WEBSOCKET, "Instance event");
         static WebSocket instance(token, intents, bot);

libs/network/Network.hpp

@@ -10,12 +10,13 @@ private:
     WebSocket& web;
     std::chrono::duration<double, std::milli> duration;
     NetworkManager& operator=(const NetworkManager&) = delete;
+    NetworkManager& operator=(NetworkManager&&) = delete;
+    NetworkManager(NetworkManager&&) = delete;
     NetworkManager(const NetworkManager&) = delete;
     NetworkManager() : web(WebSocket::getInstance()) {
         Log::create(INFO, NETWORK, "Network init");
         curl_global_init(CURL_GLOBAL_DEFAULT);
-        curl = curl_easy_init();
+        if (!(curl = curl_easy_init())) {
-        if (!curl) {
             Log::create(CRITICAL, NETWORK, "Failed to initialize CURL");
             abort();
         }