WSStream.hpp

Go to the documentation of this file.

 
#ifndef LLU_WSTP_WSSTREAM_HPP_
#define LLU_WSTP_WSSTREAM_HPP_
 
#include <algorithm>
#include <iterator>
#include <map>
#include <stack>
#include <type_traits>
#include <utility>
#include <vector>
 
#include "wstp.h"
 
#include "LLU/ErrorLog/Errors.h"
#include "LLU/Utilities.hpp"
 
#include "LLU/WSTP/Get.h"
#include "LLU/WSTP/Put.h"
#include "LLU/WSTP/Strings.h"
#include "LLU/WSTP/Utilities.h"
#include "LLU/WSTP/UtilityTypeTraits.hpp"
 
namespace LLU {
 
    template<WS::Encoding EncodingIn, WS::Encoding EncodingOut = EncodingIn>
    class WSStream {
    public:
        explicit WSStream(WSLINK mlp);
 
        WSStream(WSLINK mlp, int argc);
 
        WSStream(WSLINK mlp, const std::string& head, int argc);
 
        ~WSStream() = default;
 
        WSLINK& get() noexcept {
            return m;
        }
 
        template<typename Iterator, typename = enable_if_input_iterator<Iterator>>
        void sendRange(Iterator begin, Iterator end);
 
        template<typename Iterator, typename = enable_if_input_iterator<Iterator>>
        void sendRange(Iterator begin, Iterator end, const std::string& head);
 
    public:
        using StreamToken = WSStream& (*)(WSStream&);
 
        using BidirStreamToken = WSStream& (*)(WSStream&, WS::Direction);
 
        using LoopbackData = std::pair<std::string, WSLINK>;
 
        //
        //  operator<<
        //
 
        WSStream& operator<<(StreamToken f);
 
        WSStream& operator<<(BidirStreamToken f);
 
        WSStream& operator<<(const WS::Symbol& s);
 
        WSStream& operator<<(const WS::Function& f);
 
        WSStream& operator<<(const WS::Missing& f);
 
        WSStream& operator<<(const WS::BeginExpr& expr);
 
        WSStream& operator<<(const WS::DropExpr& expr);
 
        WSStream& operator<<(const WS::EndExpr& expr);
 
        WSStream& operator<<(bool b);
 
        WSStream& operator<<(mint i);
 
        template<typename T>
        WSStream& operator<<(const WS::ArrayData<T>& a);
 
        template<typename T>
        WSStream& operator<<(const WS::ListData<T>& l);
 
        template<typename T, typename D>
        WSStream& operator<<(const std::unique_ptr<T, D>& p);
 
        template<typename T>
        WSStream& operator<<(const std::vector<T>& l);
 
        template<WS::Encoding E>
        WSStream& operator<<(const WS::StringData<E>& s);
 
        template<WS::Encoding E, typename T>
        WSStream& operator<<(const WS::PutAs<E, T>& wrp);
 
        template<typename T>
        WSStream& operator<<(const std::basic_string<T>& s);
 
        template<typename T, std::size_t N, typename = std::enable_if_t<WS::StringTypeQ<T>>>
        WSStream& operator<<(const T (&s)[N]);
 
        WSStream& operator<<(const char* s);
 
        template<typename K, typename V>
        WSStream& operator<<(const std::map<K, V>& map);
 
        template<typename T, typename = std::enable_if_t<std::is_arithmetic_v<T>>>
        WSStream& operator<<(T value);
 
        template<typename Container, typename = std::void_t<
                                         decltype(std::declval<Container>().begin(), std::declval<Container>().end(), std::declval<Container>().size())>>
        WSStream& operator<<(const Container& c) {
            sendRange(c.begin(), c.end());
            return *this;
        }
 
        //
        //  operator>>
        //
 
        WSStream& operator>>(BidirStreamToken f);
 
        WSStream& operator>>(const WS::Symbol& s);
 
        WSStream& operator>>(WS::Symbol& s);
 
        WSStream& operator>>(const WS::Function& f);
 
        WSStream& operator>>(WS::Function& f);
 
        WSStream& operator>>(bool& b);
 
        WSStream& operator>>(mint& i);
 
        template<typename T>
        WSStream& operator>>(WS::ArrayData<T>& a);
 
        template<typename T>
        WSStream& operator>>(WS::ListData<T>& l);
 
        template<typename T>
        WSStream& operator>>(std::vector<T>& l);
 
        template<WS::Encoding E = EncodingIn>
        WSStream& operator>>(WS::StringData<E>& s);
 
        template<typename T>
        WSStream& operator>>(std::basic_string<T>& s);
 
        template<WS::Encoding E, typename T>
        WSStream& operator>>(WS::GetAs<E, T> wrp);
 
        template<typename K, typename V>
        WSStream& operator>>(std::map<K, V>& map);
 
        template<typename T, typename = std::enable_if_t<std::is_arithmetic_v<T>>>
        WSStream& operator>>(T& value);
 
    private:
        void check(int statusOk, const std::string& errorName, const std::string& debugInfo = "");
 
        int testHead(const std::string& head);
 
        void testHead(const std::string& head, int argc);
 
        void refreshCurrentWSLINK();
 
    private:
        WSLINK m {};
 
        std::stack<LoopbackData> loopbackStack;
 
        bool currentExprDropped = false;
    };
 
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    WSStream<EIn, EOut>::WSStream(WSLINK mlp) : m(mlp), loopbackStack(std::deque<LoopbackData> {{"", mlp}}) {
        if (!mlp) {
            WS::Detail::throwLLUException(ErrorName::WSNullWSLinkError);
        }
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    WSStream<EIn, EOut>::WSStream(WSLINK mlp, int argc) : WSStream(mlp, "List", argc) {}
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    WSStream<EIn, EOut>::WSStream(WSLINK mlp, const std::string& head, int argc) : WSStream(mlp) {
        testHead(head, argc);
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<typename Iterator, typename>
    void WSStream<EIn, EOut>::sendRange(Iterator begin, Iterator end) {
        sendRange(begin, end, "List");
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<typename Iterator, typename>
    void WSStream<EIn, EOut>::sendRange(Iterator begin, Iterator end, const std::string& head) {
        *this << WS::Function(head, static_cast<int>(std::distance(begin, end)));
        std::for_each(begin, end, [this](const auto& elem) { *this << elem; });
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    void WSStream<EIn, EOut>::check(int statusOk, const std::string& errorName, const std::string& debugInfo) {
        WS::Detail::checkError(m, statusOk, errorName, debugInfo);
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    int WSStream<EIn, EOut>::testHead(const std::string& head) {
        int argcount {};
        check(WSTestHead(m, head.c_str(), &argcount), ErrorName::WSTestHeadError, "Expected \"" + head + "\"");
        return argcount;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    void WSStream<EIn, EOut>::testHead(const std::string& head, int argc) {
        int argcount = testHead(head);
        if (argc != argcount) {
            WS::Detail::throwLLUException(ErrorName::WSTestHeadError, "Expected " + std::to_string(argc) + " arguments but got " + std::to_string(argcount));
        }
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    void WSStream<EIn, EOut>::refreshCurrentWSLINK() {
        if (loopbackStack.empty()) {
            WS::Detail::throwLLUException(ErrorName::WSLoopbackStackSizeError, "Stack is empty in refreshCurrentWSLINK()");
        }
        m = std::get<WSLINK>(loopbackStack.top());
    }
 
    //
    //  Definitions of WSStream<EIn, EOut>::operator<<
    //
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    auto WSStream<EIn, EOut>::operator<<(StreamToken f) -> WSStream& {
        return f(*this);
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    auto WSStream<EIn, EOut>::operator<<(BidirStreamToken f) -> WSStream& {
        return f(*this, WS::Direction::Put);
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    auto WSStream<EIn, EOut>::operator<<(const WS::Symbol& s) -> WSStream& {
        check(WSPutSymbol(m, s.getHead().c_str()), ErrorName::WSPutSymbolError, "Cannot put symbol: \"" + s.getHead() + "\"");
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    auto WSStream<EIn, EOut>::operator<<(const WS::Function& f) -> WSStream& {
        check(WSPutFunction(m, f.getHead().c_str(), f.getArgc()), ErrorName::WSPutFunctionError,
              "Cannot put function: \"" + f.getHead() + "\" with " + std::to_string(f.getArgc()) + " arguments");
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    auto WSStream<EIn, EOut>::operator<<(const WS::Missing& f) -> WSStream& {
        check(WSPutFunction(m, f.getHead().c_str(), 1),    // f.getArgc() could be 0 but we still want to send f.reason, even if it's an empty string
              ErrorName::WSPutFunctionError, "Cannot put function: \"" + f.getHead() + "\" with 1 argument");
        *this << f.why();
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    auto WSStream<EIn, EOut>::operator<<(const WS::BeginExpr& expr) -> WSStream& {
 
        // reset dropped expression flag
        currentExprDropped = false;
 
        // create a new LoopbackLink for the expression
        auto* loopback = WS::Detail::getNewLoopback(m);
 
        // store expression head together with the link on the stack
        loopbackStack.emplace(expr.getHead(), loopback);
 
        // active WSLINK changes
        refreshCurrentWSLINK();
 
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    auto WSStream<EIn, EOut>::operator<<(const WS::DropExpr& /*tag*/) -> WSStream& {
        // check if the stack has reasonable size
        if (loopbackStack.size() < 2) {
            WS::Detail::throwLLUException(ErrorName::WSLoopbackStackSizeError,
                                  "Trying to Drop expression with loopback stack size " + std::to_string(loopbackStack.size()));
        }
        // we are dropping the expression so just close the link and hope that WSTP will do the cleanup
        WSClose(std::get<WSLINK>(loopbackStack.top()));
        loopbackStack.pop();
        refreshCurrentWSLINK();
 
        // set the dropped expression flag
        currentExprDropped = true;
 
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    auto WSStream<EIn, EOut>::operator<<(const WS::EndExpr& /*tag*/) -> WSStream& {
 
        // if the expression has been dropped at some point, then just reset the flag and do nothing as the loopback link no longer exists
        if (currentExprDropped) {
            currentExprDropped = false;
            return *this;
        }
 
        // check if the stack has reasonable size
        if (loopbackStack.size() < 2) {
            WS::Detail::throwLLUException(ErrorName::WSLoopbackStackSizeError,
                                  "Trying to End expression with loopback stack size " + std::to_string(loopbackStack.size()));
        }
 
        // extract active loopback link and expression head
        auto currentPartialExpr = loopbackStack.top();
        loopbackStack.pop();
 
        // active WSLINK changes
        refreshCurrentWSLINK();
 
        // now count the expressions accumulated in the loopback link and send them to the parent link after the head
        auto& exprArgs = std::get<WSLINK>(currentPartialExpr);
        auto argCnt = WS::Detail::countExpressionsInLoopbackLink(exprArgs);
        *this << WS::Function(std::get<std::string>(currentPartialExpr), argCnt);
        check(WSTransferToEndOfLoopbackLink(m, exprArgs), ErrorName::WSTransferToLoopbackError,
              "Could not transfer " + std::to_string(argCnt) + " expressions from Loopback Link");
        // finally, close the loopback link
        WSClose(exprArgs);
 
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    auto WSStream<EIn, EOut>::operator<<(bool b) -> WSStream& {
        return *this << WS::Symbol(b ? "True" : "False");
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    auto WSStream<EIn, EOut>::operator<<(mint i) -> WSStream& {
        WS::PutScalar<wsint64>::put(m, static_cast<wsint64>(i));
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<typename T>
    auto WSStream<EIn, EOut>::operator<<(const WS::ArrayData<T>& a) -> WSStream& {
        const auto& del = a.get_deleter();
        WS::PutArray<T>::put(m, a.get(), del.getDims(), del.getHeads(), del.getRank());
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<typename T>
    auto WSStream<EIn, EOut>::operator<<(const WS::ListData<T>& l) -> WSStream& {
        const auto& del = l.get_deleter();
        WS::PutList<T>::put(m, l.get(), del.getLength());
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<typename T, typename D>
    auto WSStream<EIn, EOut>::operator<<(const std::unique_ptr<T, D>& p) -> WSStream& {
        if (p) {
            *this << *p;
        } else {
            *this << WS::Null;
        }
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<typename T>
    auto WSStream<EIn, EOut>::operator<<(const std::vector<T>& l) -> WSStream& {
        if constexpr (WS::ScalarSupportedTypeQ<T>) {
            WS::PutList<T>::put(m, l.data(), static_cast<int>(l.size()));
        } else {
            *this << WS::List(static_cast<int>(l.size()));
            for (const auto& elem : l) {
                *this << elem;
            }
        }
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<WS::Encoding E>
    auto WSStream<EIn, EOut>::operator<<(const WS::StringData<E>& s) -> WSStream& {
        WS::String<E>::put(m, s.get(), s.get_deleter().getLength());
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<typename T>
    auto WSStream<EIn, EOut>::operator<<(const std::basic_string<T>& s) -> WSStream& {
        if constexpr (WS::StringTypeQ<T>) {
            WS::String<EOut>::put(m, s.c_str(), static_cast<int>(s.size()));
        } else {
            static_assert(dependent_false_v<T>, "Calling operator<< with unsupported character type.");
        }
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<typename T, std::size_t N, typename>
    auto WSStream<EIn, EOut>::operator<<(const T (&s)[N]) -> WSStream& {
        WS::String<EOut>::put(m, s, N);
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<WS::Encoding E, typename T>
    auto WSStream<EIn, EOut>::operator<<(const WS::PutAs<E, T>& wrp) -> WSStream& {
        WSStream<EIn, E> tmpWSS {m};
        tmpWSS << wrp.obj;
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    auto WSStream<EIn, EOut>::operator<<(const char* s) -> WSStream& {
        WS::String<EOut>::put(m, s, static_cast<int>(std::strlen(s)));
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<typename T, typename>
    auto WSStream<EIn, EOut>::operator<<(T value) -> WSStream& {
        if constexpr (WS::ScalarSupportedTypeQ<T>) {
            WS::PutScalar<T>::put(m, value);
        } else {
            static_assert(dependent_false_v<T>, "Calling operator<< with unsupported scalar type.");
        }
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<typename K, typename V>
    auto WSStream<EIn, EOut>::operator<<(const std::map<K, V>& map) -> WSStream& {
        *this << WS::Association(static_cast<int>(map.size()));
        for (const auto& elem : map) {
            *this << WS::Rule << elem.first << elem.second;
        }
        return *this;
    }
 
    //
    //  Definitions of WSStream<EIn, EOut>::operator>>
    //
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    auto WSStream<EIn, EOut>::operator>>(BidirStreamToken f) -> WSStream& {
        return f(*this, WS::Direction::Get);
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    auto WSStream<EIn, EOut>::operator>>(const WS::Symbol& s) -> WSStream& {
        check(WSTestSymbol(m, s.getHead().c_str()), ErrorName::WSTestSymbolError, "Cannot get symbol: \"" + s.getHead() + "\"");
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    auto WSStream<EIn, EOut>::operator>>(WS::Symbol& s) -> WSStream& {
        if (!s.getHead().empty()) {
            check(WSTestSymbol(m, s.getHead().c_str()), ErrorName::WSTestSymbolError, "Cannot get symbol: \"" + s.getHead() + "\"");
        } else {
            const char* head {};
            check(WSGetSymbol(m, &head), ErrorName::WSGetSymbolError, "Cannot get symbol");
            s.setHead(head);
            WSReleaseSymbol(m, head);
        }
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    auto WSStream<EIn, EOut>::operator>>(const WS::Function& f) -> WSStream& {
        testHead(f.getHead(), f.getArgc());
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    auto WSStream<EIn, EOut>::operator>>(WS::Function& f) -> WSStream& {
        if (!f.getHead().empty()) {
            if (f.getArgc() < 0) {
                f.setArgc(testHead(f.getHead()));
            } else {
                testHead(f.getHead(), f.getArgc());
            }
        } else {
            const char* head {};
            int argc {};
            check(WSGetFunction(m, &head, &argc), ErrorName::WSGetFunctionError, "Cannot get function");
            f.setHead(head);
            WSReleaseSymbol(m, head);
            f.setArgc(argc);
        }
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    auto WSStream<EIn, EOut>::operator>>(bool& b) -> WSStream& {
        WS::Symbol boolean;
        *this >> boolean;
        if (boolean.getHead() == "True") {
            b = true;
        } else if (boolean.getHead() == "False") {
            b = false;
        } else {
            WS::Detail::throwLLUException(ErrorName::WSWrongSymbolForBool, R"(Expected "True" or "False", got )" + boolean.getHead());
        }
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    auto WSStream<EIn, EOut>::operator>>(mint& i) -> WSStream& {
        i = static_cast<mint>(WS::GetScalar<wsint64>::get(m));
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<WS::Encoding E, typename T>
    auto WSStream<EIn, EOut>::operator>>(WS::GetAs<E, T> wrp) -> WSStream& {
        WSStream<E, EOut> tmpWSS {m};
        tmpWSS >> wrp.obj;
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<typename T>
    auto WSStream<EIn, EOut>::operator>>(WS::ArrayData<T>& a) -> WSStream& {
        a = WS::GetArray<T>::get(m);
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<typename T>
    auto WSStream<EIn, EOut>::operator>>(WS::ListData<T>& l) -> WSStream& {
        l = WS::GetList<T>::get(m);
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<typename T>
    auto WSStream<EIn, EOut>::operator>>(std::vector<T>& l) -> WSStream& {
        if constexpr (WS::ScalarSupportedTypeQ<T>) {
            auto list = WS::GetList<T>::get(m);
            T* start = list.get();
            auto listLen = list.get_deleter().getLength();
            l = std::vector<T> {start, std::next(start, listLen)};
        } else {
            WS::List inList;
            *this >> inList;
            std::vector<T> res(inList.getArgc());
            for (auto& elem : res) {
                *this >> elem;
            }
            l = std::move(res);
        }
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<WS::Encoding E>
    auto WSStream<EIn, EOut>::operator>>(WS::StringData<E>& s) -> WSStream& {
        s = WS::String<E>::get(m);
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<typename T>
    auto WSStream<EIn, EOut>::operator>>(std::basic_string<T>& s) -> WSStream& {
        if constexpr (WS::StringTypeQ<T>) {
            s = WS::String<EIn>::template getString<T>(m);
        } else {
            static_assert(dependent_false_v<T>, "Calling operator>> with unsupported character type.");
        }
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<typename K, typename V>
    auto WSStream<EIn, EOut>::operator>>(std::map<K, V>& map) -> WSStream& {
        auto elemCount = testHead("Association");
        for (auto i = 0; i < elemCount; ++i) {
            *this >> WS::Rule;
            K key;
            *this >> key;
            V value;
            *this >> value;
            map.emplace(std::move(key), std::move(value));
        }
        return *this;
    }
 
    template<WS::Encoding EIn, WS::Encoding EOut>
    template<typename T, typename>
    auto WSStream<EIn, EOut>::operator>>(T& value) -> WSStream& {
        if constexpr (WS::ScalarSupportedTypeQ<T>) {
            value = WS::GetScalar<T>::get(m);
        } else {
            static_assert(dependent_false_v<T>, "Calling operator>> with unsupported type.");
        }
        return *this;
    }
 
} /* namespace LLU */
 
#endif /* LLU_WSTP_WSSTREAM_HPP_ */