icommon.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_INTERFACE_ICOMMON_HPP__
#define NEFORCE_CORE_INTERFACE_ICOMMON_HPP__

 
#include "NeForce/core/functional/hash.hpp"
NEFORCE_BEGIN_NAMESPACE__


template <typename T>
struct ihashable {
private:
    constexpr const T& derived() const noexcept { return static_cast<const T&>(*this); }
 
public:
    NEFORCE_NODISCARD constexpr size_t to_ihash() const noexcept(noexcept(derived().to_hash())) {
        return derived().to_hash();
    }
};
 // CRTPInterfaces


template <typename T>
struct hash<T, enable_if_t<is_base_of<ihashable<T>, T>::value>> {
    NEFORCE_NODISCARD constexpr size_t operator()(const T& obj) const noexcept(noexcept(obj.to_ihash())) {
        return obj.to_ihash();
    }
};
 // HashPrimary


template <typename T>
struct icomparable {
private:
    constexpr const T& derived() const noexcept { return static_cast<const T&>(*this); }
 
public:
    NEFORCE_NODISCARD constexpr bool operator==(const T& rhs) const noexcept(noexcept(derived().equal_to(rhs))) {
        return derived().equal_to(rhs);
    }

    NEFORCE_NODISCARD constexpr bool operator!=(const T& rhs) const noexcept(noexcept(!(derived().equal_to(rhs)))) {
        return !(derived().equal_to(rhs));
    }

    NEFORCE_NODISCARD constexpr bool operator<(const T& rhs) const noexcept(noexcept(derived().less_than(rhs))) {
        return derived().less_than(rhs);
    }

    NEFORCE_NODISCARD constexpr bool operator>(const T& rhs) const noexcept(noexcept(rhs.less_than(derived()))) {
        return rhs.less_than(derived());
    }

    NEFORCE_NODISCARD constexpr bool operator<=(const T& rhs) const noexcept(noexcept(!(rhs.less_than(derived())))) {
        return !(rhs.less_than(derived()));
    }

    NEFORCE_NODISCARD constexpr bool operator>=(const T& rhs) const noexcept(noexcept(!(derived().less_than(rhs)))) {
        return !(derived().less_than(rhs));
    }
};
 
template <typename T, enable_if_t<is_base_of_v<icomparable<T>, T>, int> = 0>
NEFORCE_NODISCARD constexpr bool operator==(const T& lhs, const T& rhs) {
    return lhs.equal_to(rhs);
}
 
template <typename T, enable_if_t<is_base_of_v<icomparable<T>, T>, int> = 0>
NEFORCE_NODISCARD constexpr bool operator!=(const T& lhs, const T& rhs) {
    return !(lhs.equal_to(rhs));
}
 
template <typename T, enable_if_t<is_base_of_v<icomparable<T>, T>, int> = 0>
NEFORCE_NODISCARD constexpr bool operator<(const T& lhs, const T& rhs) {
    return lhs.less_than(rhs);
}
 
template <typename T, enable_if_t<is_base_of_v<icomparable<T>, T>, int> = 0>
NEFORCE_NODISCARD constexpr bool operator>(const T& lhs, const T& rhs) {
    return rhs.less_than(lhs);
}
 
template <typename T, enable_if_t<is_base_of_v<icomparable<T>, T>, int> = 0>
NEFORCE_NODISCARD constexpr bool operator<=(const T& lhs, const T& rhs) {
    return !(rhs.less_than(lhs));
}
 
template <typename T, enable_if_t<is_base_of_v<icomparable<T>, T>, int> = 0>
NEFORCE_NODISCARD constexpr bool operator>=(const T& lhs, const T& rhs) {
    return !(lhs.less_than(rhs));
}
 

template <typename T>
struct icommon : public icomparable<T>, public ihashable<T> {};
 // CRTPInterfaces
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_INTERFACE_ICOMMON_HPP__