icomparer.h

 
#ifndef _IComparer_h_
#define _IComparer_h_
 
#include <detail.h>
#include <system/object.h>
#include <system/icomparable.h>
#include <defines.h>
 
namespace System {
namespace Collections {
namespace Generic {
 
template<typename T>
class ASPOSECPP_SHARED_CLASS IComparer : virtual public Object
{
    RTTI_INFO_TEMPLATE_CLASS(System::Collections::Generic::IComparer<T>, System::BaseTypesInfo<System::Object>);
public:
 
#ifdef ASPOSE_COMPARE_BY_REF
    typedef const T& args_type;
#else
    typedef T args_type;
#endif
    virtual int Compare(args_type x, args_type y) const = 0;
};
 
template<class T>
struct ASPOSECPP_SHARED_CLASS ComparerAdapter
{
    ComparerAdapter()
    {}
    ComparerAdapter(const SharedPtr<System::Collections::Generic::IComparer<T> >& comparator)
        : m_comparator(comparator)
    {}
 
    void set_Comparator(const SharedPtr<IComparer<T> >& comparator)
    {
        m_comparator = comparator;
    }
 
    template <typename Q = T>
    typename std::enable_if<detail::has_operator_less<Q>::value, bool>::type operator()(const Q &x, const Q &y) const
    {
        // should be "<" operation !!! Not "<="
        return m_comparator ? m_comparator->Compare(x, y) < 0 : (x < y);
    }
 
    template <typename Q = T>
    typename std::enable_if<!detail::has_operator_less<Q>::value, bool>::type operator()(const Q &x, const Q &y) const
    {
        return m_comparator ? m_comparator->Compare(x, y) < 0 : false;
    }
 
private:
    SharedPtr<System::Collections::Generic::IComparer<T> > m_comparator;
};
    
template<class T, typename = void>
class ASPOSECPP_SHARED_CLASS DefaultComparer : public IComparer<T>
{
public:
    using BaseType = IComparer<T>;
    using ThisType = DefaultComparer<T>;
 
private:
    RTTI_INFO_TEMPLATE_CLASS(ThisType, System::BaseTypesInfo<BaseType>);
 
public:
    virtual int Compare(typename ThisType::args_type x, typename ThisType::args_type y) const override
    {
        if (x == y)
            return 0;
 
        if (x < y)
            return -1;
 
        return 1;
    }
};
 
template <typename T>
class ASPOSECPP_SHARED_CLASS DefaultComparer<T, typename std::enable_if<std::is_base_of<IComparable<T>, T>::value>::type>
    : public IComparer<T>
{
public:
    using BaseType = IComparer<T>;
    using ThisType = DefaultComparer<T>;
 
private:
    RTTI_INFO_TEMPLATE_CLASS(ThisType, System::BaseTypesInfo<BaseType>);
 
public:
    virtual int Compare(typename ThisType::args_type x, typename ThisType::args_type y) const override
    {
        return const_cast<T&>(x).CompareTo(const_cast<T&>(y));
    }
};
 
template<class T>
class ASPOSECPP_SHARED_CLASS Comparer : public IComparer<T>
{
public:
    using BaseType = IComparer<T>;
    using ThisType = Comparer<T>;
 
private:
    RTTI_INFO_TEMPLATE_CLASS(ThisType, System::BaseTypesInfo<BaseType>);
 
protected:
    Comparer()
    {
    }
 
public:
    static SharedPtr<IComparer<T>> get_Default()
    {
        static SharedPtr<IComparer<T>> s_default_comparer = System::MakeObject<DefaultComparer<T>>();
        return s_default_comparer;
    }
};
 
}}}
 
#endif