iequality_comparer.h

 
#ifndef _iequality_comparer_h_
#define _iequality_comparer_h_
 
#include "system/object.h"
#include <system/details/equality_helper.h>
 
namespace System { namespace Collections { namespace Generic {
 
template<typename T>
class ABSTRACT IEqualityComparer: virtual public Object
{
public:
    RTTI_INFO_TEMPLATE_CLASS(System::Collections::Generic::IEqualityComparer<T>, System::BaseTypesInfo<System::Object>);
public:
    virtual bool Equals(T x, T y) const = 0;
    virtual int GetHashCode(T obj) const = 0;
};
 
template<class T>
struct ASPOSECPP_SHARED_CLASS EqualityComparerAdapter
{
    EqualityComparerAdapter()
    {}
    EqualityComparerAdapter(const SharedPtr<IEqualityComparer<T>>& comparator)
        : m_comparator(comparator)
    {}
 
    void set_EqualityComparator(const SharedPtr<IEqualityComparer<T>>& comparator)
    {
        m_comparator = comparator;
    }
 
    bool operator()(const T &x, const T &y) const
    {
        if( m_comparator )
            return m_comparator->Equals(x, y);
 
        return System::Details::AreEqual(x, y);
    }
 
private:
    SharedPtr<IEqualityComparer<T>> m_comparator;
};
 
template <typename T, class Enable = void>
struct ASPOSECPP_SHARED_CLASS DictionaryHashSelector
{
    using type = std::hash<T>;
};
 
template <typename T>
struct ASPOSECPP_SHARED_CLASS DictionaryHashSelector<T, typename std::enable_if<System::detail::has_method_gethashcode<T>::value>::type>
{
    struct type
    {
        using argument_type = const T&;
        using result_type = std::size_t;
        std::size_t operator ()(argument_type obj) const
        {
            return static_cast<std::size_t>(obj.GetHashCode());
        }
    };
};
 
template <typename T>
struct ASPOSECPP_SHARED_CLASS DictionaryHashSelector<T, typename std::enable_if<System::detail::has_ref_method_gethashcode<T>::value && !System::detail::has_method_gethashcode<T>::value>::type>
{
    struct type
    {
        using argument_type = const T&;
        using result_type = std::size_t;
        template<typename K>
        std::size_t operator ()(const System::SharedPtr<K>& obj) const
        {
            if (obj)
            {
                return obj->GetHashCode();
            }
            return 0;
        }
    };
};
 
 
template <typename T>
struct ASPOSECPP_SHARED_CLASS DictionaryHashSelector<T, typename std::enable_if<std::is_enum<T>::value>::type>
{
    struct type
    {
        using argument_type = const T&;
        using result_type = std::size_t;
        std::size_t operator ()(argument_type enum_) const
        {
            return static_cast<std::size_t>(enum_);
        }
    };
};
 
template<typename T>
struct ASPOSECPP_SHARED_CLASS EqualityComparerHashAdapter
{
    EqualityComparerHashAdapter()
    {}
    EqualityComparerHashAdapter(const SharedPtr<IEqualityComparer<T>>& comparator)
        : m_comparator(comparator)
    {}
    void set_EqualityComparator(const SharedPtr<IEqualityComparer<T>>& comparator)
    {
        m_comparator = comparator;
    }
    std::size_t operator ()(const T &x) const
    {
        if (m_comparator)
            return static_cast<std::size_t>(m_comparator->GetHashCode(x));
 
        typename DictionaryHashSelector<T>::type hash_selector;
 
        return hash_selector(x);
    }
 
private:
    SharedPtr<IEqualityComparer<T>> m_comparator;
};
 
}
 
class ABSTRACT IEqualityComparer : virtual public Object
{
public:
    RTTI_INFO_TEMPLATE_CLASS(System::Collections::IEqualityComparer, System::BaseTypesInfo<System::Object>);
 
public:
    virtual bool Equals(const SharedPtr<Object>& x, const SharedPtr<Object>& y) const = 0;
    virtual int GetHashCode(const SharedPtr<Object>& obj) const = 0;
};
 
}}
 
#endif // _IEnumerator_h_