config.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/internal/config_autogen.h>
#include <ogdf/basic/internal/version.h>
 
#include <sstream> // IWYU pragma: keep
#include <string>
 
#if defined(OGDF_DEBUG) && defined(NDEBUG)
#   error "Contradicting configuration: Macros OGDF_DEBUG and NDEBUG are defined."
#endif
 
namespace ogdf {
 
// generally used <string> members
using std::string;
using std::to_string;
 
// detection of the system
 
#if defined(unix) || defined(__unix__) || defined(__unix) || defined(_AIX) || defined(__APPLE__)
#   define OGDF_SYSTEM_UNIX
#endif
 
#if defined(__WIN32__) || defined(_WIN32) || defined(__NT__)
#   define OGDF_SYSTEM_WINDOWS
#endif
 
// Note: Apple OS X machines will be both OGDF_SYSTEM_UNIX and OGDF_SYSTEM_OSX
#if defined(__APPLE__)
#   define OGDF_SYSTEM_OSX
#endif
 
// C++11 standard
 
#if __cplusplus < 201103
 
#   if defined(_MSC_VER)
#       if _MSC_VER < 1700
#           error "Compiling OGDF requires Visual C++ 11 (Visual Studio 2012) or higher!"
#       endif
 
#   elif defined(__GNUC__)
#       ifndef __GXX_EXPERIMENTAL_CXX0X__
#           error "No C++11 support activated for g++ (compile with -std=c++0x or -std=c++11)!"
#       endif
 
#   else
#       error "Compiling OGDF requires a C++11 compliant compiler!"
#   endif
 
#endif
 
#ifdef __has_cpp_attribute
#   define OGDF_HAS_CPP_ATTRIBUTE(x) \
        (__has_cpp_attribute(x) && __cplusplus >= __has_cpp_attribute(x))
#else
#   define OGDF_HAS_CPP_ATTRIBUTE(x) 0
#endif
 
 
#define OGDF_EXPORT
 
#define OGDF_EXPORT_TEMPL_DECL OGDF_EXPORT
 
#define OGDF_EXPORT_TEMPL_INST
 
#define OGDF_LOCAL
 
#ifdef OGDF_SYSTEM_WINDOWS
#   ifdef OGDF_DLL
#       undef OGDF_EXPORT
#       ifdef OGDF_INSTALL
#           define OGDF_EXPORT __declspec(dllexport)
#           undef OGDF_EXPORT_TEMPL_DECL
#           undef OGDF_EXPORT_TEMPL_INST
#           define OGDF_EXPORT_TEMPL_DECL
#           define OGDF_EXPORT_TEMPL_INST OGDF_EXPORT
#       else
#           define OGDF_EXPORT __declspec(dllimport)
#       endif
#   endif
#else
#   undef OGDF_EXPORT
#   undef OGDF_LOCAL
#   define OGDF_EXPORT __attribute__((visibility("default")))
#   define OGDF_LOCAL __attribute__((visibility("hidden")))
#endif
 
 
#define OGDF_DEPRECATED(reason)
 
#if OGDF_HAS_CPP_ATTRIBUTE(deprecated)
#   undef OGDF_DEPRECATED
#   define OGDF_DEPRECATED(reason) [[deprecated(reason)]]
#elif defined(_MSC_VER)
#   undef OGDF_DEPRECATED
#   define OGDF_DEPRECATED(reason) __declspec(deprecated(reason))
#elif defined(__GNUC__)
#   undef OGDF_DEPRECATED
#   define OGDF_DEPRECATED(reason) __attribute__((deprecated(reason)))
#endif
 
 
#define OGDF_DISABLE_WARNING_PUSH
 
#define OGDF_DISABLE_WARNING_POP
 
#define OGDF_DISABLE_WARNING(warningNumber)
 
#define OGDF_DISABLE_WARNING_THROW_TERMINATE
 
#define OGDF_DISABLE_WARNING_UNUSED
 
#define OGDF_DISABLE_WARNING_DEPRECATED
 
#if defined(_MSC_VER)
#   undef OGDF_DISABLE_WARNING_PUSH
#   undef OGDF_DISABLE_WARNING_POP
#   undef OGDF_DISABLE_WARNING
 
#   define OGDF_DISABLE_WARNING_PUSH __pragma(warning(push))
#   define OGDF_DISABLE_WARNING_POP __pragma(warning(pop))
#   define OGDF_DISABLE_WARNING(warningNumber) __pragma(warning(disable : warningNumber))
#elif defined(__GNUC__) || defined(__clang__)
#   undef OGDF_DISABLE_WARNING_PUSH
#   undef OGDF_DISABLE_WARNING_POP
#   undef OGDF_DISABLE_WARNING
 
#   define OGDF_DO_PRAGMA(X) _Pragma(#X)
#   define OGDF_DISABLE_WARNING_PUSH OGDF_DO_PRAGMA(GCC diagnostic push)
#   define OGDF_DISABLE_WARNING_POP OGDF_DO_PRAGMA(GCC diagnostic pop)
#   define OGDF_DISABLE_WARNING(warningName) OGDF_DO_PRAGMA(GCC diagnostic ignored warningName)
#endif
 
#if defined(__GNUC__)
#   if defined(__clang__)
#       undef OGDF_DISABLE_WARNING_THROW_TERMINATE
#       define OGDF_DISABLE_WARNING_THROW_TERMINATE OGDF_DISABLE_WARNING("-Wexceptions")
#   else
#       undef OGDF_DISABLE_WARNING_THROW_TERMINATE
#       define OGDF_DISABLE_WARNING_THROW_TERMINATE OGDF_DISABLE_WARNING("-Wterminate")
#   endif
#   undef OGDF_DISABLE_WARNING_UNUSED
#   define OGDF_DISABLE_WARNING_UNUSED OGDF_DISABLE_WARNING("-Wunused")
#   undef OGDF_DISABLE_WARNING_DEPRECATED
#   define OGDF_DISABLE_WARNING_DEPRECATED OGDF_DISABLE_WARNING("-Wdeprecated-declarations")
#elif defined(_MSC_VER)
#   undef OGDF_DISABLE_WARNING_THROW_TERMINATE
#   define OGDF_DISABLE_WARNING_THROW_TERMINATE OGDF_DISABLE_WARNING(4297)
#endif
 
 
#define OGDF_NODISCARD
 
#if OGDF_HAS_CPP_ATTRIBUTE(nodiscard)
#   undef OGDF_NODISCARD
#   define OGDF_NODISCARD [[nodiscard]]
#elif defined(__GNUC__)
#   undef OGDF_NODISCARD
#   define OGDF_NODISCARD __attribute__((warn_unused_result))
#endif
 
 
 
#define OGDF_LIKELY(x) (x)
 
#define OGDF_UNLIKELY(x) (x)
 
#define OGDF_DECL_ALIGN(b)
 
#ifdef _MSC_VER // Visual C++ compiler
#   undef OGDF_DECL_ALIGN
#   define OGDF_DECL_ALIGN(b) __declspec(align(b))
#elif defined(__GNUC__) // GNU gcc compiler (also Intel compiler)
#   undef OGDF_LIKELY
#   define OGDF_LIKELY(x) __builtin_expect((x), 1)
#   undef OGDF_UNLIKELY
#   define OGDF_UNLIKELY(x) __builtin_expect((x), 0)
#   undef OGDF_DECL_ALIGN
#   define OGDF_DECL_ALIGN(b) __attribute__((aligned(b)))
#endif
 
 
#define OGDF_CASE_FALLTHROUGH
#if OGDF_HAS_CPP_ATTRIBUTE(fallthrough)
#   undef OGDF_CASE_FALLTHROUGH
#   define OGDF_CASE_FALLTHROUGH [[fallthrough]]
#elif defined(__GNUC__) && __GNUC__ >= 7
#   undef OGDF_CASE_FALLTHROUGH
#   define OGDF_CASE_FALLTHROUGH __attribute__((fallthrough))
#endif
 
// compiler adaptions
 
#ifdef _MSC_VER
 
#   ifdef OGDF_DLL
// disable useless warnings
// missing dll-interface
 
// warning C4251: 'identifier' : class 'type' needs to have dll-interface to be used by clients of class 'type2'
OGDF_DISABLE_WARNING(4251)
// warning C4275: non-DLL-interface classkey 'identifier' used as base for DLL-interface classkey 'identifier'
OGDF_DISABLE_WARNING(4275)
#   endif
 
// warning C4355: 'this' : used in base member initializer list
OGDF_DISABLE_WARNING(4355)
 
#endif
 
 
class OGDF_EXPORT Configuration {
public:
    enum class System {
        Unknown, 
        Windows, 
        Unix, 
        OSX, 
        STOP
    };
 
    enum class LPSolver {
        None, 
        Clp, 
        Symphony, 
        CPLEX, 
        Gurobi, 
        STOP
    };
 
    enum class MemoryManager {
        PoolTS, 
        PoolNTS, 
        Malloc, 
        STOP
    };
 
    static constexpr System whichSystem() {
#ifdef OGDF_SYSTEM_WINDOWS
        return System::Windows;
#elif defined(OGDF_SYSTEM_OSX)
        return System::OSX;
#elif defined(OGDF_SYSTEM_UNIX)
        return System::Unix;
#else
        return System::Unknown
#endif
    }
 
 
    OGDF_DEPRECATED("OGDF always has LP solver support since 2015.05")
 
    static constexpr bool haveLPSolver() { return true; }
 
    static constexpr LPSolver whichLPSolver() {
#if defined(COIN_OSI_CLP)
        return LPSolver::Clp;
#elif defined(COIN_OSI_SYM)
        return LPSolver::Symphony;
#elif defined(COIN_OSI_CPX)
        return LPSolver::CPLEX;
#elif defined(COIN_OSI_GRB)
        return LPSolver::Gurobi;
#else
#   error "OGDF is compiled without LP solver. Check your build configuration."
#endif
    }
 
 
    OGDF_DEPRECATED("OGDF always has COIN-OR since 2015.05")
 
    static constexpr bool haveCoin() { return true; }
 
 
    OGDF_DEPRECATED("OGDF always has ABACUS since 2015.05")
 
    static constexpr bool haveAbacus() { return true; }
 
    static constexpr MemoryManager whichMemoryManager() {
#if defined(OGDF_MEMORY_POOL_TS)
        return MemoryManager::PoolTS;
#elif defined(OGDF_MEMORY_POOL_NTS)
        return MemoryManager::PoolNTS;
#elif defined(OGDF_MEMORY_MALLOC_TS)
        return MemoryManager::Malloc;
#else
#   error "OGDF is compiled without memory manager. Check your build configuration."
#endif
    }
 
    static const string& toString(System sys);
 
    static const string& toString(LPSolver lps);
 
    static const string& toString(MemoryManager mm);
};
 
inline std::ostream& operator<<(std::ostream& os, Configuration::System sys) {
    os << Configuration::toString(sys);
    return os;
}
 
inline std::ostream& operator<<(std::ostream& os, Configuration::LPSolver lps) {
    os << Configuration::toString(lps);
    return os;
}
 
inline std::ostream& operator<<(std::ostream& os, Configuration::MemoryManager mm) {
    os << Configuration::toString(mm);
    return os;
}
 
}