CorelinkClasses.h

Go to the documentation of this file.

#ifndef CORELINKCLASSES_H
#define CORELINKCLASSES_H
#pragma once

#include "CorelinkConst.h"
#include <stdexcept>

namespace Corelink {
    class CorelinkException;
    class DLLInit;
    class Client;
    class StreamData;
    class SendStream;
    class RecvStream;
    class Callback;
    class RecvData;
}

namespace Corelink {
    class CorelinkException : public std::runtime_error {
        friend class DLLInit;
        friend class Client;
        friend class StreamData;
        friend class SendStream;
        friend class RecvStream;
    private:
        CorelinkException(const std::string& msg, const int& code);

        static void GetDLLException(const unsigned int errorID);
    public:
        ~CorelinkException();
        CorelinkException(const CorelinkException& rhs);
        CorelinkException& operator=(const CorelinkException& rhs) = delete;

        const std::string msg;
        const int code;
    };
}

namespace Corelink {
    class DLLInit {
    private:
        DLLInit() = delete;
        ~DLLInit() = delete;
    public:
        static void Init();

        static int getInitState();

        static void setInitState(int state);

        static std::string getLocalCertPath();

        static void setLocalCertPath(const char* path, int len);

        static void setLocalCertPath(const std::string& path);

        static std::string getServerCertPath();

        static void setServerCertPath(const char* path, int len);

        static void setServerCertPath(const std::string& path);

        static void setServerCredentials(const std::string& username, const std::string& password);

        static void setOnDrop(void(*func)(const STREAM_ID&));

        static void setOnStale(void(*func)(const STREAM_ID&));

        static void setOnSubscribe(void(*func)(const STREAM_ID&, const STREAM_ID&));

        static void setOnUpdate(void(*func)(const STREAM_ID&, const STREAM_ID&));
    };
}

namespace Corelink {
    class Client {
    private:
        Client() = delete;
        ~Client() = delete;

        static bool isActive();

        static std::vector<std::string> getCommResponseDataHelper(char* data);
        
        static std::vector<std::string> getCommResponseData(const int& commID);

        static const char** vecStringToCharArray(const std::vector<std::string>& vec);

        static StreamData getDataStreamInfo(int& commID);
    public:
        static void connect(const std::string& serverIP, int port);

        static void connectPlugin();

        static void cleanup();

        static std::string getToken();

        static std::vector<std::string> listServerFunctions();

        static std::vector<std::string> describeServerFunction(const std::string& func);

        static std::vector<std::string> listWorkspaces();

        static bool addWorkspace(const std::string& workspace);

        static bool rmWorkspace(const std::string& workspace);

        static rapidjson::Document genericComm(const rapidjson::Document& json);

        static rapidjson::Document genericComm(const std::string& json);

        static rapidjson::Document genericComm(const char* json, const int& len = 0);

        static std::vector<int> listStreams(const std::vector<std::string>& workspaces = {}, const std::vector<std::string>& types = {});

        static StreamData streamInfo(const int& streamID);

        static SendStream createSender(const std::string& workspace, const std::string& type, const std::string& meta, bool echo, bool alert, int protocol);

        static RecvStream createReceiver(const std::string& workspace, const std::vector<std::string>& types, const std::string& meta, bool echo, bool alert, int protocol);

        static bool subscribe(const STREAM_ID& receiverID, const STREAM_ID& senderID);

        static bool unsubscribe(const STREAM_ID& receiverID, const STREAM_ID& senderID);

        static bool rmStream(const STREAM_ID& streamID);
    };
}

namespace Corelink {
    class StreamData {
        friend class Client;
        friend class DLLInit;
        friend class Client;
        friend class StreamData;
        friend class SendStream;
        friend class RecvStream;
    private:
        int streamRef;

        typedef void(*RecvFunc)(const STREAM_ID&, const STREAM_ID&, const char*, const int&);

    public:
        // TODO: move the data to private instead of public and implement getters. 
        // Might not be necessary since this is readonly data from the dll.

        int streamID;
        int state;
        int mtu;
        std::string user;
        std::string workspace;
        std::string meta;
        std::vector<std::string> type;
    private:
        StreamData(const int& streamID, const int& state, const int& mtu, const std::string& user, const std::string& workspace, const std::string& meta, int streamRef, const std::vector<std::string>& type);

    public:
        StreamData();
        ~StreamData();
        StreamData(const StreamData& rhs);
        StreamData& operator=(const StreamData& rhs);
        friend std::ostream& operator<<(std::ostream& os, const StreamData& rhs);

        static StreamData parse(const char* data);

        bool isSender() const;

        static bool isSender(const STREAM_ID& streamID);

        bool isReceiver() const;

        static bool isReceiver(const STREAM_ID& streamID);

        static StreamData getStreamData(const STREAM_ID& streamID);

        static SendStream getSenderHandler(const STREAM_ID& streamID);

        static RecvStream getReceiverHandler(const STREAM_ID& streamID);

        static std::vector<STREAM_ID> listClientStreams();

        static std::vector<STREAM_ID> listStreamSources(const STREAM_ID& streamID);

    };
}

// TODO: determine which members should be const
namespace Corelink {
    class SendStream {
        friend class StreamData;
    private:
        STREAM_ID streamID;
        int streamRef;
        int state;
    public:
    private:
        SendStream(const STREAM_ID& streamID = STREAM_DEF, int state = Const::STREAM_STATE_NONE, int streamRef = -1);
    public:
        SendStream(const StreamData& streamData);
        SendStream(const SendStream& rhs);
        SendStream(SendStream&& rhs);
        SendStream& operator=(const SendStream& rhs);

        operator STREAM_ID() const;
    private:
    public:
        bool send(const std::string& msg, const int& federationID = 0);

        bool send(const std::string& msg, const rapidjson::Document& json, bool serverCheck = false, const int& federationID = 0);

        bool send(const char* msg, int msgLen, const int& federationID = 0);

        bool send(const char* msg, int msgLen, const rapidjson::Document& json, bool serverCheck = false, const int& federationID = 0);
    };
}

namespace Corelink {
    class RecvStream {
        friend class StreamData;
    private:
        STREAM_ID streamID;
        int streamRef;
        int state;
    public:
    private:
        RecvStream(const STREAM_ID& streamID = STREAM_DEF, int state = Const::STREAM_STATE_NONE, int streamRef = -1);
    public:
        RecvStream(const StreamData& streamData);
        RecvStream(const RecvStream& rhs);
        RecvStream(RecvStream&& rhs);
        RecvStream& operator=(const RecvStream& rhs);

        operator STREAM_ID() const;
    private:
    public:
        void setOnReceive();

        void setOnReceive(void(*func)(const STREAM_ID&, const STREAM_ID&, const char*, const int&));

        void setOnReceive(void(*func)(void*, const STREAM_ID&, const STREAM_ID&, const char*, const int&), void* obj);

        void setOnReceive(void(*func)(const STREAM_ID&, const STREAM_ID&, const char*, const int&, const rapidjson::Document&));

        void setOnReceive(void(*func)(void*, const STREAM_ID&, const STREAM_ID&, const char*, const int&, const rapidjson::Document&), void* obj);

        std::vector<STREAM_ID> listSources();
    };
}

namespace Corelink {
    class Callback {
    public:
        virtual ~Callback() = default;

        virtual void Func(const RecvData& recvData) = 0;

        static void RecvCallback(STREAM_ID recvID, STREAM_ID sendID, const char* msg, int jsonLen, int msgLen, void* callback);
    };

    class CallbackData : public Callback {
    public:
        void(*func)(const STREAM_ID&, const STREAM_ID&, const char*, const int&);

        CallbackData(void(*func)(const STREAM_ID&, const STREAM_ID&, const char*, const int&));
        
        ~CallbackData();

        void Func(const RecvData& recvData) override;

        static void RecvCallback(STREAM_ID recvID, STREAM_ID sendID, const char* msg, int jsonLen, int msgLen, void* callback);
    };

    class CallbackDataVoid : public Callback {
    public:
        void(*func)(void*, const STREAM_ID&, const STREAM_ID&, const char*, const int&);

        void* obj;

        CallbackDataVoid(void(*func)(void*, const STREAM_ID&, const STREAM_ID&, const char*, const int&), void* obj);
        
        ~CallbackDataVoid();

        void Func(const RecvData& recvData) override;

        static void RecvCallback(STREAM_ID recvID, STREAM_ID sendID, const char* msg, int jsonLen, int msgLen, void* callback);
    };
    
    class CallbackDataJson : public Callback {
    public:
        void(*func)(const STREAM_ID&, const STREAM_ID&, const char*, const int&, const rapidjson::Document&);

        CallbackDataJson(void(*func)(const STREAM_ID&, const STREAM_ID&, const char*, const int&, const rapidjson::Document&));

        ~CallbackDataJson();

        void Func(const RecvData& recvData) override;

        static void RecvCallback(STREAM_ID recvID, STREAM_ID sendID, const char* msg, int jsonLen, int msgLen, void* callback);
    };

    class CallbackDataJsonVoid : public Callback {
    public:
        void(*func)(void*, const STREAM_ID&, const STREAM_ID&, const char*, const int&, const rapidjson::Document&);

        void* obj;

        CallbackDataJsonVoid(void(*func)(void*, const STREAM_ID&, const STREAM_ID&, const char*, const int&, const rapidjson::Document&), void* obj);
        
        ~CallbackDataJsonVoid();

        void Func(const RecvData& recvData) override;

        static void RecvCallback(STREAM_ID recvID, STREAM_ID sendID, const char* msg, int jsonLen, int msgLen, void* callback);
    };
}

namespace Corelink {
    class RecvData {
    public:
        RecvData(STREAM_ID recvID, STREAM_ID sendID, const char* data, int hdrLen, int msgLen);
        RecvData(const RecvData& rhs);
        ~RecvData();
        RecvData& operator=(const RecvData& rhs);

        STREAM_ID recvID;
        STREAM_ID sendID;
        const char* data;
        int hdrLen;
        int msgLen;
    };
}
#endif