JTuple.hh

Go to the documentation of this file.

#ifndef __JTOOLS__JTUPLE__
#define __JTOOLS__JTUPLE__
 
#include <istream>
#include <ostream>
#include <stdarg.h>
 
#include "JLang/JTypeList.hh"
#include "JLang/JNullType.hh"
#include "JLang/JClass.hh"
#include "JLang/JComparable.hh"
#include "JLang/JType.hh"
#include "JLang/JNumber.hh"
#include "JMath/JMath.hh"
#include "JIO/JSerialisable.hh"
 
 
/**
 * \file
 * Data structure based on type list.
 * \author mdejong
 */
namespace JTOOLS {}
namespace JPP { using namespace JTOOLS; }
 
namespace JTOOLS {
 
  using JLANG::JTypeList;
  using JLANG::JTYPELIST;
  using JLANG::JNullType;
  using JLANG::JClass;
  using JLANG::JType;
  using JLANG::JNumber;
  using JLANG::for_each;
  using JMATH::JMath;
  using JLANG::JComparable;
  using JIO::JReader;
  using JIO::JWriter;
 
 
  /**
   * Template data structure.
   */
  template<class T>
  struct JTuple :
    public JMath      < JTuple<T> >,
    public JComparable< JTuple<T> >
  {
 
    typedef JTypeList<T>  typelist;
 
    /**
     * Default constructor.
     */
    JTuple()
    {}
 
 
    /**
     * Constructor.
     *
     * \param   __first        first
     */
    JTuple(typename JClass<T>::argument_type __first) :
      first(__first)
    {}
 
 
    /**
     * Negate tuple.
     *
     * \return                 this tuple
     */
    JTuple& negate()
    {
      first = -first;
 
      return *this;
    }
 
 
    /**
     * Add tuple.
     *
     * \param  tuple           tuple
     * \return                 this tuple
     */
    JTuple& add(const JTuple& tuple)
    {
      first += tuple.first;
 
      return *this;
    }
 
 
    /**
     * Subtract tuple.
     *
     * \param  tuple           tuple
     * \return                 this tuple
     */
    JTuple& sub(const JTuple& tuple)
    {
      first -= tuple.first;
 
      return *this;
    }
 
 
    /**
     * Scale tuple.
     *
     * \param  factor          multiplication factor
     * \return                 this tuple
     */
    JTuple& mul(const double factor)
    {
      first *= factor;
 
      return *this;
    }
 
 
    /**
     * Scale tuple.
     *
     * \param  factor          division factor
     * \return                 this tuple
     */
    JTuple& div(const double factor)
    {
      first /= factor;
 
      return *this;
    }
 
 
    /**
     * Compare tuple.
     *
     * \param  tuple           tuple
     * \return                 true if this tuple less than given tuple; else false
     */
    bool less(const JTuple& tuple) const
    {
      return first < tuple.first;
    }
 
 
    /**
     * Initialise values.
     *
     * \param  ap              argument list
     */
    void valueOf(va_list& ap)
    {
      first  = va_arg(ap, T);
    }
 
 
    /**
     * Read tuple from input.
     *
     * \param  in              input stream
     * \param  tuple           tuple
     * \return                 input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JTuple& tuple)
    {
      return in >> tuple.first;
    }
 
 
    /**
     * Write tuple to output.
     *
     * \param  out             output stream
     * \param  tuple           tuple
     * \return                 output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JTuple& tuple)
    {
      return out << tuple.first;
    }
 
 
    /**
     * Read tuple from input.
     *
     * \param  in              reader
     * \param  tuple           tuple
     * \return                 reader
     */
    friend inline JReader& operator>>(JReader& in, JTuple& tuple)
    {
      return in >> tuple.first;
    }
 
 
    /**
     * Write tuple to output.
     *
     * \param  out             writer
     * \param  tuple           tuple
     * \return                 writer
     */
    friend inline JWriter& operator<<(JWriter& out, const JTuple& tuple)
    {
      return out << tuple.first;
    }
 
 
    T first;
  };
  
 
 
  /**
   * Template specialisation of JTuple for multiple data types.
   */
  template<class JHead_t, class JTail_t>
  struct JTuple< JTypeList<JHead_t, JTail_t> > :
    public JMath      < JTuple< JTypeList<JHead_t, JTail_t> > >,
    public JComparable< JTuple< JTypeList<JHead_t, JTail_t> > >
  {
    
    typedef JTypeList<JHead_t, JTail_t>  typelist;
 
 
    /**
     * Default constructor.
     */
    JTuple()
    {}
 
 
    /**
     * Constructor.
     *
     * \param   __first        first
     * \param   __second       second
     */
    JTuple(typename JClass<JHead_t>::argument_type __first, const JTuple<JTail_t>& __second) :
      first (__first),
      second(__second)
    {}
 
 
    /**
     * Initialise constructor.
     *
     * \param  x               comma seperated argument list
     */
    JTuple(typename JClass<JHead_t>::argument_type x,...)
    {
      va_list  ap;
 
      first = x;
      
      va_start(ap, x);
      
      second.valueOf(ap);
 
      va_end(ap);
    }
 
 
    /**
     * Negate tuple.
     *
     * \return                 this tuple
     */
    JTuple& negate()
    {
      first  = -first;
      second.negate();
 
      return *this;
    }
 
 
    /**
     * Add tuple.
     *
     * \param  tuple           tuple
     * \return                 this tuple
     */
    JTuple& add(const JTuple& tuple)
    {
      first  +=  tuple.first;
      second.add(tuple.second);
 
      return *this;
    }
 
 
    /**
     * Subtract tuple.
     *
     * \param  tuple           tuple
     * \return                 this tuple
     */
    JTuple& sub(const JTuple& tuple)
    {
      first  -=  tuple.first;
      second.sub(tuple.second);
 
      return *this;
    }
 
 
    /**
     * Scale tuple.
     *
     * \param  factor          multiplication factor
     * \return                 this tuple
     */
    JTuple& mul(const double factor)
    {
      first  *=  factor;
      second.mul(factor);
 
      return *this;
    }
 
 
    /**
     * Scale tuple.
     *
     * \param  factor          division factor
     * \return                 this tuple
     */
    JTuple& div(const double factor)
    {
      first  /=  factor;
      second.div(factor);
 
      return *this;
    }
 
 
    /**
     * Compare tuple.
     *
     * \param  tuple           tuple
     * \return                 true if this tuple less than given tuple; else false
     */
    bool less(const JTuple& tuple) const
    {
      if (first == tuple.first)
        return second < tuple.second;
      else
        return first  < tuple.first;
    }
 
 
    /**
     * Initialise values.
     *
     * \param  ap              argument list
     */
    void valueOf(va_list& ap)
    {
      first  = va_arg(ap, JHead_t);
 
      second.valueOf(ap);
    }
 
 
    /**
     * Read tuple from input.
     *
     * \param  in              input stream
     * \param  tuple           tuple
     * \return                 input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JTuple& tuple)
    {
      in >> tuple.first;
      in >> tuple.second;
 
      return in;
    }
 
 
    /**
     * Write tuple to output.
     *
     * \param  out             output stream
     * \param  tuple           tuple
     * \return                 output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JTuple& tuple)
    {
      out << tuple.first;
      out << ' ';
      out << tuple.second;
 
      return out;
    }
 
 
    /**
     * Read tuple from input.
     *
     * \param  in              reader
     * \param  tuple           tuple
     * \return                 reader
     */
    friend inline JReader& operator>>(JReader& in, JTuple& tuple)
    {
      in >> tuple.first;
      in >> tuple.second;
 
      return in;
    }
 
 
    /**
     * Write tuple to output.
     *
     * \param  out             writer
     * \param  tuple           tuple
     * \return                 writer
     */
    friend inline JWriter& operator<<(JWriter& out, const JTuple& tuple)
    { 
      out << tuple.first;
      out << tuple.second;
 
      return out;
    }
 
 
    JHead_t         first;
    JTuple<JTail_t> second;
  };
 
 
  /**
   * Template specialisation of JTuple for two data types.
   */
  template<class JHead_t, class JTail_t>
  struct JTuple< JTypeList<JHead_t, JTypeList<JTail_t, JNullType> > > :
    public JMath      < JTuple<JTypeList<JHead_t, JTypeList<JTail_t, JNullType> > > >,
    public JComparable< JTuple<JTypeList<JHead_t, JTypeList<JTail_t, JNullType> > > >
  {
    
    typedef JTypeList<JHead_t, JTail_t>  typelist;
 
    /**
     * Default constructor.
     */
    JTuple()
    {}
 
 
    /**
     * Constructor.
     *
     * \param   __first        first
     * \param   __second       second
     */
    JTuple(typename JClass<JHead_t>::argument_type __first,
           typename JClass<JTail_t>::argument_type __second) :
      first (__first),
      second(__second)
    {}
 
 
    /**
     * Constructor.
     *
     * \param   __first        first
     * \param   __second       second
     */
    JTuple(typename JClass<JHead_t>::argument_type __first, const JTuple<JTail_t>& __second) :
      first (__first),
      second(__second.first)
    {}
 
 
    /**
     * Negate tuple.
     *
     * \return                 this tuple
     */
    JTuple& negate()
    {
      first  = -first;
      second = -second;
 
      return *this;
    }
 
 
    /**
     * Add tuple.
     *
     * \param  tuple           tuple
     * \return                 this tuple
     */
    JTuple& add(const JTuple& tuple)
    {
      first  +=  tuple.first;
      second +=  tuple.second;
 
      return *this;
    }
 
 
    /**
     * Subtract tuple.
     *
     * \param  tuple           tuple
     * \return                 this tuple
     */
    JTuple& sub(const JTuple& tuple)
    {
      first  -=  tuple.first;
      second -=  tuple.second;
 
      return *this;
    }
 
 
    /**
     * Scale tuple.
     *
     * \param  factor          multiplication factor
     * \return                 this tuple
     */
    JTuple& mul(const double factor)
    {
      first  *=  factor;
      second *=  factor;
 
      return *this;
    }
 
 
    /**
     * Scale tuple.
     *
     * \param  factor          division factor
     * \return                 this tuple
     */
    JTuple& div(const double factor)
    {
      first  /=  factor;
      second /=  factor;
 
      return *this;
    }
 
 
    /**
     * Compare tuple.
     *
     * \param  tuple           tuple
     * \return                 true if this tuple less than given tuple; else false
     */
    bool less(const JTuple& tuple) const
    {
      if (first == tuple.first)
        return second < tuple.second;
      else
        return first  < tuple.first;
    }
 
 
    /**
     * Initialise values.
     *
     * \param  ap              argument list
     */
    void valueOf(va_list& ap)
    {
      first  = va_arg(ap, JHead_t);
      second = va_arg(ap, JTail_t);
    }
 
 
    /**
     * Read tuple from input.
     *
     * \param  in              input stream
     * \param  tuple           tuple
     * \return                 input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JTuple& tuple)
    {
      in >> tuple.first;
      in >> tuple.second;
 
      return in;
    }
 
 
    /**
     * Write tuple to output.
     *
     * \param  out             output stream
     * \param  tuple           tuple
     * \return                 output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JTuple& tuple)
    {
      out << tuple.first;
      out << ' ';
      out << tuple.second;
 
      return out;
    }
 
 
    /**
     * Read tuple from input.
     *
     * \param  in              reader
     * \param  tuple           tuple
     * \return                 reader
     */
    friend inline JReader& operator>>(JReader& in, JTuple& tuple)
    {
      in >> tuple.first;
      in >> tuple.second;
 
      return in;
    }
 
 
    /**
     * Write tuple to output.
     *
     * \param  out             writer
     * \param  tuple           tuple
     * \return                 writer
     */
    friend inline JWriter& operator<<(JWriter& out, const JTuple& tuple)
    { 
      out << tuple.first;
      out << tuple.second;
 
      return out;
    }
 
 
    JHead_t first;
    JTail_t second;
  };
 
 
  /**
   * Terminator class of recursive JTuple class.
   */
  template<class JHead_t>
  struct JTuple< JTypeList<JHead_t, JNullType> > :
    public JTuple<JHead_t>
  {
    
    typedef JTypeList<JHead_t>  typelist;
 
    /**
     * Default constructor.
     */
    JTuple()
    {}
 
 
    /**
     * Constructor.
     *
     * \param   __first        first
     */
    JTuple(typename JClass<JHead_t>::argument_type __first) :
      JTuple<JHead_t>(__first)
    {}
 
 
    /**
     * Constructor.
     *
     * \param   __first        first
     * \param   __second       second
     */
    JTuple(typename JClass<JHead_t>::argument_type __first, const JTuple<JNullType>& __second) :
      JTuple<JHead_t>(__first)
    {}
  };
 
 
  /**
   * Helper method for tuple.
   *
   * \param   b              null type
   * \param   c              null type
   * \param   d              null type
   * \param   e              null type
   * \param   f              null type
   * \param   g              null type
   * \param   h              null type
   * \param   i              null type
   * \param   j              null type
   * \param   k              null type
   * \param   l              null type
   * \param   m              null type
   * \param   n              null type
   * \param   o              null type
   * \param   p              null type
   * \param   q              null type
   * \param   r              null type
   * \param   s              null type
   * \param   t              null type
   * \param   u              null type
   * \param   v              null type
   * \param   w              null type
   * \param   x              null type
   * \param   y              null type
   * \param   z              null type
   * \return                 tuple
   */
  JTuple< JTypeList<JNullType, JNullType> >
  make_tuple(const JNullType& b,
             const JNullType& c,
             const JNullType& d,
             const JNullType& e,
             const JNullType& f,
             const JNullType& g,
             const JNullType& h,
             const JNullType& i,
             const JNullType& j,
             const JNullType& k,
             const JNullType& l,
             const JNullType& m,
             const JNullType& n,
             const JNullType& o,
             const JNullType& p,
             const JNullType& q,
             const JNullType& r,
             const JNullType& s,
             const JNullType& t,
             const JNullType& u,
             const JNullType& v,
             const JNullType& w,
             const JNullType& x,
             const JNullType& y,
             const JNullType& z)
  {
    return JTuple< JTypeList<JNullType, JNullType> >();
  }
 
 
  /**
   * Helper method for tuple.
   *
   * \param   a              a-th parameter
   * \param   b              b-th parameter
   * \param   c              c-th parameter
   * \param   d              d-th parameter
   * \param   e              e-th parameter
   * \param   f              f-th parameter
   * \param   g              g-th parameter
   * \param   h              h-th parameter
   * \param   i              i-th parameter
   * \param   j              j-th parameter
   * \param   k              k-th parameter
   * \param   l              l-th parameter
   * \param   m              m-th parameter
   * \param   n              n-th parameter
   * \param   o              o-th parameter
   * \param   p              p-th parameter
   * \param   q              q-th parameter
   * \param   r              r-th parameter
   * \param   s              s-th parameter
   * \param   t              t-th parameter
   * \param   u              u-th parameter
   * \param   v              v-th parameter
   * \param   w              w-th parameter
   * \param   x              x-th parameter
   * \param   y              y-th parameter
   * \param   z              z-th parameter
   * \return                 tuple
   */
  template<class A,
           class B = JNullType,
           class C = JNullType,
           class D = JNullType,
           class E = JNullType,
           class F = JNullType,
           class G = JNullType,
           class H = JNullType,
           class I = JNullType,
           class J = JNullType,
           class K = JNullType,
           class L = JNullType,
           class M = JNullType,
           class N = JNullType,
           class O = JNullType,
           class P = JNullType,
           class Q = JNullType,
           class R = JNullType,
           class S = JNullType,
           class T = JNullType,
           class U = JNullType,
           class V = JNullType,
           class W = JNullType,
           class X = JNullType,
           class Y = JNullType,
           class Z = JNullType>
  JTuple<typename JTYPELIST<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z>::typelist>
  make_tuple(const A& a,
             const B& b = JNullType(),
             const C& c = JNullType(),
             const D& d = JNullType(),
             const E& e = JNullType(),
             const F& f = JNullType(),
             const G& g = JNullType(),
             const H& h = JNullType(),
             const I& i = JNullType(),
             const J& j = JNullType(),
             const K& k = JNullType(),
             const L& l = JNullType(),
             const M& m = JNullType(),
             const N& n = JNullType(),
             const O& o = JNullType(),
             const P& p = JNullType(),
             const Q& q = JNullType(),
             const R& r = JNullType(),
             const S& s = JNullType(),
             const T& t = JNullType(),
             const U& u = JNullType(),
             const V& v = JNullType(),
             const W& w = JNullType(),
             const X& x = JNullType(),
             const Y& y = JNullType(),
             const Z& z = JNullType())
  {
    return JTuple<typename JTYPELIST<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z>::typelist>(a, make_tuple(b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z));
  }
 
  /**
   * For each data type method.
   *
   * The given object should provide for the function object operator
   * <pre>
   *    template<class T>
   *    void object()(JType<T> type, tuple);
   * </pre>
   *
   * \param  object           object
   * \param  typelist         type list
   * \param  tuple            tuple
   * \return                  object
   */
  template<class JObject_t, class JHead_t, class JTail_t, class T>
  JObject_t& for_each(JObject_t& object, JType< JTypeList<JHead_t, JTail_t> > typelist, const JTuple<T>& tuple)
  {
    for_each(object, JType<JHead_t>(), tuple);
    for_each(object, JType<JTail_t>(), tuple);
 
    return object;
  }
 
 
  /**
   * For each data type method.
   *
   * The given object should provide for the function object operator
   * <pre>
   *    template<class T>
   *    void object()(JType<T> type, tuple);
   * </pre>
   *
   * \param  object           object
   * \param  type             type
   * \param  tuple            tuple
   * \return                  object
   */
  template<class JObject_t, class JTypelist_t, class T>
  JObject_t& for_each(JObject_t& object, JType<JTypelist_t> type, const JTuple<T>& tuple)
  {
    object(type, tuple);
 
    return object;
  }
 
 
  /**
   * Termination method of for each data type method.
   *
   * \param  object           object
   * \param  type             null type
   * \param  tuple            tuple
   * \return                  object
   */
  template<class JObject_t, class T>
  JObject_t& for_each(JObject_t& object, JType<JNullType> type, const JTuple<T>& tuple)
  {
    return object;
  }
}
 
#endif