WSTP/Utilities.h

Go to the documentation of this file.

 
#ifndef LLU_WSTP_UTILITIES_H_
#define LLU_WSTP_UTILITIES_H_
 
#include <cstring>
#include <string>
 
#include "wstp.h"
 
#include "LLU/ErrorLog/Errors.h"
#include "LLU/WSTP/EncodingTraits.hpp"
 
namespace LLU {
 
    template<WS::Encoding, WS::Encoding>
    class WSStream;
 
    namespace WS {
 
        struct Symbol {
            Symbol() = default;
 
            explicit Symbol(std::string h) : head(std::move(h)) {};
 
            const std::string& getHead() const;
 
            void setHead(std::string h);
 
        private:
            std::string head;
        };
 
        struct Function : Symbol {
 
            Function() : Function("", -1) {};
 
            explicit Function(const std::string& h) : Function(h, -1) {}
 
            Function(const std::string& h, int argCount) : Symbol(h), argc(argCount) {}
 
            int getArgc() const;
 
            void setArgc(int newArgc);
 
        private:
            int argc;
        };
 
        struct Association : Function {
            Association() : Function("Association") {}
 
            explicit Association(int argCount) : Function("Association", argCount) {}
        };
 
        struct List : Function {
            List() : Function("List") {}
 
            explicit List(int argCount) : Function("List", argCount) {}
        };
 
        struct Missing : Function {
            Missing() : Function("Missing") {}
 
            explicit Missing(std::string r) : Function("Missing", 1), reason(std::move(r)) {}
 
            const std::string& why() const {
                return reason;
            }
 
        private:
            std::string reason;
        };
 
        namespace Detail {
            void checkError(WSLINK m, int statusOk, const std::string& errorName, const std::string& debugInfo = "");
 
            [[noreturn]] void throwLLUException(const std::string& errorName, const std::string& debugInfo = "");
 
            WSLINK getNewLoopback(WSLINK m);
 
            int countExpressionsInLoopbackLink(WSLINK& lpbckLink);
        }    // namespace Detail
 
        enum class Direction : bool { Get, Put };
 
        template<WS::Encoding EIn, WS::Encoding EOut>
        WSStream<EIn, EOut>& NewPacket(WSStream<EIn, EOut>& ms) {
            Detail::checkError(ms.get(), WSNewPacket(ms.get()), ErrorName::WSPacketHandleError, "Error in WSNewPacket");
            return ms;
        }
 
        template<WS::Encoding EIn, WS::Encoding EOut>
        WSStream<EIn, EOut>& EndPacket(WSStream<EIn, EOut>& ms) {
            Detail::checkError(ms.get(), WSEndPacket(ms.get()), ErrorName::WSPacketHandleError, "Error in WSEndPacket");
            return ms;
        }
 
        template<WS::Encoding EIn, WS::Encoding EOut>
        WSStream<EIn, EOut>& Flush(WSStream<EIn, EOut>& ms) {
            Detail::checkError(ms.get(), WSFlush(ms.get()), ErrorName::WSFlowControlError, "Error in WSFlush");
            return ms;
        }
 
        template<WS::Encoding EIn, WS::Encoding EOut>
        WSStream<EIn, EOut>& Rule(WSStream<EIn, EOut>& ms, Direction dir) {
            if (dir == Direction::Put) {
                return ms << Function("Rule", 2);
            }
            return ms >> Function("Rule", 2);
        }
 
        template<WS::Encoding EIn, WS::Encoding EOut>
        WSStream<EIn, EOut>& Null(WSStream<EIn, EOut>& ms, Direction dir) {
            if (dir == Direction::Put) {
                return ms << Symbol("Null");
            }
            return ms >> Symbol("Null");
        }
 
        struct BeginExpr : Symbol {
            explicit BeginExpr(const std::string& head) : Symbol(head) {}
        };
 
        struct DropExpr {};
 
        struct EndExpr {};
 
    }    // namespace WS
}    // namespace LLU
 
#endif /* LLU_WSTP_UTILITIES_H_ */