WebSocketManager.hpp

Go to the documentation of this file.

#pragma once
#ifndef _KURLYK_WEBSOCKET_MANAGER_HPP_INCLUDED
#define _KURLYK_WEBSOCKET_MANAGER_HPP_INCLUDED

 
#include "client/BaseWebSocketClient.hpp"
 
#ifdef KURLYK_USE_EMSCRIPTEN
#include "client/Emscripten/EmscriptenWebSocketClientAdapter.hpp"
#endif
 
#ifdef KURLYK_USE_SIMPLEWEB
#include "client/SimpleWeb.hpp"
#endif
 
namespace kurlyk {
 
#ifdef KURLYK_USE_EMSCRIPTEN
    using selected_backend_client_t = EmscriptenWebSocketClientAdapter;
#elif defined(KURLYK_USE_SIMPLEWEB)
    using selected_backend_client_t = SimpleWebSocketClientAdapter;
#endif

    using selected_backend_client_ptr = std::shared_ptr<selected_backend_client_t>;
    using selected_backend_client_weak_ptr = std::weak_ptr<selected_backend_client_t>;

    class WebSocketManager final : public core::INetworkTaskManager {
    public:

        static WebSocketManager& get_instance() {
            static WebSocketManager* instance = new WebSocketManager();
            return *instance;
        }

        void process() override {
            std::lock_guard<std::mutex> lock(m_client_list_mutex);
            for (auto &&client_weak_ptr : m_client_list) {
                if (auto client_ptr = client_weak_ptr.lock()) {
                    client_ptr->process();
                }
            }
            // Remove expired clients from the list
            m_client_list.remove_if([](const selected_backend_client_weak_ptr& client_weak_ptr) {
                return client_weak_ptr.expired();
            });
        }

        void shutdown() override {
            std::lock_guard<std::mutex> lock(m_client_list_mutex);
            for (auto &&client_weak_ptr : m_client_list) {
                if (auto client_ptr = client_weak_ptr.lock()) {
                    client_ptr->shutdown();
                }
            }
        }

        const bool is_loaded() const override {
            std::lock_guard<std::mutex> lock(m_client_list_mutex);
            for (auto &&client_weak_ptr : m_client_list) {
                if (auto client_ptr = client_weak_ptr.lock()) {
                    if (client_ptr->is_running()) return true;
                }
            }
            return false;
        }

        selected_backend_client_ptr create_client() {
            selected_backend_client_ptr client;
 
#           ifdef KURLYK_USE_EMSCRIPTEN
            // Client for the Emscripten platform
#           if __cplusplus >= 201402L
            client = std::make_shared<selected_backend_client_t>();
#           else
            client = selected_backend_client_ptr(new selected_backend_client_t());
#           endif
#           endif
 
#           ifdef KURLYK_USE_SIMPLEWEB
            // Client for other platforms
#           if __cplusplus >= 201402L
            client = std::make_shared<selected_backend_client_t>();
#           else
            client = selected_backend_client_ptr(new selected_backend_client_t());
#           endif
#           endif
 
            std::lock_guard<std::mutex> lock(m_client_list_mutex);
            m_client_list.push_back(client);
            return client;
        }
 
    private:
        mutable std::mutex                          m_client_list_mutex; 
        std::list<selected_backend_client_weak_ptr> m_client_list;       

        WebSocketManager() = default;

        virtual ~WebSocketManager() = default;

        WebSocketManager(const WebSocketManager&) = delete;

        WebSocketManager& operator=(const WebSocketManager&) = delete;
 
    }; // WebSocketManager
 
}
 
#endif // _KURLYK_WEBSOCKET_MANAGER_HPP_INCLUDED