cmp.h

 
#include <cstring>
#include <functional>
 
#ifndef BF_P4C_LIB_CMP_H_
#define BF_P4C_LIB_CMP_H_
 
 
#define OPERATOR(op, Op)                                                                 \
    struct Op {                                                                          \
        bool operator()(const T *left, const T *right) const { return op(left, right); } \
    };                                                                                   \
    static bool op(const T *left, const T *right)
 
template <class T>
class LiftEqual {
 public:
    virtual bool operator==(const T &) const = 0;
 
    bool operator!=(const T &other) const { return !(operator==(other)); }
 
    OPERATOR(equal, Equal) {
        if (left != right && left && right) return *left == *right;
        return left == right;
    }
 
    OPERATOR(not_equal, NotEqual) { return !equal(left, right); }
};
 
template <class T>
class LiftLess {
 public:
    virtual bool operator<(const T &) const = 0;
 
    bool operator==(const T &other) const { return !operator!=(other); }
 
    bool operator!=(const T &other) const { return operator<(other) || operator>(other); }
 
    bool operator>(const T &other) const { return other.operator<(*dynamic_cast<const T *>(this)); }
 
    bool operator<=(const T &other) const { return !operator>(other); }
    bool operator>=(const T &other) const { return !(operator<(other)); }
 
    OPERATOR(not_equal, NotEqual) { return less(left, right) || greater(left, right); }
 
    OPERATOR(less, Less) {
        if (left != right && left && right) return *left < *right;
        return left < right;
    }
 
    OPERATOR(equal, Equal) { return !not_equal(left, right); }
    OPERATOR(greater, Greater) { return less(right, left); }
    OPERATOR(less_equal, LessEqual) { return !greater(left, right); }
    OPERATOR(greater_equal, GreaterEqual) { return !less(left, right); }
};
 
template <class T>
class LiftCompare : public LiftEqual<T>, public LiftLess<T> {
 public:
    bool operator!=(const T &other) const { return LiftEqual<T>::operator!=(other); }
 
    OPERATOR(equal, Equal) { return LiftEqual<T>::equal(left, right); }
 
    OPERATOR(not_equal, NotEqual) { return LiftEqual<T>::not_equal(left, right); }
};
 
template <class T>
class ByNameLess {
 public:
    bool operator()(const T &a, const T &b) const {
        return std::strcmp(a.getName().name, b.getName().name) < 0;
    }
 
    bool operator()(const T *a, const T *b) const {
        // note: std::less is guaranteed to be defined for pointers, operator < is not
        return a && b ? (*this)(*a, *b) : std::less<T *>()(a, b);
    }
};
 
template <class A, class B, class AComp = std::less<A>, class BCmp = std::less<B>>
class PairLess {
 public:
    using Pair = std::pair<A, B>;
    bool operator()(const Pair &a, const Pair &b) const {
        AComp acmp;
        if (acmp(a.first, b.first)) return true;
        // !(a < b) && !(b < a) => a == b
        if (!acmp(b.first, a.first)) return BCmp()(a.second, b.second);
        return false;
    }
};
#endif /* BF_P4C_LIB_CMP_H_ */