error.h

/*********************************************************************************************************************************************/
/*  DocWire SDK: Award-winning modern data processing in C++20. SourceForge Community Choice & Microsoft support. AI-driven processing.      */
/*  Supports nearly 100 data formats, including email boxes and OCR. Boost efficiency in text extraction, web data extraction, data mining,  */
/*  document analysis. Offline processing possible for security and confidentiality                                                          */
/*                                                                                                                                           */
/*  Copyright (c) SILVERCODERS Ltd, http://silvercoders.com                                                                                  */
/*  Project homepage: https://github.com/docwire/docwire                                                                                     */
/*                                                                                                                                           */
/*  SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-DocWire-Commercial                                                                  */
/*********************************************************************************************************************************************/
 
#ifndef DOCWIRE_ERROR_H
#define DOCWIRE_ERROR_H
 
#include "core_export.h"
#include "diagnostic_context.h" // IWYU pragma: keep
#include <exception>
#include <typeinfo>
#include "serialization_pair.h" // IWYU pragma: keep
#include "source_location.h"
#include "type_id.h"
#include <tuple>
#include <utility>

namespace docwire::errors
{
#ifdef DOCWIRE_ENABLE_SHORT_MACRO_NAMES
    #define current_location DOCWIRE_CURRENT_LOCATION
#endif

struct DOCWIRE_CORE_EXPORT base : public std::exception
{
    source_location location;

    base(const source_location& location = source_location::current());
    base(const base&);
    base(base&&);
    base& operator=(const base&);
    base& operator=(base&&);
    ~base() override;

    virtual type_id context_type_id(size_t index) const noexcept = 0;

    virtual std::string context_string(size_t index) const = 0;

    virtual size_t context_count() const noexcept = 0;

    const char* what() const noexcept override;
};
 
} // namespace docwire::errors
 
namespace docwire::errors
{
std::string diagnostic_message(const std::exception& e);
std::string diagnostic_message(std::exception_ptr eptr);
} // namespace docwire::errors
 
#include "stringification.h"
 
namespace docwire::errors
{

template <typename... T>
struct impl : public base
{
private:
    template<size_t I>
    std::string context_string_impl() const
    {
        return stringify(std::get<I>(context));
    }
 
    template<size_t I>
    type_id context_type_impl() const noexcept
    {
        return type_id_of<std::decay_t<decltype(std::get<I>(context))>>();
    }
 
    template <size_t... Is>
    std::string context_string_at(size_t index, std::index_sequence<Is...>) const {
        using FuncType = std::string(impl::*)() const;
        static constexpr FuncType funcs[] = { &impl::template context_string_impl<Is>... };
        return (this->*funcs[index])();
    }
 
    template <size_t... Is>
    type_id context_type_at(size_t index, std::index_sequence<Is...>) const noexcept {
        using FuncType = type_id(impl::*)() const noexcept;
        static constexpr FuncType funcs[] = { &impl::template context_type_impl<Is>... };
        return (this->*funcs[index])();
    }
 
public:
    std::tuple<T...> context;
    
    explicit impl(const std::tuple<T...>& context_tuple, const source_location& location = source_location::current())
        : base(location), context(context_tuple)
    {
    }

    type_id context_type_id(size_t index) const noexcept override
    {
        return context_type_at(index, std::make_index_sequence<sizeof...(T)>{});
    }

    std::string context_string(size_t index) const override
    {
        return context_string_at(index, std::make_index_sequence<sizeof...(T)>{});
    }

    size_t context_count() const noexcept override
    {
        return sizeof...(T);
    }
};
 
} // namespace docwire::errors
 
#endif