JASCIIFileStreamer.hh

Go to the documentation of this file.

#ifndef __JROOT_JASCIIFILESTREAMER__
#define __JROOT_JASCIIFILESTREAMER__

#include <string>
#include <vector>
#include <fstream>
#include <sstream>

#include "JLang/JEquationParameters.hh"
#include "JLang/JRedirectString.hh"

#include "JROOT/JRootClass.hh"
#include "JROOT/JRootDictionary.hh"
#include "JROOT/JRootStreamer.hh"


/**
 * \author mdejong
 */
namespace JROOT {}
namespace JPP { using namespace JROOT; }

namespace JROOT {


  /**
   * Auxiliary class to read objects with ROOT dictionary from ASCII formatted file.
   *
   * The names of in the first line are one-to-one mapped to the names of the data members 
   * of the corresponding data structure using the corresponding ROOT dictionary.
   */
  template<class T>
  struct JASCIIFileReader :
    public std::ifstream
  {
    using std::ifstream::operator>>;

    /**
     * Constructor.
     *
     * \param  dictionary    dictionary
     */
    JASCIIFileReader(const JRootDictionary& dictionary = JRootDictionary::getInstance()) :
      reader(static_cast<std::istream&>(*this), JLANG::JEquationParameters(), dictionary)
    {}


    /**
     * Constructor.
     *
     * \param  file_name     file name
     * \param  dictionary    dictionary
     */
    JASCIIFileReader(const char* const      file_name,
                     const JRootDictionary& dictionary = JRootDictionary::getInstance()) :
      reader(static_cast<std::istream&>(*this), JLANG::JEquationParameters(), dictionary)
    {
      this->open(file_name);
    }


    /**
     * Read object from this file.
     *
     * \param  object        object
     * \return               this input stream
     */
    JASCIIFileReader& operator>>(T& object)
    {
      using namespace std;
      using namespace JPP;

      if (columns.empty()) {

        JRootReadableClass cls(this->object);

        string buffer;

        if (std::getline(*this, buffer)) {

          istringstream is(buffer);
            
          while (is >> buffer) {
            columns.push_back(cls.find(buffer.c_str()));
          }
        }
      }

      object = value;

      reader.flags(this->flags());

      string buffer;

      if (std::getline(*this, buffer)) {

        istringstream is(buffer);

        for (size_t i = 0; i != columns.size() && is >> buffer; ++i) {

          if (columns[i].is_valid()) {     

            JRedirectString redirect(reader, buffer);
      
            reader.getObject(columns[i]);
          }
        }

        object = this->object;
      }

      return *this;
    }

  private:
    T  object;                                      //!< internal value
    T  value;                                       //!< default  value

    std::vector<JROOT::JRootReadableClass> columns; //!< column count -> data member

    JRootReader reader;
  };


  /**
   * Auxiliary class to write object with ROOT dictionary from ASCII formatted file.
   *
   * The names of in the first line are one-to-one mapped to the names of the data members 
   * of the corresponding data structure using the corresponding ROOT dictionary.
   */
  template<class T>
  struct JASCIIFileWriter :
    public std::ofstream
  {
    using std::ofstream::operator<<;

    /**
     * Constructor.
     *
     * \param  dictionary    dictionary
     */
    JASCIIFileWriter(const JRootDictionary& dictionary = JRootDictionary::getInstance()) :
      writer(static_cast<std::ostream&>(*this), JLANG::JEquationParameters(), dictionary)
    {}


    /**
     * Constructor.
     *
     * \param  file_name     file name
     * \param  dictionary    dictionary
     */
    JASCIIFileWriter(const char* const      file_name,
                     const JRootDictionary& dictionary = JRootDictionary::getInstance()) :
      writer(static_cast<std::ostream&>(*this), JLANG::JEquationParameters(), dictionary)
    {
      this->open(file_name);
    }


    /**
     * Write object to this file.
     *
     * \param  object        object
     * \return               this input stream
     */
    JASCIIFileWriter& operator<<(const T& object)
    {
      using namespace std;
      using namespace JPP;

      if (columns.empty()) {

        JRootWritableClass cls(this->object);

        for (const TDataMember* p : getListOfDataMembers<T>()) {

          static_cast<ostream&>(*this) << ' ' << p->GetName();

          columns.push_back(cls.get(*p));
        }
         
        static_cast<ostream&>(*this) << endl;
      }

      this->object = object;

      writer.flags(this->flags());

      for (size_t i = 0; i != columns.size(); ++i) {
        writer.putObject(columns[i]);
      }

      return *this;
    }

  private:
    T  object;                                      //!< internal value

    std::vector<JROOT::JRootWritableClass> columns; //!< column count -> data member

    JRootWriter writer;
  };
}

#endif