result.hpp

// Copyright (c) 2026 Ryan P. Nicholl <rnicholl@protonmail.com>
// Copyright 2024 Ryan P. Nicholl, rnicholl@protonmail.com
 
#ifndef RPNXDATASTRUCTURES_RESULT_HPP
#define RPNXDATASTRUCTURES_RESULT_HPP
 
#include <exception>
#include <optional>
#include <cassert>
#include <stdexcept>
#include <utility>
 
namespace rpnx
{
    template < typename T >
    class result
    {
        std::optional< T > t;
        std::exception_ptr er;
 
      public:
        result(T t) : t(std::move(t))
        {
        }

        result()
        {
        }

        result(std::exception_ptr er) : er(er)
        {
        }

        void test() const
        {
            if (er)
            {
                std::rethrow_exception(er);
            }
        }

        T & get() &
        {
            if (er)
            {
                std::rethrow_exception(er);
            }
 
            assert(t.has_value());
 
            return t.value();
        }

        T const & get() const &
        {
            if (er)
            {
                std::rethrow_exception(er);
            }
 
            assert(t.has_value());
 
            return t.value();
        }

        T && get() &&
        {
            if (er)
            {
                std::rethrow_exception(er);
            }
 
            assert(t.has_value());
 
            return std::move(t.value());
        }

        T const && get() const &&
        {
            if (er)
            {
                std::rethrow_exception(er);
            }
 
            assert(t.has_value());
 
            return std::move(t.value());
        }

        T & value() &
        {
            return get();
        }

        T const & value() const &
        {
            return get();
        }

        T && value() &&
        {
            return std::move(*this).get();
        }

        T const && value() const &&
        {
            return std::move(*this).get();
        }

        void set_value(T t)
        {
            this->er = nullptr;
            this->t = std::move(t);
        }

        void set_error(std::exception_ptr er)
        {
            this->t.reset();
            this->er = er;
        }

        void set_exception(std::exception_ptr er)
        {
            set_error(er);
        }

        bool has_result() const
        {
            return t.has_value() || er != nullptr;
        }

        bool has_value() const
        {
            return t.has_value();
        }

        bool has_error() const
        {
            return er != nullptr;
        }

        bool has_exception() const
        {
            return has_error();
        }

        std::exception_ptr get_error() const
        {
            return er;
        }

        inline operator bool() const
        {
            return has_result();
        }
    };

    template <>
    class result< void >
    {
        bool t = false;
        std::exception_ptr er;
 
      public:
        result()
        {
        }

        result(std::exception_ptr er) : er(er)
        {
        }

        void test() const
        {
            if (er)
            {
                std::rethrow_exception(er);
            }
        }

        void get() const
        {
            if (er)
                std::rethrow_exception(er);
            if (!t)
                throw std::logic_error("No value");
            return;
        }

        void value() const
        {
            get();
        }

        void set_value()
        {
            this->er = nullptr;
            this->t = true;
        }

        void set_error(std::exception_ptr er)
        {
            this->t = false;
            this->er = er;
        }

        void set_exception(std::exception_ptr er)
        {
            set_error(er);
        }

        bool has_value() const
        {
            return t;
        }

        bool has_error() const
        {
            return er != nullptr;
        }

        bool has_exception() const
        {
            return has_error();
        }

        std::exception_ptr get_error() const
        {
            return er;
        }

        inline bool has_result() const
        {
            return has_value() || has_error();
        }

        inline operator bool() const
        {
            return has_result();
        }
    };
} // namespace rpnx
 
#endif // RPNXDATASTRUCTURES_RESULT_HPP