core.h

#pragma once

#include <format>
#include <functional>
#include <iterator>
#include <memory>
#include <optional>
#include <ranges>
#include <vector>
#include <Eigen/Core>
#include <nlohmann/json.hpp>

// forward declare logger
namespace spdlog {
class logger;
}

extern template class nlohmann::basic_json<>;

namespace Faunus {

using Point = Eigen::Vector3d;          
using PointVector = std::vector<Point>; 
using json = nlohmann::json;            
class Random;

namespace Geometry {
using BoundaryFunction = std::function<void(Point&)>;
using DistanceFunction = std::function<Point(const Point&, const Point&)>;
} // namespace Geometry

template <class T>
concept RequirePoints =
    std::ranges::range<T> && std::is_same_v<std::ranges::range_value_t<T>, Point>;

template <class T>
concept RequirePointIterator = std::is_convertible_v<std::iter_value_t<T>, Point>;

using namespace std::string_literals;

extern std::shared_ptr<spdlog::logger> faunus_logger; // global instance
extern std::shared_ptr<spdlog::logger> mcloop_logger; // global instance

struct GenericError : public std::runtime_error
{
    explicit GenericError(const std::exception& e);
    explicit GenericError(const std::runtime_error& e);
    explicit GenericError(const std::string& msg);
    explicit GenericError(const char* msg);

    template <class... Args>
    explicit GenericError(std::format_string<Args...> fmt, Args&&... args)
        : std::runtime_error(std::format(fmt, std::forward<Args>(args)...))
    {
    }
};

struct ConfigurationError : public GenericError
{
    using GenericError::GenericError;
    [[nodiscard]] const json& attachedJson() const;
    ConfigurationError& attachJson(const json& j);

  private:
    json attached_json;
};

struct IOError : public GenericError
{
    using GenericError::GenericError;
};

void displayError(spdlog::logger& logger, const std::exception& e, int level = 0);

} // namespace Faunus