error_ptr.hpp

#pragma once
 
#include <memory>
#include <utility>
 
#include "errors/error.hpp"
 
namespace errors
{
 
class error_ptr : public std::unique_ptr<error> {
    public:
        using std::unique_ptr<error>::unique_ptr;
 
        template <typename E>
        [[nodiscard]]
        bool is() const
        {
                static_assert(std::is_base_of_v<error, E>);
 
                auto current = this->get();
                while (current != nullptr) {
                        if (dynamic_cast<const E *>(current) != nullptr) {
                                return true;
                        }
 
                        current = current->cause().get();
                }
                return false;
        }
 
        template <typename E>
        [[nodiscard]]
        const E *as() const
        {
                static_assert(std::is_base_of_v<error, E>);
 
                auto current = this->get();
                while (current != nullptr) {
                        auto result = dynamic_cast<const E *>(current);
                        if (result != nullptr) {
                                return result;
                        }
 
                        current = current->cause().get();
                }
                return nullptr;
        }
 
        template <typename E>
        [[nodiscard]]
        E *as()
        {
                return const_cast<E *>(std::as_const(*this).as<E>());
        }
};
static_assert(!std::is_abstract<error_ptr>());
}
 
#if not defined(ERRORS_DISABLE_OSTREAM)
 
#include <cassert>
#include <ostream>
 
inline std::ostream &operator<<(std::ostream &os, const errors::error_ptr &err)
{
        const auto *current = err.get();
 
        if (!current) {
                os << "no error";
                return os;
        }
 
        bool printed = false;
 
        while (current != nullptr) {
                if (printed) {
                        os << ": ";
                        printed = false;
                }
 
                auto what = current->what();
                assert(what);
                if (what[0] != '\0') {
                        os << what;
                        printed = true;
                }
 
                current = current->cause().get();
        }
 
        return os;
}
#endif