error_info.hpp

// Copyright Take Vos 2020.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef ERROR_INFO_HPP
#define ERROR_INFO_HPP
 
#pragma once
 
#include "source_location.hpp"
#include "tag.hpp"
#include "concepts.hpp"
#include "check.hpp"
#include <cstdint>
#include <string>
#include <type_traits>
#include <optional>
 
namespace tt {
 
class URL;
 
class parse_location;
 
namespace detail {
 
struct error_info_entry_base {
    uint64_t version;
 
    [[nodiscard]] virtual std::string string() noexcept = 0;
};
 
template<basic_fixed_string Tag, typename ValueType>
struct error_info_entry : public error_info_entry_base {
    using value_type = ValueType;
 
    std::optional<value_type> value;
 
    [[nodiscard]] std::string string() noexcept override
    {
        using std::to_string;
        using tt::to_string;
 
        if constexpr (to_stringable<value_type>) {
            return fmt::format("{}={}", Tag, to_string(*value));
        } else {
            return fmt::format("{}={}", Tag, *value);
        }
    }
};
 
}
 
class error_info {
public:
    error_info(source_location location) noexcept
    {
        ++version;
        tt_axiom(state == state::closed);
        tt_axiom(version != 0);
 
        state = state::writing;
        set<"source_location">(location);
    }
 
    error_info(bool reopen) noexcept
    {
        tt_axiom(reopen == true);
        if (state == state::closed) {
            // Start a new transaction if it wasn't already opened.
            // This may happen on a catch statement from a traditional exception.
            ++version;
 
        } else {
            tt_axiom(state == state::reading);
        }
 
        tt_axiom(version != 0);
 
        state = state::writing;
    }
 
    ~error_info()
    {
        tt_axiom(state == state::writing);
        tt_axiom(version != 0);
 
        state = state::reading;
    }
 
    error_info(error_info &&rhs) noexcept = delete;
    error_info &operator=(error_info &&rhs) noexcept = delete;
    error_info(error_info const &rhs) = delete;
    error_info &operator=(error_info const &rhs) = delete;
 
    template<basic_fixed_string Tag, typename Arg>
    error_info &set(Arg &&value) noexcept
    {
        tt_axiom(state == state::writing);
        tt_axiom(version != 0);
 
        auto &e = entry<Tag, std::remove_cvref_t<Arg>>;
        if (e.version == 0) {
            // Track this entry from now on, so that information on all error_info
            // can be listed dynamically.
            [[unlikely]] register_entry(e);
        }
 
        e.version = version;
        e.value = std::forward<Arg>(value);
        return *this;
    }
 
    static void close() noexcept
    {
        tt_axiom(state == state::closed || state == state::reading);
 
        state = state::closed;
    }
 
    template<typename ValueType, basic_fixed_string Tag>
    static std::optional<ValueType> pop() noexcept
    {
        close();
        tt_axiom(state == state::closed);
 
        auto &e = entry<Tag,ValueType>;
        if (version != 0 && e.version == version) {
            return std::exchange(e.value, {});
        } else {
            return {};
        }
    }
 
    template<typename ValueType, basic_fixed_string Tag>
    static std::optional<ValueType> peek() noexcept
    {
        auto &e = entry<Tag,ValueType>;
        if (version != 0 && e.version == version) {
            return e.value;
        } else {
            return {};
        }
    }
 
    static std::string string() noexcept
    {
        std::string r;
 
        for (auto e: entries) {
            if (version != 0 && e->version == version) {
                if (!r.empty()) {
                    r += ", ";
                }
 
                r += e->string();
            }
        }
        return r;
    }
 
private:
    enum class state {
        closed, 
        writing, 
        reading 
    };
 
    inline static thread_local uint64_t version;
 
    inline static thread_local state state;
 
    template<basic_fixed_string Tag, typename ValueType>
    inline static thread_local detail::error_info_entry<Tag, ValueType> entry;
 
    inline static thread_local std::vector<detail::error_info_entry_base *> entries;
 
    tt_no_inline static void register_entry(detail::error_info_entry_base &e) noexcept
    {
        entries.push_back(&e);
    }
};
 
[[nodiscard]] inline std::string to_string(std::exception const &e, bool close=true) noexcept
{
    if (close) {
        error_info::close();
    }
    return fmt::format("{}: {}: {}", typeid(e).name(), e.what(), error_info::string());
}
 
} // namespace tt
 
#define tt_error_info() tt::error_info(tt_source_location_current())
 
#endif