DCS_ModuleNetwork.h

Go to the documentation of this file.

#ifndef _DCS_NETWORK_H
#define _DCS_NETWORK_H

#pragma once
#include "../../config/exports.h"
#include "../../DCS_Utils/include/DCS_ModuleUtils.h"
#include "../../config/registry.h"

#include <unordered_map>

namespace DCS
{
    namespace Network
    {
        typedef DCS::GenericHandle Socket;

        DCS_API void Init();

        DCS_API bool GetStatus();

        DCS_API void Destroy();

        namespace Server
        {
            enum class StopMode
            {
                IMMEDIATE, 
                WAIT       
            };

            DCS_API Socket Create(i32 port);

            DCS_API void WaitForConnections(Socket server);

            DCS_API void StopListening(Socket server);

            DCS_API bool StartThread(Socket client);

            DCS_API void StopThread(Socket client, StopMode mode = StopMode::IMMEDIATE);

            DCS_API Socket GetConnectedClient();

            DCS_API Socket GetListenSocket();

            DCS_API bool IsRunning();

        }

        namespace Client
        {
            DCS_API Socket Connect(DCS::Utils::String host, i32 port);

            DCS_API void Authenticate(Socket socket, DCS::Utils::String username, DCS::Utils::String password);

            DCS_API bool StartThread(Socket connection);

            DCS_API void StopThread(Socket connection);

            DCS_API i16 GetMillisLatency();

        }

        namespace Message
        {
            enum class Operation
            {
                NO_OP = 0,     
                REQUEST = 1,   
                               // 2 and 3 reserved
                RESPONSE = 4,  
                               // 5 and 6 reserved
                EVT_SUB = 7,   
                               // 8 reserved
                EVT_UNSUB = 9, 
                OP_ERROR,      
                CON_VALID,     
                DATA           
            };

            DCS_API DCS::Utils::AsyncItem<DCS::Registry::SVReturn> SendAsync(Operation op, u8 *data, i32 size);

            DCS_API Registry::SVReturn SendSync(Operation op, u8 *data, i32 size);

            DCS_REGISTER_EVENT
            DCS_API void FibSeqEvt();
        }
    }

    namespace CLI
    {
        class Command
        {
        public:
            using MapType = std::map<std::string, Command>;
            using RunCB = std::function<void(bool*)>;

            Command(const char *DCL, const char *help = "", RunCB cb = nullptr)
            {
                cmd_name = DCL;
                help_string = help;
                to_run = cb;

                if (!IsCommand(cmd_name))
                    cmd_reg.emplace(cmd_name, *this);
                else
                    LOG_WARNING("Attempted to create command %s. But it was already registered. Ignoring...", DCL);
            }

            static Command *Get(std::string name)
            {
                MapType::iterator it = cmd_reg.find(name);

                if (it != cmd_reg.end())
                    return &it->second;
                return nullptr;
            }

            static bool IsCommand(std::string name)
            {
                MapType::iterator it = cmd_reg.find(name);
                return it != cmd_reg.end();
            }

            static Command *Closest(std::string name);

            static std::vector<std::string> ListCommands()
            {
                std::vector<std::string> cmds;
                for (auto &p : cmd_reg)
                {
                    cmds.push_back(p.second.cmd_name + " - " + p.second.help_string);
                }
                return cmds;
            }

            inline const std::string getName() const
            {
                return cmd_name;
            }

            inline void Run(bool* brk)
            {
                if (to_run != nullptr)
                {
                    to_run(brk);
                }

                // Silently ignore
            }

        private:
            inline static MapType cmd_reg;

        private:
            std::string cmd_name;
            std::string help_string;

            RunCB to_run;
        };

        DCS_API void Spin();
    }
}

#endif _DCS_NETWORK_H