JMultiComparable.hh

Go to the documentation of this file.

#ifndef __JLANG__JMULTICOMPARABLE__
#define __JLANG__JMULTICOMPARABLE__

#include "JLang/JNullType.hh"
#include "JLang/JTypeList.hh"
#include "JLang/JType.hh"


/**
 * \author mdejong
 */

namespace JLANG {}
namespace JPP { using namespace JLANG; }

namespace JLANG {

  
  /**
   * Template definition of auxiliary base class for composite data structures
   * composed of base classes with comparisons capabilities.
   *
   * Each data type <tt>T</tt> in the type list should have the corresponding operator:
   * <pre>
   *       bool operator<(const T&, const T& second);
   * </pre>
   * This class uses in-class friend operators (see Barton-Nackman trick).
   *
   * This class implements the operators <tt> < > <= >= == != </tt>.
   */
  template<class JClass_t, class JTypelist_t>
  struct JMultiComparable {
  protected:
    /**
     * Less than method for composite data types.
     *
     * \param  first        first  object
     * \param  second       second object
     * \param  type         type
     * \return              true if first object is less than second object; else false
     */
    template<class JHead_t, class JTail_t>
    static inline bool lt(const JClass_t& first,
                          const JClass_t& second,
                          const JType<JTypeList<JHead_t, JTail_t> >& type)
    {
      if      (static_cast<const JHead_t&>(first)  <
               static_cast<const JHead_t&>(second))
        return true;
      else if (static_cast<const JHead_t&>(second)  <
               static_cast<const JHead_t&>(first))
        return false;
      else
        return lt(first, second, JType<JTail_t>());
    }
    

    /**
     * Less than method for composite data types.
     *
     * \param  first        first  object
     * \param  second       second object
     * \param  type         type
     * \return              true if first object is less than second object; else false
     */
    template<class JHead_t>
    static inline bool lt(const JClass_t& first,
                          const JClass_t& second,
                          const JType<JTypeList<JHead_t, JNullType> >& type)
    {
      return (static_cast<const JHead_t&>(first) <
              static_cast<const JHead_t&>(second));
    }

  public:
    /**
     * Less than operator.
     *
     * \param  first        first  object
     * \param  second       second object
     * \return              true if first object is less than second object; else false
     */
    friend bool operator<(const JClass_t& first,
                          const JClass_t& second)
    { 
      return lt(first, second, JType<JTypelist_t>());
    }

 
    /**
     * Greater than operator.
     *
     * \param  first        first  object
     * \param  second       second object
     * \return              true if first object is greater than second object; else false
     */
    friend bool operator>(const JClass_t& first,
                          const JClass_t& second)
    { 
      return lt(second, first, JType<JTypelist_t>());
    }
    

    /**
     * Less than or equal operator.
     *
     * \param  first        first  object
     * \param  second       second object
     * \return              true if first object is less than or equal to second object; else false
     */
    friend bool operator<=(const JClass_t& first,
                           const JClass_t& second)
    { 
      return !lt(second, first, JType<JTypelist_t>());
    }
    

    /**
     * Greater than or equal operator.
     *
     * \param  first        first  object
     * \param  second       second object
     * \return              true if first object is greater than or equal to second object; else false
     */
    friend bool operator>=(const JClass_t& first,
                           const JClass_t& second)
    { 
      return !lt(first, second, JType<JTypelist_t>());
    }
    

    /**
     * Equal operator.
     *
     * \param  first        first  object
     * \param  second       second object
     * \return              true if two objects are equal; else false
     */
    friend bool operator==(const JClass_t& first,
                           const JClass_t& second)
    { 
      return (!lt(first, second, JType<JTypelist_t>()) &&
              !lt(second, first, JType<JTypelist_t>()));
    }


    /**
     * Not equal operator.
     *
     * \param  first        first  object
     * \param  second       second object
     * \return              true if two objects are not equal; else false
     */
    friend bool operator!=(const JClass_t& first,
                           const JClass_t& second)
    {
      return (lt(first, second, JType<JTypelist_t>()) ||
              lt(second, first, JType<JTypelist_t>()));
    }
  };
}

#endif