JTemplateReader.hh

Go to the documentation of this file.

#ifndef __JLANG__JTEMPLATEREADER__
#define __JLANG__JTEMPLATEREADER__
 
#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 types which derive 
   * from one or more base classes for which the redirect operator <tt><<</tt> is defined.
   * The various specialisations of this class implement the redirect operator <tt><<</tt>
   * for the derived class.
   */
  template<class JReader_t,
           class JClass_t    = JNullType,
           class JTypelist_t = JNullType> 
  struct JTemplateReader;
 
 
  /**
   * Specialisation of class JTemplateReader for general purpose write methods.
   */
  template<class JReader_t>
  struct JTemplateReader<JReader_t, JNullType, JNullType>
  {
  protected:
    /**
     * Write method for single data types.
     *
     * \param  in           reader
     * \param  object       object
     * \param  type         type
     * \return              reader
     */
    template<class JClass_t>
    static inline JReader_t& read(JReader_t& in,
                                  JClass_t&  object,
                                  const JType <JNullType>& type)
    {
      return in >> object;
    }
    
    
    /**
     * Read method for composite data types.
     *
     * \param  in           reader
     * \param  object       object
     * \param  type         type
     * \return              reader
     */
    template<class JClass_t, class JHead_t, class JTail_t>
    static inline JReader_t& read(JReader_t& in,
                                  JClass_t&  object,
                                  const JType<JTypeList<JHead_t, JTail_t> >& type)
    {
      in >> static_cast<JHead_t&>(object);
      
      return read(in, object, JType<JTail_t>());
    }
    
 
    /**
     * Read method for composite data types.
     *
     * \param  in           reader
     * \param  object       object
     * \param  type         type
     * \return              reader
     */
    template<class JClass_t, class JHead_t>
    static inline JReader_t& read(JReader_t& in,
                                  JClass_t&  object,
                                  const JType<JTypeList<JHead_t, JNullType> >& type)
    {
      return in >> static_cast<JHead_t&>(object);
    }
  };
 
 
  /**
   * Specialisation of class JTemplateReader for composite data type.
   *
   * This class uses in-class friend operators (see Barton-Nackman trick).
   */
  template<class JReader_t, class JClass_t, class JHead_t, class JTail_t>
  struct JTemplateReader<JReader_t, JClass_t, JTypeList<JHead_t, JTail_t> > :
    public JTemplateReader<JReader_t>
  {
    /**
     * Read operator.
     *
     * \param  in           reader
     * \param  object       object
     * \return              true if first object is less than second object; else false
     */
    friend JReader_t& operator>>(JReader_t& in, JClass_t& object)
    { 
      return JTemplateReader::read(in, object, JType< JTypeList<JHead_t, JTail_t> >());
    }
  };
}
 
#endif