Gui.h

#pragma once
 
#include <vector>
#include <string>
#include <functional>
#include <JSON.h>
#include <typeinfo> // for types in templates
#include <memory>
#include <DataBuffer.h>
 
// forward declarations
class WSServer;
 
class Gui
{
        private:
 
                std::vector<DataBuffer> _buffers;
                std::unique_ptr<WSServer> ws_server;
 
                bool wsIsConnected = false;
 
                void ws_connect();
                void ws_disconnect();
                void ws_onControlData(const char* data, unsigned int size);
                void ws_onData(const char* data, unsigned int size);
                int doSendBuffer(const char* type, unsigned int bufferId, const void* data, size_t size);
 
                unsigned int _port;
                std::string _addressControl;
                std::string _addressData;
                std::wstring _projectName;
 
                // User defined functions
                std::function<bool(JSONObject&, void*)> customOnControlData;
                std::function<bool(const char*, unsigned int, void*)> customOnData;
 
                void* controlCallbackArg = nullptr;
                void* binaryCallbackArg = nullptr;
 
        public:
                Gui();
                Gui(unsigned int port, std::string address);
                ~Gui();
 
                int setup(unsigned int port = 5555, std::string address = "gui");
                int setup(std::string projectName, unsigned int port = 5555, std::string address = "gui");
                void cleanup();
 
                bool isConnected(){ return wsIsConnected; };
 
                // BUFFERS
                unsigned int setBuffer(char bufferType, unsigned int size);
                DataBuffer& getDataBuffer(unsigned int bufferId);

                void setControlDataCallback(std::function<bool(JSONObject&, void*)> callback, void* callbackArg=nullptr){
                        customOnControlData = callback;
                        controlCallbackArg = callbackArg;
                };

                void setBinaryDataCallback(std::function<bool(const char*, unsigned int, void*)> callback, void* callbackArg=nullptr){
                        customOnData = callback;
                        binaryCallbackArg = callbackArg;
                };

                int sendControl(JSONValue* root);

                template<typename T, typename A>
                int sendBuffer(unsigned int bufferId, std::vector<T,A> & buffer);
                template <typename T, size_t N>
                int sendBuffer(unsigned int bufferId, T (&buffer)[N]);
                template <typename T>
                int sendBuffer(unsigned int bufferId, T* ptr, size_t count);
                template <typename T>
                int sendBuffer(unsigned int bufferId, T value);
};
 
template<typename T, typename A>
int Gui::sendBuffer(unsigned int bufferId, std::vector<T,A> & buffer)
{
        const char* type = typeid(T).name();
        return doSendBuffer(type, bufferId, (const void*)buffer.data(), (buffer.size()*sizeof(T)));
}
 
template <typename T, size_t N>
int Gui::sendBuffer(unsigned int bufferId, T (&buffer)[N])
{
        const char* type = typeid(T).name();
        return doSendBuffer(type, bufferId, (const void*)buffer, N*sizeof(T));
}
 
template <typename T>
int Gui::sendBuffer(unsigned int bufferId, T* ptr, size_t count){
        const char* type = typeid(T).name();
        return doSendBuffer(type, bufferId, ptr, count * sizeof(T));
}
 
template <typename T>
int Gui::sendBuffer(unsigned int bufferId, T value)
{
        const char* type = typeid(T).name();
        return doSendBuffer(type, bufferId, (const void*)&value, sizeof(T));
}