IComparable.h

#pragma once
 
#include <type_traits>
 
namespace sw
{
    template <
        typename TDerived,
        typename TOther = const TDerived &>
    class IEqualityComparable
    {
    public:
        bool Equals(TOther other) const
        {
            static_assert(
                !std::is_same<
                    decltype(&IEqualityComparable<TDerived, TOther>::Equals),
                    decltype(&TDerived::Equals)>::value,
                "Derived class must implement Equals method.");
 
            return static_cast<const TDerived *>(this)->Equals(other);
        }
 
        bool operator==(TOther other) const
        {
            return Equals(other);
        }
 
        bool operator!=(TOther other) const
        {
            return !Equals(other);
        }
    };
 
    template <
        typename TDerived,
        typename TOther = const TDerived &>
    class IComparable : public IEqualityComparable<TDerived, TOther>
    {
    public:
        int CompareTo(TOther other) const
        {
            static_assert(
                !std::is_same<
                    decltype(&IComparable<TDerived, TOther>::CompareTo),
                    decltype(&TDerived::CompareTo)>::value,
                "Derived class must implement CompareTo method.");
 
            return static_cast<const TDerived *>(this)->CompareTo(other);
        }
 
        bool Equals(TOther other) const
        {
            return CompareTo(other) == 0;
        }
 
        bool operator<(TOther other) const
        {
            return CompareTo(other) < 0;
        }
 
        bool operator<=(TOther other) const
        {
            return CompareTo(other) <= 0;
        }
 
        bool operator>(TOther other) const
        {
            return CompareTo(other) > 0;
        }
 
        bool operator>=(TOther other) const
        {
            return CompareTo(other) >= 0;
        }
    };
}