Errors.h

#ifndef NTA_ERRORS_H_INCLUDED
#define NTA_ERRORS_H_INCLUDED
 
#include <functional>
 
#include "nta/Option.h"
 
namespace nta {
    struct Error;
    typedef std::function<void(const Error*)> ErrorCallback;
    enum ErrorType {
        MISSING_RESOURCE,
        INVALID_VALUE,
        GL_FAILURE,
        SDL_FAILURE,
        DEVIL_FAILURE,
        IMPOSSIBLE_BEHAVIOR,
        UNWRAP_WRONG_RESULT_VARIANT,
        OTHER
    };
    struct Error {
        Error(crstring desc = "", ErrorType t = OTHER) : description(desc), type(t) {
        }
        Error(const Error& other) {
            description = other.description;
            type = other.type;
            prev = other.prev;
        }
        ~Error() {
            if (prev) delete prev;
        }
        std::string description;
        ErrorType type;
        const Error* prev = nullptr;
    };
    class ErrorManager {
    private:
        static const Error* m_errors;
        static ErrorCallback m_periodic_callback;
        static ErrorCallback m_push_callback;
    public:
        static void handle_errors();
        static void set_periodic_callback(const ErrorCallback& callback);
        static void set_push_callback(const ErrorCallback& callback);
        static void push_error(const Error& err);
        static const Error* pop_error();
        static const Error* peek_error();
        static void clear_errors();
    };
 
    // I wonder how much of my C++ code is influenced by Rust
    template<typename T>
    class Result {
    private:
        Result() {}
 
        union {
            T data;
            Error err;
        };
        bool is_err_variant;
    public:
        Result(const Result& other) {
            is_err_variant = other.is_err_variant;
            if (is_err_variant) {
                new(&err) Error(other.err);
            } else {
                new(&data) T(other.data);
            }
        }
        ~Result() {}
        static Result new_ok(const T& data) {
            Result ret;
            new(&ret.data) T((data));
            ret.is_err_variant = false;
            return ret;
        }
        static Result new_err(const Error& err) {
            Result ret;
            new(&ret.err) Error(std::move(err));
            ret.is_err_variant = true;
            return ret;
        }
        bool is_err() const { return is_err_variant; }
        bool is_ok() const { return !is_err_variant; }
        T get_data() const {
            if (is_err()) {
                ErrorManager::push_error(Error("Called get_data on err Result",
                                               UNWRAP_WRONG_RESULT_VARIANT));
            }
            return data; 
        }
        T unwrap() const { return get_data(); }
        Error get_err() const { 
            if (is_ok()) {
                ErrorManager::push_error(Error("Called get_err on ok Result",
                                               UNWRAP_WRONG_RESULT_VARIANT));
            }
            return err; 
        }
        T get_data_or(T optb) const { return is_err_variant ? optb : data; }
        T unwrap_or(T optb) const { return get_data_or(optb); }
        template<typename S>
        Result<S> map(std::function<S(T)> func) {
            return is_err_variant ? Result<S>::new_err(err) : Result<S>::new_ok(func(data));
        }
        // Result<void> is basically Option<Error>
        utils::Option<Error> map(std::function<void(T)> func) {
            if (is_err_variant) return utils::Option<Error>::some(err);
            func(data);
            return utils::Option<Error>::none();
        }
        template<typename S>
        Result<S> convert_error() {
            if (is_ok()) {
                ErrorManager::push_error(Error("Called convert_error on ok Result",
                                               UNWRAP_WRONG_RESULT_VARIANT));
            }
            return Result<S>::new_err(err);
        }
    };
 
    std::string get_errortype_string(ErrorType t);
};
 
#endif // NTA_ERRORS_H_INCLUDED