basic.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/internal/config.h>
 
 
#define OGDF_ASSERT(expr)
#define OGDF_HEAVY_ASSERT(expr)
 
#ifdef OGDF_DEBUG
#   ifdef OGDF_HEAVY_DEBUG
#       undef OGDF_HEAVY_ASSERT
#       define OGDF_HEAVY_ASSERT(expr) OGDF_ASSERT(expr)
#   endif
#   undef OGDF_ASSERT
#   ifndef OGDF_USE_ASSERT_EXCEPTIONS
#       include <cassert>
#       define OGDF_ASSERT(expr) assert(expr)
#   else
#       include <sstream>
#       include <stdexcept>
 
namespace ogdf {
class AssertionFailed : public std::runtime_error {
    using std::runtime_error::runtime_error;
};
}
 
#       define OGDF_ASSERT(expr)                                                          \
            do {                                                                           \
                if (!(expr)) {                                                             \
                    std::stringstream ogdf_assert_ss;                                      \
                    ogdf_assert_ss << "OGDF assertion `" #expr "' failed at " __FILE__ ":" \
                                   << __LINE__ << "(" << OGDF_FUNCTION_NAME << ")";        \
                    ogdf::get_stacktrace(ogdf_assert_ss);                                  \
                    OGDF_DISABLE_WARNING_PUSH                                              \
                    OGDF_DISABLE_WARNING_THROW_TERMINATE                                   \
                    throw ogdf::AssertionFailed(ogdf_assert_ss.str());                     \
                    OGDF_DISABLE_WARNING_POP                                               \
                }                                                                          \
            } while (false)
#   endif
#endif
 
#define OGDF_IF_DBG(x)
#ifdef OGDF_DEBUG
#   undef OGDF_IF_DBG
#   define OGDF_IF_DBG(x) x
#endif
 
 
// g++ 4.8/4.9 does not have is_trivially_copyable,
// but clang 3.5 (which is also __GNUC__ < 5) has it.
#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 5
#   define OGDF_TRIVIALLY_COPYABLE std::has_trivial_copy_assign
#else
#   define OGDF_TRIVIALLY_COPYABLE std::is_trivially_copyable
#endif
 
OGDF_DISABLE_WARNING_PUSH
OGDF_DISABLE_WARNING_DEPRECATED
#include <algorithm>
OGDF_DISABLE_WARNING_POP
#include <cmath>
#include <cstdint>
#include <ctime>
#include <fstream>
#include <limits>
 
namespace ogdf {
 
OGDF_EXPORT extern bool debugMode;
 
// generally used <algorithm> members
using std::max;
using std::min;
 
class OGDF_EXPORT Initialization {
public:
    Initialization();
    ~Initialization();
};
 
// OGDF_INSTALL is defined only when compiling a dynamic library.
// Whenever this library is used we can safely assume that this header
// file is included beforehand.
// Thus, there will be a static initialization object in the program that uses the library.
#ifndef OGDF_INSTALL
// This has to be in the header file. Being in the cpp file does not
// guarantee that it is constructed (with all linkers).
static Initialization s_ogdfInitializer;
#endif
 
#ifdef OGDF_USE_ASSERT_EXCEPTIONS
OGDF_EXPORT extern void get_stacktrace(std::ostream& stream);
#endif
 
enum class Direction { before, after };
 
 
 
OGDF_EXPORT long unsigned int randomSeed();
 
OGDF_EXPORT void setSeed(int val);
 
 
OGDF_EXPORT int randomNumber(int low, int high);
 
 
OGDF_EXPORT double randomDouble(double low, double high);
 
inline double randomDoubleNormal(double m, double sd) {
    double x1, y1, w;
 
    do {
        double rndVal = randomDouble(0, 1);
        x1 = 2.0 * rndVal - 1.0;
        rndVal = randomDouble(0, 1);
        double x2 = 2.0 * rndVal - 1.0;
        w = x1 * x1 + x2 * x2;
    } while (w >= 1.0);
 
    w = sqrt((-2.0 * log(w)) / w);
    y1 = x1 * w;
 
    return m + y1 * sd;
}
 
 
OGDF_EXPORT double randomDoubleExponential(double beta);
 
 
 
OGDF_EXPORT double usedTime(double& T);
 
OGDF_EXPORT void removeTrailingWhitespace(string& str);
 
OGDF_EXPORT bool equalIgnoreCase(const string& str1, const string& str2);
 
OGDF_EXPORT bool prefixIgnoreCase(const string& prefix, const string& str);
 
 
 
template<typename CONTAINER, typename T>
int searchPos(const CONTAINER& C, const T& x) {
    int pos = 0;
    for (const T& y : C) {
        if (x == y) {
            return pos;
        }
        ++pos;
    }
 
    return -1;
}
 
 
 
template<class E>
class BucketFunc {
public:
    virtual ~BucketFunc() { }
 
    virtual int getBucket(const E& x) = 0;
};
 
}