exceptions.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Logger.h> // IWYU pragma: keep
#include <ogdf/basic/basic.h>
#include <ogdf/basic/internal/config_autogen.h>
 
#include <exception>
#include <iostream> // IWYU pragma: keep
 
namespace ogdf {
 
 
#define OGDF_FLUSH_OUTPUTS std::cout << std::flush, ::ogdf::Logger::sfout() << std::flush
 
#define OGDF_THROW_PARAM(CLASS, PARAM) OGDF_FLUSH_OUTPUTS, throw CLASS(PARAM)
 
#define OGDF_THROW(CLASS) OGDF_FLUSH_OUTPUTS, throw CLASS()
 
#ifdef OGDF_DEBUG
#   undef OGDF_THROW_PARAM
#   define OGDF_THROW_PARAM(CLASS, PARAM) \
        OGDF_FLUSH_OUTPUTS, throw CLASS(PARAM, __FILE__, __LINE__)
#   undef OGDF_THROW
#   define OGDF_THROW(CLASS) OGDF_FLUSH_OUTPUTS, throw CLASS(__FILE__, __LINE__)
#endif
 
 
 
enum class AlgorithmFailureCode {
    Unknown,
    IllegalParameter, 
    NoFlow, 
    Sort, 
    Label, 
    ExternalFace, 
    ForbiddenCrossing, 
    TimelimitExceeded, 
    NoSolutionFound, 
    IndexOutOfBounds, 
 
    // The following codes are used by Abacus (think about changing them to
    // more error describing codes)
    PrimalBound,
    DualBound,
    NotInteger,
    Buffer,
    AddVar,
    Sorter,
    Phase,
    Active,
    NoSolution,
    MakeFeasible,
    Guarantee,
    BranchingVariable,
    Strategy,
    CloseHalf,
    StandardPool,
    Variable,
    LpIf,
    Lp,
    Bstack,
    LpStatus,
    BranchingRule,
    FixSet,
    LpSub,
    String,
    Constraint,
    Pool,
    Global,
    FsVarStat,
    LpVarStat,
    OsiIf,
    ConBranchRule,
    Timer,
    Array,
    Csense,
    BPrioQueue,
    FixCand,
    BHeap,
    Poolslot,
    SparVec,
    Convar,
    Ostream,
    Hash,
    Paramaster,
    InfeasCon,
 
    STOP // INSERT NEW CODES BEFORE afcSTOP!
};
 
 
enum class LibraryNotSupportedCode {
    Unknown,
    Coin, 
    Abacus, 
    Cgal, 
    FunctionNotImplemented, 
    MissingCallbackImplementation, //
    STOP // INSERT NEW CODES BEFORE nscSTOP!
};
 
 
class OGDF_EXPORT Exception : std::exception {
private:
    const char* m_file; 
    int m_line; 
 
public:
 
    explicit Exception(const char* file = nullptr, int line = -1) : m_file(file), m_line(line) { }
 
 
    const char* file() const { return m_file; }
 
 
    int line() const { return m_line; }
 
    const char* what() const noexcept override { return "Unknown OGDF Exception"; }
};
 
 
class OGDF_EXPORT DynamicCastFailedException : public Exception {
public:
    explicit DynamicCastFailedException(const char* file = nullptr, int line = -1)
        : Exception(file, line) { }
};
 
 
class OGDF_EXPORT InsufficientMemoryException : public Exception {
public:
    explicit InsufficientMemoryException(const char* file = nullptr, int line = -1)
        : Exception(file, line) { }
};
 
 
class OGDF_EXPORT NoStdComparerException : public Exception {
public:
    explicit NoStdComparerException(const char* file = nullptr, int line = -1)
        : Exception(file, line) { }
};
 
 
class OGDF_EXPORT TypeNotSupportedException : public Exception {
public:
    explicit TypeNotSupportedException(const char* file = nullptr, int line = -1)
        : Exception(file, line) { }
};
 
 
class OGDF_EXPORT AlgorithmFailureException : public Exception {
public:
    explicit AlgorithmFailureException(AlgorithmFailureCode code, const char* file = nullptr,
            int line = -1)
        : Exception(file, line), m_exceptionCode(code) { }
 
    explicit AlgorithmFailureException(const char* file = nullptr, int line = -1)
        : Exception(file, line), m_exceptionCode(AlgorithmFailureCode::Unknown) { }
 
    AlgorithmFailureCode exceptionCode() const { return m_exceptionCode; }
 
    const char* what() const noexcept override { return codeToString(m_exceptionCode); }
 
    static const char* codeToString(AlgorithmFailureCode code);
 
private:
    AlgorithmFailureCode m_exceptionCode; 
};
 
 
class OGDF_EXPORT LibraryNotSupportedException : public Exception {
public:
    explicit LibraryNotSupportedException(LibraryNotSupportedCode code, const char* file = nullptr,
            int line = -1)
        : Exception(file, line), m_exceptionCode(code) { }
 
    explicit LibraryNotSupportedException(const char* file = nullptr, int line = -1)
        : Exception(file, line), m_exceptionCode(LibraryNotSupportedCode::Unknown) { }
 
    LibraryNotSupportedCode exceptionCode() const { return m_exceptionCode; }
 
private:
    LibraryNotSupportedCode m_exceptionCode; 
};
 
}