ErrorManager.h

Go to the documentation of this file.

 
#ifndef LLU_ERRORLOG_ERRORMANAGER_H
#define LLU_ERRORLOG_ERRORMANAGER_H
 
#include <algorithm>
#include <initializer_list>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "LLU/ErrorLog/LibraryLinkError.h"
#include "LLU/LibraryData.h"
 
namespace LLU {
 
    class ErrorManager {
    public:
        using ErrorStringData = std::pair<std::string, std::string>;
 
    public:
        ErrorManager() = delete;
 
        static void registerPacletErrors(const std::vector<ErrorStringData>& errors);
 
        template<typename... T>
        [[noreturn]] static void throwException(const std::string& errorName, T&&... args);
 
        template<typename... T>
        [[noreturn]] static void throwException(WolframLibraryData libData, const std::string& errorName, T&&... args);
 
        template<class Error, typename... Args>
        [[noreturn]] static void throwCustomException(const std::string& errorName, Args&&... args);
 
        template<typename... T>
        [[noreturn]] static void throwExceptionWithDebugInfo(const std::string& errorName, const std::string& debugInfo, T&&... args);
 
        template<typename... T>
        [[noreturn]] static void
        throwExceptionWithDebugInfo(WolframLibraryData libData, const std::string& errorName, const std::string& debugInfo, T&&... args);
 
        static void setSendParametersImmediately(bool newValue) {
            sendParametersImmediately = newValue;
        }
 
        static bool getSendParametersImmediately() {
            return sendParametersImmediately;
        }
 
        static void sendRegisteredErrorsViaWSTP(WSLINK mlp);
 
    private:
        using ErrorMap = std::unordered_map<std::string, const LibraryLinkError>;
 
    private:
        static void set(const ErrorStringData& errorData);
 
        static const LibraryLinkError& findError(int errorId);
 
        static const LibraryLinkError& findError(const std::string& errorName);
 
        /***
         * @brief Initialization of static error map
         * @param initList - list of errors used internally by LLU
         * @return reference to static error map
         */
        static ErrorMap registerLLUErrors(std::initializer_list<ErrorStringData> initList);
 
        static ErrorMap& errors();
 
        static int& nextErrorId();
 
        static bool sendParametersImmediately;
    };
 
    template<typename... T>
    [[noreturn]] void ErrorManager::throwException(const std::string& errorName, T&&... args) {
        throwException(LibraryData::uncheckedAPI(), errorName, std::forward<T>(args)...);
    }
 
    template<typename... T>
    [[noreturn]] void ErrorManager::throwException(WolframLibraryData libData, const std::string& errorName, T&&... args) {
        throwExceptionWithDebugInfo(libData, errorName, "", std::forward<T>(args)...);
    }
 
    template<class Error, typename... Args>
    [[noreturn]] void ErrorManager::throwCustomException(const std::string& errorName, Args&&... args) {
        throw Error(findError(errorName), std::forward<Args>(args)...);
    }
 
    template<typename... T>
    [[noreturn]] void ErrorManager::throwExceptionWithDebugInfo(const std::string& errorName, const std::string& debugInfo, T&&... args) {
        throwExceptionWithDebugInfo(LibraryData::uncheckedAPI(), errorName, debugInfo, std::forward<T>(args)...);
    }
 
    template<typename... T>
    [[noreturn]] void
    ErrorManager::throwExceptionWithDebugInfo(WolframLibraryData libData, const std::string& errorName, const std::string& debugInfo, T&&... args) {
        auto e = findError(errorName);
        e.setDebugInfo(debugInfo);
        if (libData && sizeof...(args) > 0) {
            e.setMessageParameters(libData, std::forward<T>(args)...);
            if (sendParametersImmediately) {
                e.sendParameters(libData);
            }
        }
        throw std::move(e);
    }
 
} /* namespace LLU */
 
#endif    // LLU_ERRORLOG_ERRORMANAGER_H