error.h

/*******************************************************************************
 * Copyright (C) 2015-2026 Commissariat a l'energie atomique et aux energies alternatives (CEA)
 * Copyright (C) 2021 Institute of Bioorganic Chemistry Polish Academy of Science (PSNC)
 * Copyright (C) 2026 Julien Bigot <julien@julien-bigot.fr>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * * Neither the name of CEA nor the names of its contributors may be used to
 *   endorse or promote products derived from this software without specific
 *   prior written permission.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 ******************************************************************************/
 
#ifndef PDI_ERROR_H_
#define PDI_ERROR_H_
 
#include <concepts>
#include <exception>
#include <iostream>
#include <ranges>
#include <sstream>
#include <stdexcept>
#include <string>
 
#include <spdlog/spdlog.h>
 
#include <pdi/pdi_fwd.h>
#include <pdi/paraconf_wrapper.h>
 
namespace PDI {

template <typename R>
concept range_of_exception_ptrs
    = std::ranges::input_range<R> && std::ranges::sized_range<R> && std::convertible_to<std::ranges::range_reference_t<R>, std::exception_ptr>;

class PDI_EXPORT Error: virtual public std::exception
{
public:
    virtual ~Error() noexcept;

    virtual PDI_status_t status() const noexcept = 0;

    [[noreturn]] virtual void rethrow_with_context(std::string context) const = 0;

    virtual std::string full_msg() const = 0;

    template <typename... Args>
    [[noreturn]] void inline rethrow_with_context(fmt::format_string<Args...> format_str, Args&&... args) const
    {
        rethrow_with_context(fmt::format(format_str, std::forward<Args>(args)...));
        std::abort(); // rethrow_with_context should never return, this is just to silence compiler warnings
    }
};
 
namespace impl {

class PDI_EXPORT What_impl: virtual public std::exception
{
private:
    std::string m_what;
 
protected:
    What_impl(std::string what) noexcept;
 
public:
    const char* what() const noexcept override;
};

template <PDI_status_t STATUS>
class PDI_EXPORT Status_impl: virtual public Error
{
public:
    PDI_status_t status() const noexcept override { return STATUS; }
};

template <PDI_status_t STATUS>
class PDI_EXPORT Error_impl
    : public What_impl
    , public Status_impl<STATUS>
{
public:
    Error_impl(std::string what) noexcept;

    template <typename... Args>
    inline Error_impl(fmt::format_string<Args...> format_str, Args&&... args) noexcept
        : Error_impl(fmt::format(format_str, std::forward<Args>(args)...))
    {}
 
    using What_impl::what;
 
    using Status_impl<STATUS>::status;
 
    std::string full_msg() const override;
 
    [[noreturn]] void rethrow_with_context(std::string msg) const override;
};
 
} // namespace impl

using Value_error = impl::Error_impl<PDI_ERR_VALUE>;
extern template class PDI_EXPORT impl::Error_impl<PDI_ERR_VALUE>;

using Plugin_error = impl::Error_impl<PDI_ERR_PLUGIN>;
extern template class PDI_EXPORT impl::Error_impl<PDI_ERR_PLUGIN>;

using Impl_error = impl::Error_impl<PDI_ERR_IMPL>;
extern template class PDI_EXPORT impl::Error_impl<PDI_ERR_IMPL>;

using State_error = impl::Error_impl<PDI_ERR_STATE>;
extern template class PDI_EXPORT impl::Error_impl<PDI_ERR_STATE>;

using Permission_error = impl::Error_impl<PDI_ERR_PERMISSION>;
extern template class PDI_EXPORT impl::Error_impl<PDI_ERR_PERMISSION>;

using System_error = impl::Error_impl<PDI_ERR_SYSTEM>;
extern template class PDI_EXPORT impl::Error_impl<PDI_ERR_SYSTEM>;

using Type_error = impl::Error_impl<PDI_ERR_TYPE>;
extern template class PDI_EXPORT impl::Error_impl<PDI_ERR_TYPE>;

using Invalid_action_error = impl::Error_impl<PDI_ERR_INVALIDACTION>;
extern template class PDI_EXPORT impl::Error_impl<PDI_ERR_INVALIDACTION>;

class PDI_EXPORT Spectree_error
    : public impl::What_impl
    , public impl::Status_impl<PDI_ERR_SPECTREE>
{
private:
    std::optional<Yaml_region> m_location;
 
    Spectree_error(std::optional<Yaml_region> location, std::string what);
 
public:
    Spectree_error(PC_tree_t tree, std::string what);

    template <typename... Args>
    inline Spectree_error(PC_tree_t tree, fmt::format_string<Args...> format_str, Args&&... args)
        : Spectree_error(tree, fmt::format(format_str, std::forward<Args>(args)...))
    {}
 
    using What_impl::what;
 
    using Status_impl::status;
 
    std::string full_msg() const override;
 
    [[noreturn]] void rethrow_with_context(std::string msg) const override;
};

class PDI_EXPORT Multiple_errors
    : public impl::Status_impl<PDI_ERR_MULTIPLE>
    , public impl::What_impl
{
private:
    std::vector<std::exception_ptr> m_nested_ptrs;
 
public:
    Multiple_errors(std::vector<std::exception_ptr> causes, std::string what) noexcept;

    template <typename... Args>
    inline Multiple_errors(range_of_exception_ptrs auto&& causes, fmt::format_string<Args...> format_str, Args&&... args) noexcept
        : Multiple_errors(std::vector<std::exception_ptr>(causes.begin(), causes.end()), fmt::format(format_str, std::forward<Args>(args)...))
    {}

    std::vector<std::exception_ptr> const & nested_ptrs() const;
 
    using Status_impl::status;
 
    using What_impl::what;
 
    std::string full_msg() const override;
 
    [[noreturn]] void rethrow_with_context(std::string msg) const override;
};

[[noreturn]] void PDI_EXPORT rethrow_with_simple_context(std::exception_ptr err, std::string msg);

template <typename... Args>
[[noreturn]] static inline void rethrow_with_context(std::exception_ptr err, fmt::format_string<Args...> format_str, Args&&... args)
{
    rethrow_with_simple_context(err, fmt::format(format_str, std::forward<Args>(args)...));
}

void PDI_EXPORT rethrow_with_simple_context(std::vector<std::exception_ptr> errors, std::string msg);

template <typename... Args>
static inline void rethrow_with_context(range_of_exception_ptrs auto&& errors, fmt::format_string<Args...> format_str, Args&&... args)
{
    rethrow_with_simple_context(std::vector<std::exception_ptr>(errors.begin(), errors.end()), fmt::format(format_str, std::forward<Args>(args)...));
}
 
} // namespace PDI
 
#endif // PDI_ERROR_H_