JRootStreamObjectOutput.hh

Go to the documentation of this file.

#ifndef __JROOT__JSTREAMOBJECTOUTPUT__
#define __JROOT__JSTREAMOBJECTOUTPUT__

#include <string>

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

#include "JROOT/JRootStreamer.hh"


/**
 * \author mdejong
 */

namespace JROOT {}
namespace JPP { using namespace JROOT; }

namespace JROOT {

  using JLANG::JObjectOutput;
  using JLANG::JTypeList;
  using JLANG::JNullType;


  /**
   * Template implementation of stream output for single data type based on ROOT dictionary.
   *
   * This class implements the JLANG::JObjectOutput interface.
   */
  template<class T>
  class JRootStreamObjectOutput :
    public virtual JObjectOutput<T>
  {
  public:
    /**
     * Constructor.
     *
     * \param  out        output stream
     * \param  sep        token separator
     */
    JRootStreamObjectOutput(JRootWriter&       out,
                            const std::string& sep = "") :
      __out(out),
      __sep(sep)
    {}


    /**
     * Object output.
     *
     * \param  object     object
     * \return            true if OK; else false
     */
    virtual bool put(const T& object) 
    {
      __out.putObject(object) << __sep;

      return (bool) __out;
    }


    /**
     * Get token separator.
     *
     * \return            separator
     */
    const std::string& getSeparator() const
    {
      return this->__sep;
    }


    /**
     * Set token separator.
     *
     * \param sep         separator
     */
    void setSeparator(const std::string& sep)
    {
      this->__sep = sep;
    }

  private:
    JRootWriter& __out;
    std::string  __sep;
  };


  /**
   * Template specialisationimplementation of stream object output for multiple data types.
   *
   * This class recursively implements the JLANG::JObjectOutput interface
   * for all data types by deriving from:
   *  - JRootStreamObjectOutput<JHead_t>; and 
   *  - JRootStreamObjectOutput<JTail_t>.
   */
  template<class JHead_t, class JTail_t>
  class JRootStreamObjectOutput< JTypeList<JHead_t, JTail_t> > :
    public virtual JObjectOutput< JTypeList<JHead_t, JTail_t> >,
    public JRootStreamObjectOutput<JHead_t>,
    public JRootStreamObjectOutput<JTail_t>

  {
  public:

    using JRootStreamObjectOutput<JHead_t>::put;
    using JRootStreamObjectOutput<JTail_t>::put;


    /**
     * Constructor.
     *
     * \param  out        output stream
     * \param  sep        token separator
     */
    JRootStreamObjectOutput(JRootWriter&       out,
                            const std::string& sep = "") :
      JRootStreamObjectOutput<JHead_t>(out, sep),
      JRootStreamObjectOutput<JTail_t>(out, sep)
    {}


    /**
     * Set token separator.
     *
     * \param sep         separator
     */
    void setSeparator(const std::string& sep)
    {
      JRootStreamObjectOutput<JHead_t>::setSeparator(sep);
      JRootStreamObjectOutput<JTail_t>::setSeparator(sep);
    }
  };


  /**
   * Terminator class of recursive JRootStreamObjectOutput class.
   */
  template<class JHead_t>
  class JRootStreamObjectOutput< JTypeList<JHead_t, JNullType> > :
    public JRootStreamObjectOutput<JHead_t>
  {
  public:

    using JRootStreamObjectOutput<JHead_t>::put;


    /**
     * Constructor.
     *
     * \param  out        output stream
     * \param  sep        token separator
     */
    JRootStreamObjectOutput(JRootWriter&       out,
                            const std::string& sep = "") :
      JRootStreamObjectOutput<JHead_t>(out, sep)
    {}
  };
}

#endif