JRootStreamer.hh

Go to the documentation of this file.

#ifndef __JROOT__JROOTSTREAMER__
#define __JROOT__JROOTSTREAMER__

#include <string>
#include <istream>
#include <ostream>

#include "JLang/JEquation.hh"
#include "JLang/JEquationParameters.hh"
#include "JLang/JEquationFacet.hh"
#include "JLang/JStreamAvailable.hh"
#include "JLang/JBool.hh"
#include "JLang/JRedirectString.hh"
#include "JLang/JStreamState.hh"
#include "JROOT/JAbstractStreamer.hh"
#include "JROOT/JRootClass.hh"
#include "JROOT/JRootDictionary_t.hh"


/**
 * \file
 *
 * ASCII I/O of objects with ROOT dictionary.
 * \author mdejong
 */
namespace JROOT {}
namespace JPP { using namespace JROOT; }

namespace JROOT {

  using JLANG::JEquationParameters;
  using JLANG::JBool;
  using JLANG::JStreamState;
  using JLANG::JException;


  /**
   * Implementation for ASCII input of objects with ROOT dictionary.
   *
   * The method JRootReader::get is compatible with equation formatting, i.e:
   *
   * <pre><key><separator><value>[<white space><value>]*<end of line></pre>
   *
   * and method JRootReader::getObject with simple formatting, i.e:
   *
   * <pre><value>[<white space><value>]*</pre>
   *
   * The default format for input of <tt>std::vector<T></tt> is 
   *
   * <pre><number of elements>[<white space><value>]*</pre>
   */
  class JRootReader :
    public std::istream,
    private JStreamState
  {
  private:
    /**
     * Default helper class for formatting.
     */
    template<class T>
    struct JDefaultHelper {
      /**
       * Read object.
       *
       * This method transfers the reading of the given object to the given ROOT reader.
       *
       * \param  reader          ROOT reader
       * \param  object          object
       * \return                 ROOT reader
       */
      static JRootReader& getObject(JRootReader& reader, T& object)
      {
        return reader.getObject(object);
      }
    };

  public:
    /**
     * Helper class for user formatting.
     *
     * This class should be specialised for implementing a different format.
     */
    template<class T>
    struct JHelper : 
      public JDefaultHelper<T>
    {};


    /**
     * Constructor.
     *
     * \param  in              input stream
     * \param  parameters      equation parameters
     * \param  dictionary      dictionary
     */
    JRootReader(std::istream&              in, 
                const JEquationParameters& parameters,
                const JRootDictionary_t&   dictionary) :
      std::istream(in.rdbuf()),
      JStreamState(in, static_cast<std::istream&>(*this)),
      dictionary(dictionary)
    {
      imbue(std::locale(in.getloc(), new JLANG::JEquationFacet(parameters)));
    }


    /**
     * Get dictionary.
     *
     * \return                 dictionary
     */
    const JRootDictionary_t& getDictionary() const
    {
      return dictionary;
    }


    /**
     * Read object.
     *
     * This method transfers the reading of the given object to the template JHelper class
     * so that the default format can be changed through specialisation of this class.
     *
     * \param  reader          ROOT reader
     * \param  object          object
     * \return                 ROOT reader
     */
    template<class T>
    static JRootReader& getObject(JRootReader& reader, T& object)
    {
      return JRootReader::JHelper<T>::getObject(reader, object);
    }


    /**
     * Read object according equation format.
     *
     * \param  object          object
     * \return                 this ROOT reader
     */
    template<class T>
    JRootReader& get(T& object)
    {
      return this->get(JRootReadableClass(object));
    }


    /**
     * Read object.
     *
     * \param  object          object
     * \return                 this ROOT reader
     */
    template<class T>
    JRootReader& getObject(T& object)
    {
      return this->getObject(object, JBool<JStreamAvailable<T>::has_istream>());
    }


    /**
     * Read ROOT class according equation format.
     *
     * \param  cls             ROOT class
     * \return                 this ROOT reader
     */
    JRootReader& get(const JRootReadableClass& cls)
    {
      using namespace std;
      using namespace JLANG;

      if (cls.is_valid()) {

        const JEquationFacet& facet = use_facet<JEquationFacet>(this->getloc());
        
        for (JEquation equation; *this >> equation; ) {

          const JRootReadableClass abc = cls.find(equation.getKey().c_str());

          bool okay = abc.is_valid();
          
          if (okay) {
          
            JRedirectString redirect(*this, equation.getValue());
          
            if      (facet.isDivision (equation.getSeparator()))
              this->get(abc);
            else if (facet.isSeparator(equation.getSeparator())) 
              this->getObject(abc);
            else
              okay = false;
            
            okay &= (!this->fail() || this->eof());
          }

          if (!okay) {
            throw JException("Error parsing: " + equation.toString());
          }
        }
      }

      return *this;
    }


    /**
     * Read ROOT class.
     *
     * \param  cls             ROOT class
     * \return                 this ROOT reader
     */
    JRootReader& getObject(const JRootReadableClass& cls)
    {
      if (cls.is_valid()) {

        JRootDictionary_t::const_iterator i = this->getDictionary().find(cls.getTypename());

        if (i != this->getDictionary().end()) {

          i->second->getObject(*this, cls.getAddress());
          
        } else if (cls.getClass() != NULL) {
          
          if (cls.getClass()->GetListOfBases() != NULL) {

            TIterator* i = cls.getClass()->GetListOfBases()->MakeIterator();
          
            for (const TBaseClass* p; (p = (const TBaseClass*) i->Next()) != NULL && (bool) (*this); ) {
              this->getObject(cls.get(*p));
            }
          }
          
          if (cls.getClass()->GetListOfDataMembers() != NULL) {

            TIterator* i = cls.getClass()->GetListOfDataMembers()->MakeIterator();
          
            for (const TDataMember* p; (p = (const TDataMember*) i->Next()) != NULL && (bool) (*this); ) {
              this->getObject(cls.get(*p));
            }
          }
        }
      }

      return *this;
    }


    /**
     * Read ROOT class according equation format.
     *
     * \param  cls             ROOT class
     * \return                 this ROOT reader
     */
    JRootReader& getObject(JRootReadableClass& cls)
    {
      return getObject(const_cast<const JRootReadableClass&>(cls));
    }
 

  protected:
    /**
     * Read object.
     *
     * \param  object          object
     * \param  option          true
     * \return                 this ROOT reader
     */
    template<class T>
    JRootReader& getObject(T& object, const JBool<true>& option)
    {
      *this >> object;

      return *this;
    }


    /**
     * Read object.
     *
     * \param  object          object
     * \param  option          false
     * \return                 this ROOT reader
     */
    template<class T>
    JRootReader& getObject(T& object, const JBool<false>& option)
    {
      return this->getObject(JRootReadableClass(object));
    }


    /**
     * Read object.
     *
     * \param  object          object
     * \param  option          false
     * \return                 this ROOT reader
     */
    template<class JElement_t, class JAllocator_t>
    JRootReader& getObject(std::vector<JElement_t, JAllocator_t>& object, const JBool<false>& option)
    {
      int n = 0;

      this->getObject(n);

      for (JElement_t element; n != 0 && this->getObject(element); --n) {
        object.push_back(element);
      }

      return *this;
    }


    const JRootDictionary_t& dictionary;
  };


  /**
   * Implementation for ASCII output of objects with ROOT dictionary.
   *
   * The method JRootReader::put is compatible with equation formatting, i.e:
   *
   * <pre><key><separator><value>[<white space><value>]*<end of line></pre>
   *
   * and method JRootReader::putObject with simple formatting, i.e:
   *
   * <pre><value>[<white space><value>]*</pre>
   *
   * The default format for input of <tt>std::vector<T></tt> is 
   *
   * <pre><number of elements>[<white space><value>]*</pre>
   */
  class JRootWriter :
    public std::ostream,
    private JStreamState
  {
  private:
    /**
     * Default helper class for formatting.
     */
    template<class T>
    struct JDefaultHelper {
      /**
       * Write object.
       *
       * This method transfers the writing of the given object to the given ROOT writer.
       *
       * \param  writer          ROOT writer
       * \param  object          object
       * \return                 ROOT writer
       */
      static JRootWriter& putObject(JRootWriter& writer, const T& object)
      {
        return writer.putObject(object);
      }


      /**
       * Write given key and value according equation format.
       *
       * \param  writer          ROOT writer
       * \param  key             key
       * \param  value           value
       * \return                 ROOT writer
       */
      static JRootWriter& put(JRootWriter& writer, const std::string& key, const T& value)
      {
        return writer.put(key, value);
      }
    };

  public:
    /**
     * Helper class for user formatting.
     *
     * This class should be specialised for implementing a different format.
     */
    template<class T>
    struct JHelper : 
      public JDefaultHelper<T>
    {};


    /**
     * Constructor.
     *
     * \param  out             output stream
     * \param  parameters      equation parameters
     * \param  dictionary      dictionary
     */
    JRootWriter(std::ostream&              out, 
                const JEquationParameters& parameters,
                const JRootDictionary_t&   dictionary) :
      std::ostream(out.rdbuf()),
      JStreamState(out, static_cast<std::ostream&>(*this)),
      dictionary(dictionary)
    {
      imbue(std::locale(out.getloc(), new JLANG::JEquationFacet(parameters)));

      flags    (out.flags());
      width    (out.width());
      precision(out.precision());
    }


    /**
     * Get dictictionary.
     *
     * \return                 dictionary
     */
    const JRootDictionary_t& getDictionary() const
    {
      return dictionary;
    }


    /**
     * Write object.
     *
     * This method transfers the writing of the given object to the template JHelper class
     * so that the default format can be changed through specialisation of this class.
     *
     * \param  writer          ROOT writer
     * \param  object          object
     * \return                 ROOT writer
     */
    template<class T>
    static JRootWriter& putObject(JRootWriter& writer, const T& object)
    {
      return JRootWriter::JHelper<T>::putObject(writer, object);
    }
    

    /**
     * Write given key and value according equation format.
     *
     * \param  writer          ROOT writer
     * \param  key             key
     * \param  value           value
     * \return                 ROOT writer
     */
    template<class T>
    static JRootWriter& put(JRootWriter& writer, const std::string& key, const T& value)
    {
      return JRootWriter::JHelper<T>::put(writer, key, value);
    }
    

    /**
     * Write object according equation format.
     *
     * \param  object          object
     * \return                 this ROOT writer
     */
    template<class T>
    JRootWriter& put(const T& object)
    {
      return this->put(JRootWritableClass(object));
    }


    /**
     * Write object according equation format.
     *
     * \param  cls             ROOT class
     * \return                 this ROOT writer
     */
    JRootWriter& put(const JRootWritableClass& cls)
    {
      return this->put("", cls, false);
    }


    /**
     * Write object according equation format.
     *
     * \param  cls             ROOT class
     * \return                 this ROOT writer
     */
    JRootWriter& put(JRootWritableClass& cls)
    {
      return this->put(const_cast<const JRootWritableClass&>(cls));
    }


    /**
     * Write object.
     *
     * \param  object          object
     * \return                 this ROOT writer
     */
    template<class T>
    JRootWriter& putObject(const T& object)
    {
      return this->putObject(object, JBool<JStreamAvailable<T>::has_ostream>());
    }


    /**
     * ROOT class output.
     *
     * \param  prefix          prefix
     * \param  cls             ROOT class
     * \param  eol             end-of-line
     * \return                 object output
     */
    JRootWriter& put(const std::string& prefix, const JRootWritableClass& cls, bool eol)
    {
      using namespace std;
      using namespace JLANG;

      if (cls.is_valid()) {

        const JEquationFacet& facet = use_facet<JEquationFacet>(this->getloc());

        JRootDictionary_t::const_iterator i = this->getDictionary().find(cls.getTypename());

        if (i != this->getDictionary().end()) {

          i->second->put(*this, prefix, cls.getAddress());
          
        } else if (eol) {

          *this << prefix;
          *this << separator;
          
          this->putObject(cls);
          
          *this << end_of_line;

        } else if (cls.getClass() != NULL) {

          if (cls.getClass()->GetListOfBases() != NULL) {
            
            TIterator* i = cls.getClass()->GetListOfBases()->MakeIterator();
            
            for (const TBaseClass* p; (p = (const TBaseClass*) i->Next()) != NULL; ) {        
              this->put(prefix, cls.get(*p), false);
            }
          }
          
          if (cls.getClass()->GetListOfDataMembers() != NULL) {
            
            TIterator* i = cls.getClass()->GetListOfDataMembers()->MakeIterator();
            
            for (const TDataMember* p; (p = (const TDataMember*) i->Next()) != NULL; ) {
              if (!JRootClass::is_static(*p)) {
                this->put(facet.getPrefix(prefix,p->GetName()), cls.get(*p), false);
              }
            }
          }
        }
      }

      return *this;
    }


    /**
     * ROOT class output.
     *
     * \param  cls             ROOT class
     * \return                 object output
     */
    JRootWriter& putObject(const JRootWritableClass& cls)
    {
      using namespace std;

      if (cls.is_valid()) {

        JRootDictionary_t::const_iterator i = this->getDictionary().find(cls.getTypename());

        if (i != this->getDictionary().end()) {
          
          i->second->putObject(*this, cls.getAddress());
          
        } else if (cls.getClass() != NULL) {
            
          if (cls.getClass()->GetListOfBases() != NULL) {

            TIterator* i = cls.getClass()->GetListOfBases()->MakeIterator();
          
            for (const TBaseClass* p; (p = (const TBaseClass*) i->Next()) != NULL; ) {
              this->putObject(cls.get(*p));
            }
          }

          if (cls.getClass()->GetListOfDataMembers() != NULL) {

            TIterator* i = cls.getClass()->GetListOfDataMembers()->MakeIterator();
          
            for (const TDataMember* p; (p = (const TDataMember*) i->Next()) != NULL; ) {
              if (!JRootClass::is_static(*p)) {
                this->putObject(cls.get(*p));
              }
            }
          }
        }
      }

      return *this;
    }


    /**
     * Write given key and value according equation format.
     *
     * \param  key             key
     * \param  value           value
     * \return                 this ROOT writer
     */
    template<class T>
    JRootWriter& put(const std::string& key, const T& value)
    {
      return this->put(key, value, JLANG::JBool<JStreamAvailable<T>::has_ostream>());
    }

  protected:
    /**
     * Write given key and value according equation format.
     *
     * \param  key             key
     * \param  value           value
     * \param  option          true
     * \return                 this ROOT writer
     */
    template<class T>
    JRootWriter& put(const std::string& key, const T& value, const JBool<true> option)
    {
      using namespace JLANG;

      *this << key;
      *this << separator;
      *this << white_space;
      *this << value;
      *this << end_of_line;

      return *this;
    }


    /**
     * Write given key and value according equation format.
     *
     * \param  key             key
     * \param  value           value
     * \param  option          false
     * \return                 this ROOT writer
     */
    template<class T>
    JRootWriter& put(const std::string& key, const T& value, const JBool<false> option)
    {
      using namespace JLANG;

      *this << key;
      *this << separator;

      this->putObject(value);

      *this << end_of_line;

      return *this;
    }


    /**
     * Write given key and value according equation format.
     *
     * \param  key             key
     * \param  value           value
     * \param  option          false
     * \return                 this ROOT writer
     */
    template<class JElement_t, class JAllocator_t>
    JRootWriter& put(const std::string& key, const std::vector<JElement_t, JAllocator_t>& value, const JBool<false> option)
    {
      for (typename std::vector<JElement_t, JAllocator_t>::const_iterator i = value.begin(); i != value.end(); ++i) {
        this->put(key, *i);
      }
        
      return *this;
    }


    /**
     * Write object.
     *
     * \param  object          object
     * \param  option          true
     * \return                 this ROOT writer
     */
    template<class T>
    JRootWriter& putObject(const T& object, const JBool<true>& option)
    {
      using namespace JLANG;

      *this << white_space;
      *this << object;

      return *this;
    }


    /**
     * Write object.
     *
     * \param  object          object
     * \param  option          false
     * \return                 this ROOT writer
     */
    template<class T>
    JRootWriter& putObject(const T& object, const JBool<false>& option)
    {
      return this->putObject(JRootWritableClass(object));
    }


    /**
     * Write object.
     *
     * \param  object          object
     * \param  option          false
     * \return                 this ROOT writer
     */
    template<class JElement_t, class JAllocator_t>
    JRootWriter& putObject(const std::vector<JElement_t, JAllocator_t>& object, const JBool<false> option)
    {
      this->putObject(object.size());

      for (typename std::vector<JElement_t, JAllocator_t>::const_iterator i = object.begin(); i != object.end(); ++i) {
        this->putObject(*i);
      }

      return *this;
    }


    const JRootDictionary_t& dictionary;
  };


  /**
   * JObjectStreamer class.
   *
   * This class implements the JAstractStreamer interface for the given template class.
   * The I/O functionality is transferred to the JRootReader and JRootWriter class, respectively.
   */
  template<class T>
  class JObjectStreamer :
    public JAbstractStreamer
  {
  public:
    /**
     * Stream input.
     *
     * \param  in              object reader
     * \param  address         pointer to object
     * \return                 object reader
     */
    virtual JRootReader& getObject(JRootReader& in, void* address) const
    {
      return JRootReader::getObject(in, * ((T*) address));
    }


    /**
     * Stream output.
     *
     * \param  out             object writer
     * \param  address         pointer to object
     * \return                 object writer
     */
    virtual JRootWriter& putObject(JRootWriter& out, const void* address) const 
    {
      return JRootWriter::putObject(out, * ((const T*) address));
    }


    /**
     * Stream output.
     *
     * \param  out             object writer
     * \param  prefix          prefix
     * \param  address         pointer to object
     * \return                 object writer
     */
    virtual JRootWriter& put(JRootWriter& out, const std::string& prefix, const void* address) const
    {
      return JRootWriter::put(out, prefix, * ((const T*) address));
    }
  };
}

#endif