学步园

/**
  @brief 生成一个比较器(Comparator)，兼键提取(KeyExtractor)类

  使用这个宏生成的比较器可以作用在不同的对象上，只要这些对象有相同名称的成员，
  并且可以作用在类型为成员类型的对象上。

  - 假设：

    - 有 n 个类 class[1], class[2], ... class[n]，都有类型为 MemberType ，名称为 MemberName 的数据成员
    - 那么以下类型的对象可以使用该类相互比较，并且可以从这些对象中提取出 MemberType 类型的键：
        class[1] ... class[n], MemberType, 以及所有这些类型的任意级别的指针

  @param ComparatorName 比较器类的名字
  @param MemberType     要比较的对象的成员类型
  @param MemberName     要比较的对象的成员名字，也可以是一个成员函数调用，
                        前面必须加 '.' 或者 '->', 加 '->' 只是为用于 smart_ptr/iterator/proxy 等重载 '->' 的对象
                        当用于裸指针时，仍使用 '.'，这意味着裸指针和 smart_ptr/iterator/proxy
                        不能使用同一个生成的 Comparator，虽然裸指针的语法和它们都相同
  @param ComparePred    比较准则，这个比较准则将被应用到 XXXX MemberName

  @note
    - 这个类不是从 ComparePred 继承，为的是可以允许 ComparePred 是个函数，
      但这样（不继承）阻止了编译器进行空类优化
    - 不在内部使用 const MemberType&, 而是直接使用 MemberType, 
      是为了允许 MemberName 是一个函数时，返回一个即时计算出来的 Key；
      - 当为了效率需要使用引用时，将 const MemberType& 作为 MemberType 传进来
    - 当 MemberType 是个指针时，将 Type* 作为 MemberType ，而非 const Type*，即使 MemberType 真的是 const Type*
    - 注意 C++ 参数推导机制：
    @code
      template<T> void f(const T& x) { } // f1
      template<T> void f(const T* x) { } // f2
      template<T> void g(const T& x) { } // g1
      template<T> void g(const T* x) { } // g2
      template<T> void g(      T& x) { } // g3
      template<T> void g(      T* x) { } // g4
      void foo()
      {
         int a;
         const int b;
         f(&a); // call f1, T was deduced as int*, and then convert to 'const int*&', so match f1, not f2
         f(&b); // call f2, T was deduced as int
         g(&a); // call g4, T was deduced as int
         g(&b); // call g2, T was deduced as int
      }
    @endcode
      在上述代码已经表现得比较明白了，这就是要生成四个不同 deref 版本的原因
    - 为了配合上述机制，传入的 MemberType 不要有任何 const 修饰符
 */
#define SAME_NAME_MEMBER_COMPARATOR_EX(ComparatorName, MemberType, MemberName, ComparePred) /
class ComparatorName                                        /
{                                                           /
    ComparePred m_comp;                                     /
public:                                                     /
    typedef bool        result_type;                        /
    typedef MemberType  key_type;                           /
    typedef boost::integral_constant<bool,                  /
        febird::HasTriCompare<ComparePred>::value           /
    > has_tri_compare;                                      /
                                                            /
    ComparatorName()  {}                                    /
    ComparatorName(const ComparePred& rhs)                  /
        : m_comp(rhs) {}                                    /
                                                            /
    template<class T>const T&deref(T*x)const{return*x;}     /
    template<class T>const T&deref(T&x)const{return x;}     /
    template<class T>const T&deref(const T*x)const{return*x;}/
    template<class T>const T&deref(const T&x)const{return x;}/
                                                            /
    const MemberType operator()(const MemberType x)const{return x;} /
    template<class T>const MemberType operator()(const T&x)const{return deref(x)MemberName;}/
                                                            /
    template<class Tx, class Ty>                            /
    bool operator()(const Tx&x, const Ty&y) const           /
    {                                                       /
        return m_comp((*this)(x),(*this)(y));               /
    }                                                       /
    template<class Tx, class Ty>                            /
    int compare(const Tx&x, const Ty&y) const               /
    {                                                       /
        return m_comp.compare((*this)(x),(*this)(y));       /
    }                                                       /
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#endif

// #define SAME_NAME_MEMBER_COMPARATOR_EX(ComparatorName, MemberType, MemberName, ComparePred)  /
// SAME_NAME_MEMBER_COMPARATOR_EX_NO_TRAITS(ComparatorName, MemberType, MemberName, ComparePred)/
// BOOST_TT_AUX_BOOL_TRAIT_SPEC1(HasTriCompare, ComparatorName, HasTriCompare<ComparePred>::value)

//! note@ if MemberType must not be a reference, neither const nor non-const
#define SAME_NAME_MEMBER_COMPARATOR(ComparatorName, MemberType, MemberName) /
    SAME_NAME_MEMBER_COMPARATOR_EX(ComparatorName, MemberType, MemberName, std::less<MemberType>)