OperatorSuppliers.h

Go to the documentation of this file.

#ifndef INCLUDE_MOLASSEMBLER_TEMPLE_OPERATOR_SUPPLIERS_H
#define INCLUDE_MOLASSEMBLER_TEMPLE_OPERATOR_SUPPLIERS_H

namespace Scine {
namespace Molassembler {
namespace Temple {

namespace Crtp {

template<typename T>
struct InequalityFromEquality {
  constexpr bool operator != (const InequalityFromEquality<T>& other) const {
    const auto& lhs = static_cast<const T&>(*this);
    const auto& rhs = static_cast<const T&>(other);

    return !(lhs == rhs);
  }
};

template <typename T>
struct AllOperatorsFromLessThan {
  static constexpr const T& derived(const AllOperatorsFromLessThan& base) {
    return static_cast<const T&>(base);
  }

  constexpr bool operator == (const AllOperatorsFromLessThan& other) const {
    const T& lhs = derived(*this);
    const T& rhs = derived(other);
    return !(lhs < rhs) && !(rhs < lhs);
  }

  constexpr bool operator != (const AllOperatorsFromLessThan& other) const {
    const T& lhs = derived(*this);
    const T& rhs = derived(other);
    return (lhs < rhs) || (rhs < lhs);
  }

  constexpr bool operator > (const AllOperatorsFromLessThan& other) const {
    return derived(other) < derived(*this);
  }

  constexpr bool operator <= (const AllOperatorsFromLessThan& other) const {
    return !(derived(other) < derived(*this));
  }

  constexpr bool operator >= (const AllOperatorsFromLessThan& other) const {
    return !(derived(*this) < derived(other));
  }
};

template<typename T>
struct LexicographicComparable {
  static constexpr const T& derived(const LexicographicComparable& base) {
    return static_cast<const T&>(base);
  }

  constexpr bool operator == (const LexicographicComparable& other) const {
    return derived(*this).tie() == derived(other).tie();
  }

  constexpr bool operator != (const LexicographicComparable& other) const {
    return derived(*this).tie() != derived(other).tie();
  }

  constexpr bool operator < (const LexicographicComparable& other) const {
    return derived(*this).tie() < derived(other).tie();
  }

  constexpr bool operator <= (const LexicographicComparable& other) const {
    return derived(*this).tie() <= derived(other).tie();
  }

  constexpr bool operator > (const LexicographicComparable& other) const {
    return derived(*this).tie() > derived(other).tie();
  }

  constexpr bool operator >= (const LexicographicComparable& other) const {
    return derived(*this).tie() >= derived(other).tie();
  }
};

} // namespace Crtp
} // namespace Temple
} // namespace Molassembler
} // namespace Scine

#endif