comparer.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/exceptions.h>
 
#include <functional>
 
namespace ogdf {
template<typename E>
class StdComparer;
template<typename ELEM, typename NUM, bool ascending = true>
struct GenericComparer;
 
 
template<typename E>
class StdComparer {
public:
    static bool less(const E& x, const E& y) { OGDF_THROW(NoStdComparerException); }
 
    static bool leq(const E& x, const E& y) { OGDF_THROW(NoStdComparerException); }
 
    static bool greater(const E& x, const E& y) { OGDF_THROW(NoStdComparerException); }
 
    static bool geq(const E& x, const E& y) { OGDF_THROW(NoStdComparerException); }
 
    static bool equal(const E& x, const E& y) { OGDF_THROW(NoStdComparerException); }
};
 
 
#define OGDF_STD_COMPARER(type)                                             \
    template<>                                                              \
    class StdComparer<type> {                                               \
    public:                                                                 \
        static bool less(const type& x, const type& y) { return x < y; }    \
        static bool leq(const type& x, const type& y) { return x <= y; }    \
        static bool greater(const type& x, const type& y) { return x > y; } \
        static bool geq(const type& x, const type& y) { return x >= y; }    \
        static bool equal(const type& x, const type& y) { return x == y; }  \
    };
 
OGDF_STD_COMPARER(short)
OGDF_STD_COMPARER(int)
OGDF_STD_COMPARER(float)
OGDF_STD_COMPARER(double)
 
 
template<>
class StdComparer<bool> {
public:
    static bool less(const bool& x, const bool& y) { return !x && y; }
 
    static bool leq(const bool& x, const bool& y) { return !x || y; }
 
    static bool greater(const bool& x, const bool& y) { return x && !y; }
 
    static bool geq(const bool& x, const bool& y) { return x || !y; }
 
    static bool equal(const bool& x, const bool& y) { return x == y; }
};
 
 
template<class CONTENTTYPE, class STATICCONTENTCOMPARER = StdComparer<CONTENTTYPE>>
class TargetComparer {
    using CONTENTPOINTER = CONTENTTYPE*;
 
public:
    static bool less(const CONTENTPOINTER& x, const CONTENTPOINTER& y) {
        return STATICCONTENTCOMPARER::less(*x, *y);
    }
 
    static bool leq(const CONTENTPOINTER& x, const CONTENTPOINTER& y) {
        return STATICCONTENTCOMPARER::leq(*x, *y);
    }
 
    static bool greater(const CONTENTPOINTER& x, const CONTENTPOINTER& y) {
        return STATICCONTENTCOMPARER::greater(*x, *y);
    }
 
    static bool geq(const CONTENTPOINTER& x, const CONTENTPOINTER& y) {
        return STATICCONTENTCOMPARER::geq(*x, *y);
    }
 
    static bool equal(const CONTENTPOINTER& x, const CONTENTPOINTER& y) {
        return STATICCONTENTCOMPARER::equal(*x, *y);
    }
};
 
 
#define OGDF_AUGMENT_COMPARER(type)                                                \
public:                                                                            \
    bool less(const type& x, const type& y) const { return compare(x, y) < 0; }    \
    bool leq(const type& x, const type& y) const { return compare(x, y) <= 0; }    \
    bool greater(const type& x, const type& y) const { return compare(x, y) > 0; } \
    bool geq(const type& x, const type& y) const { return compare(x, y) >= 0; }    \
    bool equal(const type& x, const type& y) const { return compare(x, y) == 0; }
 
 
#define OGDF_AUGMENT_STATICCOMPARER(type)                                           \
public:                                                                             \
    static bool less(const type& x, const type& y) { return compare(x, y) < 0; }    \
    static bool leq(const type& x, const type& y) { return compare(x, y) <= 0; }    \
    static bool greater(const type& x, const type& y) { return compare(x, y) > 0; } \
    static bool geq(const type& x, const type& y) { return compare(x, y) >= 0; }    \
    static bool equal(const type& x, const type& y) { return compare(x, y) == 0; }
 
 
template<class E>
class VComparer {
public:
    VComparer() { }
 
    virtual ~VComparer() { }
 
 
    virtual int compare(const E& x, const E& y) const = 0;
 
    virtual bool less(const E& x, const E& y) const { return compare(x, y) < 0; }
 
    virtual bool leq(const E& x, const E& y) const { return compare(x, y) <= 0; }
 
    virtual bool greater(const E& x, const E& y) const { return compare(x, y) > 0; }
 
    virtual bool geq(const E& x, const E& y) const { return compare(x, y) >= 0; }
 
    virtual bool equal(const E& x, const E& y) const { return compare(x, y) == 0; }
};
 
 
template<class X, class Priority = double>
class Prioritized {
    X x;
    Priority p;
 
public:
    Prioritized() : x(0), p(0) { }
 
    Prioritized(X xt, Priority pt) : x(xt), p(pt) { }
 
    Prioritized(const Prioritized& P) = default;
 
    Priority priority() const { return p; }
 
    X item() const { return x; }
 
    void setPriority(Priority pp) { p = pp; }
 
    void setItem(X item) { x = item; }
 
    Prioritized& operator=(const Prioritized<X, Priority>& P) = default;
 
    bool operator<(const Prioritized<X, Priority>& P) const { return p < P.p; }
 
    bool operator<=(const Prioritized<X, Priority>& P) const { return p <= P.p; }
 
    bool operator>(const Prioritized<X, Priority>& P) const { return p > P.p; }
 
    bool operator>=(const Prioritized<X, Priority>& P) const { return p >= P.p; }
 
    bool operator==(const Prioritized<X, Priority>& P) const { return p == P.p; }
 
    bool operator!=(const Prioritized<X, Priority>& P) const { return p != P.p; }
};
 
template<class X, class Priority>
class StdComparer<Prioritized<X, Priority>> {
public:
    static bool less(const Prioritized<X, Priority>& x, const Prioritized<X, Priority>& y) {
        return x < y;
    }
 
    static bool leq(const Prioritized<X, Priority>& x, const Prioritized<X, Priority>& y) {
        return x <= y;
    }
 
    static bool greater(const Prioritized<X, Priority>& x, const Prioritized<X, Priority>& y) {
        return x > y;
    }
 
    static bool geq(const Prioritized<X, Priority>& x, const Prioritized<X, Priority>& y) {
        return x >= y;
    }
 
    static bool equal(const Prioritized<X, Priority>& x, const Prioritized<X, Priority>& y) {
        return x == y;
    }
};
 
template<typename TYPE, class COMPARER = StdComparer<TYPE>>
class StlLess {
public:
    bool operator()(const TYPE& x, const TYPE& y) const { return COMPARER::less(x, y); }
};
 
template<typename TYPE, class COMPARER = StdComparer<TYPE>>
class StlGreater {
public:
    bool operator()(const TYPE& x, const TYPE& y) const { return COMPARER::greater(x, y); }
};
 
template<typename ELEM, typename NUM, bool ascending>
struct GenericComparer {
    using OrderFunction = std::function<NUM(const ELEM&)>;
 
    GenericComparer(const OrderFunction& mapToValue) : m_mapToValue(mapToValue) { }
 
    int compare(const ELEM& x, const ELEM& y) const {
        NUM a = m_mapToValue(x);
        NUM b = m_mapToValue(y);
 
        return a == b ? 0 : ((a < b) == ascending ? -1 : 1);
    }
 
    OGDF_AUGMENT_COMPARER(ELEM)
 
private:
    const OrderFunction m_mapToValue;
};
 
#define OGDF_DECLARE_COMPARER(NAME, TYPE, NUMBER, GET_X_ATTR)                   \
    struct NAME : public GenericComparer<TYPE, NUMBER> {                        \
        NAME() : GenericComparer([&](const TYPE& x) { return GET_X_ATTR; }) { } \
    }
 
}