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_SIMPLEWEB
#include "client/SimpleWeb.hpp"
#endif
 
namespace kurlyk {

    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 std::weak_ptr<IWebSocketClient>& 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;
        }

        std::shared_ptr<IWebSocketClient> create_client() {
            std::shared_ptr<IWebSocketClient> client;
 
#           ifdef KURLYK_USE_EMSCRIPTEN
            // Client for the Emscripten platform
#           if __cplusplus >= 201402L
            client = std::make_shared<EmscriptenWebSocketClientAdapter>();
#           else
            client = std::shared_ptr<EmscriptenWebSocketClientAdapter>(new EmscriptenWebSocketClientAdapter());
#           endif
#           endif
 
#           ifdef KURLYK_USE_SIMPLEWEB
            // Client for other platforms
#           if __cplusplus >= 201402L
            client = std::make_shared<SimpleWebSocketClientAdapter>();
#           else
            client = std::shared_ptr<SimpleWebSocketClientAdapter>(new SimpleWebSocketClientAdapter());
#           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<std::weak_ptr<IWebSocketClient>>  m_client_list;       

        WebSocketManager() = default;

        virtual ~WebSocketManager() = default;

        WebSocketManager(const WebSocketManager&) = delete;

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