JComparator.hh

Go to the documentation of this file.

#ifndef __JLANG__JCOMPARATOR__
#define __JLANG__JCOMPARATOR__
 
#include "JLang/JClass.hh"
#include "JLang/JComparison.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JLANG {}
namespace JPP { using namespace JLANG; }
 
namespace JLANG {
 
  /**
   * Template definition of auxiliary class to compare objects.
   * The first template argument refers to the data member or member method and
   * the second template argument to the comparator of the corresponding values.
   */
  template<class JTypename_t, class JComparator_t = JComparison::lt>
  class JComparator;
 
 
  /**
   * Template specialisation of JComparator for comparison between values of data members.
   */
  template<class T, class JResult_t, class JComparator_t>
  class JComparator<JResult_t T::*, JComparator_t> {
  public:    
 
    typedef JResult_t T::*data_member;                    //!< Type definition of data member
    typedef JComparator_t comparator_type;                //!< Type definition of comparator
        
    
    /**
     * Constructor.
     *
     * \param  member       pointer to data member
     * \param  comparator   comparator method
     */
    JComparator(data_member            member,
                const comparator_type& comparator = comparator_type()) :
      __member    (member),
      __comparator(comparator)
    {}
 
 
    /**
     * Compare objets.
     *
     * \param  first        first  object
     * \param  second       second object
     * \return              result of comparison of return values
     */
    bool operator()(const T& first, const T& second) const
    {
      return __comparator(first.*__member, second.*__member);
    }
 
 
    /**
     * Compare objet to value.
     *
     * \param  first        first  object
     * \param  second       second value
     * \return              result of comparison of return values
     */
    bool operator()(const T& first, typename JClass<JResult_t>::argument_type second) const
    {
      return __comparator(first.*__member, second);
    }
 
  protected:
    data_member     __member;
    comparator_type __comparator;
  };
 
 
  /**
   * Template specialisation of JComparator for comparison between return values of member methods.
   */
  template<class T, class JResult_t, class JComparator_t>
  class JComparator<JResult_t (T::*)() const, JComparator_t> {
  public:    
 
    typedef JResult_t (T::*member_method)() const;        //!< Type definition of member method
    typedef JComparator_t comparator_type;                //!< Type definition of comparator
    
    
    /**
     * Constructor.
     *
     * \param  function     pointer to member method
     * \param  comparator   comparator method
     */
    JComparator(member_method          function,
                const comparator_type& comparator = comparator_type()) :
      __function  (function),
      __comparator(comparator)
    {}
 
 
    /**
     * Compare objets.
     *
     * \param  first        first  object
     * \param  second       second object
     * \return              result of comparison of return values
     */
    bool operator()(const T& first, const T& second) const
    {
      return __comparator((first.*__function)(), (second.*__function)());
    }
 
 
    /**
     * Compare objet to value.
     *
     * \param  first        first  object
     * \param  second       second value
     * \return              result of comparison of return values
     */
    bool operator()(const T& first, typename JClass<JResult_t>::argument_type second) const
    {
      return __comparator((first.*__function)(), second);
    }
 
  protected:
    member_method   __function;
    comparator_type __comparator;
  };
 
 
  /**
   * Helper method to create comparator between values of data member.
   *
   * \param  member       pointer to data member
   * \return              comparator between objects
   */
  template<class T, class JResult_t>
  JComparator<JResult_t T::*, JComparison::lt> make_comparator(JResult_t T::*member)
  {
    return JComparator<JResult_t T::*, JComparison::lt>(member, JComparison::lt());
  }
 
 
  /**
   * Helper method to create comparator between values of data member.
   *
   * \param  member       pointer to data member
   * \param  comparator   comparator between values of data members
   * \return              comparator between objects
   */
  template<class T, class JResult_t, class JComparator_t>
  JComparator<JResult_t T::*, JComparator_t> make_comparator(JResult_t T::*member,
                                                             const JComparator_t& comparator)
  {
    return JComparator<JResult_t T::*, JComparator_t>(member, comparator);
  }
 
 
  /**
   * Helper method to create comparator between return values of member method.
   *
   * \param  function     pointer to member method
   * \return              comparator between objects
   */
  template<class T, class JResult_t>
  JComparator<JResult_t (T::*)() const, JComparison::lt> make_comparator(JResult_t (T::*function)() const)
  {
    return JComparator<JResult_t (T::*)() const, JComparison::lt>(function, JComparison::lt());
  }
 
 
  /**
   * Helper method to create comparator between return values of member method.
   *
   * \param  function     pointer to member method
   * \param  comparator   comparator between return values
   * \return              comparator between objects
   */
  template<class T, class JResult_t, class JComparator_t>
  JComparator<JResult_t (T::*)() const, JComparator_t> make_comparator(JResult_t (T::*function)() const,
                                                                       const JComparator_t& comparator)
  {
    return JComparator<JResult_t (T::*)() const, JComparator_t>(function, comparator);
  }
}
 
#endif