error.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2023 - 2025 NeoN authors
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <cstdlib>
#include <exception>
#include <iostream>
#include <string>
#include <sstream>
#include <iostream>
 
#ifdef NF_WITH_MPI_SUPPORT
#include <mpi.h>
#endif
 
// compiling with clang and cuda fails to
// find source location
// #include <source_location>
// #include <experimental/source_location>
 
#include "info.hpp"
 
#ifdef NF_DEBUG_MESSAGING
#include "cpptrace/cpptrace.hpp"
#endif
 
 
namespace NeoN
{
 
class NeoNException : public std::exception
{
public:
 
    explicit NeoNException(const std::string& message) : message_(message) {}
 
    const char* what() const noexcept override { return message_.c_str(); }
 
private:
 
    std::string message_; 
};
 
} // namespace NeoN
 
#ifdef NF_DEBUG_MESSAGING
#define NF_ERROR_MESSAGE(message)                                                                  \
    "Error: " << message << "\nFile: " << __FILE__ << "\nLine: " << __LINE__ << "\n"               \
              << cpptrace::generate_trace().to_string() << "\n"
#else
#define NF_ERROR_MESSAGE(message)                                                                  \
    "Error: " << message << "\nFile: " << __FILE__ << "\nLine: " << __LINE__ << "\n"
#endif
 
#ifdef NF_WITH_MPI_SUPPORT
#define NF_ERROR_EXIT(message)                                                                     \
    do                                                                                             \
    {                                                                                              \
        std::cerr << NF_ERROR_MESSAGE(message);                                                    \
        MPI_Abort(MPI_COMM_WORLD, 1);                                                              \
    }                                                                                              \
    while (false)
#else
#define NF_ERROR_EXIT(message)                                                                     \
    do                                                                                             \
    {                                                                                              \
        std::cerr << NF_ERROR_MESSAGE(message);                                                    \
        std::exit(1);                                                                              \
    }                                                                                              \
    while (false)
#endif
 
#define NF_THROW(message)                                                                          \
    throw NeoN::NeoNException((std::stringstream() << NF_ERROR_MESSAGE(std::string(message))).str())
 
#define NF_ASSERT(condition, message)                                                              \
    do                                                                                             \
    {                                                                                              \
        if (!(condition)) [[unlikely]]                                                             \
        {                                                                                          \
            NF_ERROR_EXIT("Assertion `" #condition "` failed.\n       " << message);               \
        }                                                                                          \
    }                                                                                              \
    while (false)
 
#define NF_ASSERT_THROW(condition, message)                                                        \
    do                                                                                             \
    {                                                                                              \
        if (!(condition)) [[unlikely]]                                                             \
        {                                                                                          \
            NF_THROW("Assertion `" #condition "` failed.\n       " << message);                    \
        }                                                                                          \
    }                                                                                              \
    while (false)
 
#ifdef NF_DEBUG
#define NF_DEBUG_ASSERT(condition, message) NF_ASSERT(condition, message)
 
#define NF_DEBUG_ASSERT_THROW(condition, message) NF_ASSERT_THROW(condition, message)
#else
#define NF_DEBUG_ASSERT(condition, message) ((void)0)
 
#define NF_DEBUG_ASSERT_THROW(condition, message) ((void)0)
#endif
 
#define NF_ASSERT_EQUAL(a, b) NF_ASSERT(a == b, "Expected " << b << ", got " << a)
 
#define NF_DEBUG_ASSERT_EQUAL(a, b) NF_DEBUG_ASSERT(a == b, "Expected " << b << ", got " << a)
 
#define NF_ASSERT_EQUAL_THROW(a, b) NF_ASSERT_THROW(a == b, "Expected " << b << ", got " << a)
 
#define NF_DEBUG_ASSERT_EQUAL_THROW(a, b)                                                          \
    NF_DEBUG_ASSERT_THROW(a == b, "Expected " << b << ", got " << a)