Nektar::ErrorUtil Class Reference

#include <ErrorUtil.hpp>

Classes
class	NekError

Public Types
enum	ErrType { efatal , ewarning }

Static Public Member Functions
static void	SetErrorStream (std::ostream &o)
static void	SetPrintBacktrace (bool b)
static bool	HasCustomErrorStream ()
static void	Error (ErrType type, const char *routine, int lineNumber, const char *msg, unsigned int level, bool DoComm=false)
static void	Error (ErrType type, const char *routine, int lineNumber, const std::string &msg, unsigned int level)
static void	Error (ErrType type, const char *routine, int lineNumber, const char *msg)

Static Private Attributes
static std::ostream *	m_outStream = &std::cerr
static bool	m_printBacktrace = true

Detailed Description

Definition at line 54 of file ErrorUtil.hpp.

Member Enumeration Documentation

ErrType

enum Nektar::ErrorUtil::ErrType

Enumerator
efatal
ewarning

Definition at line 65 of file ErrorUtil.hpp.

    {
        efatal,
        ewarning
    };

Member Function Documentation

Error() [1/3]

static void Nektar::ErrorUtil::Error ( ErrType  type, const char *  routine, int  lineNumber, const char *  msg  )

inlinestatic

Definition at line 193 of file ErrorUtil.hpp.

    {
        Error(type, routine, lineNumber, msg, 0);
    }

References Error().

Error() [2/3]

static void Nektar::ErrorUtil::Error ( ErrType  type, const char *  routine, int  lineNumber, const char *  msg, unsigned int  level, bool  DoComm = false  )

inlinestatic

Definition at line 86 of file ErrorUtil.hpp.

    {
        // The user of outStream is primarily for the unit tests.  The unit
        // tests often generate errors on purpose to make sure invalid usage is
        // flagged appropriately.  Printing the error messages to cerr made the
        // unit test output hard to parse.
 
        std::string baseMsg =
            "Level " + std::to_string(level) + " assertion violation\n";
#if defined(NEKTAR_DEBUG) || defined(NEKTAR_FULLDEBUG)
        baseMsg += "Where   : " + std::string(routine) + "[" +
                   std::to_string(lineNumber) + "]\nMessage : ";
#endif
        baseMsg += std::string(msg);
 
        // Default rank is zero. If MPI used and initialised, populate with
        // the correct rank. Messages are only printed on rank zero.
        int rank = 0;
#if defined(NEKTAR_USE_MPI) && !defined(NEKTAR_USE_CWIPI)
        int flag = 0;
        if (DoComm)
        {
            MPI_Initialized(&flag);
            if (flag)
            {
                MPI_Comm_rank(MPI_COMM_WORLD, &rank);
            }
        }
#endif
 
        std::string btMessage("");
#if defined(NEKTAR_FULLDEBUG)
#ifndef _WIN32
        if (m_printBacktrace)
        {
            void *btArray[40];
            int btSize;
            char **btStrings;
 
            btSize    = backtrace(btArray, 40);
            btStrings = backtrace_symbols(btArray, btSize);
 
            for (int i = 0; i < btSize; ++i)
            {
                btMessage += std::string(btStrings[i]) + "\n";
            }
            free(btStrings);
        }
#endif
#endif
 
        switch (type)
        {
            case efatal:
                if (!rank)
                {
                    if (m_printBacktrace)
                    {
                        (*m_outStream) << btMessage;
                    }
                    (*m_outStream)
                        << std::endl
                        << "\033[31mFatal   : \033[0m" << baseMsg << std::endl
                        << std::endl;
                }
 
#if defined(NEKTAR_USE_MPI) && !defined(NEKTAR_USE_CWIPI)
                if (DoComm)
                {
                    if (flag)
                    {
                        MPI_Barrier(MPI_COMM_WORLD);
                    }
                }
#endif
                throw NekError(baseMsg);
                break;
            case ewarning:
                if (!rank)
                {
                    if (m_printBacktrace)
                    {
                        (*m_outStream) << btMessage;
                    }
                    (*m_outStream)
                        << std::endl
                        << "\033[36mWarning : \033[0m" << baseMsg << std::endl
                        << std::endl;
                }
                break;
            default:
                (*m_outStream) << std::endl
                               << "\033[35mUnknown warning type: \033[0m"
                               << baseMsg << std::endl
                               << std::endl;
        }
    }

References efatal, ewarning, and m_printBacktrace.

Referenced by Error(), and Error().

Error() [3/3]

static void Nektar::ErrorUtil::Error ( ErrType  type, const char *  routine, int  lineNumber, const std::string &  msg, unsigned int  level  )

inlinestatic

Definition at line 187 of file ErrorUtil.hpp.

    {
        Error(type, routine, lineNumber, msg.c_str(), level);
    }

References Error().

HasCustomErrorStream()

static bool Nektar::ErrorUtil::HasCustomErrorStream ( )

inlinestatic

Definition at line 81 of file ErrorUtil.hpp.

    {
        return m_outStream != &std::cerr;
    }

References m_outStream.

Referenced by Nektar::UnitTests::RedirectCerrIfNeeded().

SetErrorStream()

static void Nektar::ErrorUtil::SetErrorStream ( std::ostream &  o )

inlinestatic

Definition at line 71 of file ErrorUtil.hpp.

    {
        m_outStream = &o;
    }

References m_outStream.

Referenced by PYBIND11_MODULE(), and Nektar::UnitTests::RedirectCerrIfNeeded().

SetPrintBacktrace()

static void Nektar::ErrorUtil::SetPrintBacktrace ( bool  b )

inlinestatic

Definition at line 76 of file ErrorUtil.hpp.

    {
        m_printBacktrace = b;
    }

References m_printBacktrace.

Member Data Documentation

m_outStream

std::ostream * Nektar::ErrorUtil::m_outStream = &std::cerr

staticprivate

Definition at line 200 of file ErrorUtil.hpp.

Referenced by HasCustomErrorStream(), and SetErrorStream().

m_printBacktrace

bool Nektar::ErrorUtil::m_printBacktrace = true

staticprivate

Definition at line 201 of file ErrorUtil.hpp.

Referenced by Error(), and SetPrintBacktrace().