JTemplateWriter.hh

Go to the documentation of this file.

#ifndef __JLANG__JTEMPLATEWRITER__
#define __JLANG__JTEMPLATEWRITER__

#include <ostream>

#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 JWriter_t,
           class JClass_t    = JNullType,
           class JTypelist_t = JNullType> 
  struct JTemplateWriter;


  /**
   * Specialisation of class JTemplateWriter for general purpose write methods.
   */
  template<class JWriter_t>
  struct JTemplateWriter<JWriter_t, JNullType, JNullType>
  {
  protected:
    /**
     * Write method for single data types.
     *
     * \param  out          writer
     * \param  object       object
     * \param  type         type
     * \return              writer
     */
    template<class JClass_t>
    static inline JWriter_t& write(JWriter_t&      out,
                                   const JClass_t& object,
                                   const JType <JNullType>& type)
    {
      return out << object;
    }
    
    
    /**
     * Write method for composite data types.
     *
     * \param  out          writer
     * \param  object       object
     * \param  type         type
     * \return              writer
     */
    template<class JClass_t, class JHead_t, class JTail_t>
    static inline JWriter_t& write(JWriter_t&      out,
                                   const JClass_t& object,
                                   const JType<JTypeList<JHead_t, JTail_t> >& type)
    {
      out << static_cast<const JHead_t&>(object);

      if (WHITE_SPACE) {
        out << WHITE_SPACE;
      }
      
      return write(out, object, JType<JTail_t>());
    }
    

    /**
     * Write method for composite data types.
     *
     * \param  out          writer
     * \param  object       object
     * \param  type         type
     * \return              writer
     */
    template<class JClass_t, class JHead_t>
    static inline JWriter_t& write(JWriter_t&      out,
                                   const JClass_t& object,
                                   const JType<JTypeList<JHead_t, JNullType> >& type)
    {
      return out << static_cast<const JHead_t&>(object);
    }

  public:
    static const char* WHITE_SPACE;    //!< White space between consecutive items in a type list.
  };


  /**
   * Default white space is empty.
   */
  template<class JWriter_t>
  const char* JTemplateWriter<JWriter_t>::WHITE_SPACE = NULL; 


  /**
   * Specialisation of white space for std::ostream.
   */
  template<>
  const char* JTemplateWriter<std::ostream>::WHITE_SPACE = " "; 


  /**
   * Specialisation of class JTemplateWriter for composite data type.
   *
   * This class uses in-class friend operators (see Barton-Nackman trick).
   */
  template<class JWriter_t, class JClass_t, class JHead_t, class JTail_t>
  struct JTemplateWriter<JWriter_t, JClass_t, JTypeList<JHead_t, JTail_t> > :
    public JTemplateWriter<JWriter_t>
  {
    /**
     * Write operator.
     *
     * \param  out          writer
     * \param  object       object
     * \return              true if first object is less than second object; else false
     */
    friend JWriter_t& operator<<(JWriter_t& out, const JClass_t& object)
    { 
      return JTemplateWriter::write(out, object, JType< JTypeList<JHead_t, JTail_t> >());
    }
  };
}

#endif