JHead.cc

Go to the documentation of this file.

#include <string>
#include <map>
#include <sstream>

#include "km3net-dataformat/offline/Head.hh"
#include "km3net-dataformat/offline/io_ascii.hh"

#include "JSystem/JStat.hh"
#include "JLang/JRedirectString.hh"
#include "JLang/JStringStream.hh"
#include "JLang/JNullStream.hh"
#include "JLang/JLangToolkit.hh"
#include "JROOT/JRootClass.hh"
#include "JROOT/JRootStreamer.hh"
#include "JAAnet/JHead.hh"
#include "JAAnet/JAAnetDictionary.hh"


/**
 * \author mdejong
 */
namespace JAANET {

  /**
   * Applications.
   */
  const std::string JHead::GENHEN   = "GENHEN";
  const std::string JHead::GENIE    = "GENIE";
  const std::string JHead::GSEAGEN  = "gSeaGen";
  const std::string JHead::MUPAGE   = "HEMAS-DPM";
  const std::string JHead::JSIRENE  = "JSirene";
  const std::string JHead::KM3      = "KM3";
  const std::string JHead::KM3SIM   = "KM3Sim";


  /**
   * Read header from input.
   *
   * \param  in         input stream
   * \return            input stream
   */
  std::istream& JHead::read(std::istream& in)
  {
    using namespace std;
    using namespace JPP;

    JStringStream is(in);

    if (getFileStatus(is.str().c_str())) {
      is.load();
    }

    JRootReader reader(is, JHead::getEquationParameters(), JAAnetDictionary::getInstance());

    JRootReadableClass cls(*this);
    
    for (JEquation equation; reader >> equation && equation.getKey() != end_event::Class_Name(); ) {

      JRedirectString redirect(reader, equation.getValue());

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

      if (abc.is_valid()) {
        reader.getObject(abc);
      }

      (*this)[equation.getKey()] = equation.getValue();
    }

    return in;
  }
  
  
  /**
   * Write header to output.
   *
   * \param  out        output stream
   * \return            output stream
   */
  std::ostream& JHead::write(std::ostream& out) const
  {
    using namespace std;
    using namespace JPP;

    JRootWriter writer(out, JHead::getEquationParameters(), JAAnetDictionary::getInstance());

    JRootWritableClass cls(*this);

    TIterator* i = cls.getClass()->GetListOfDataMembers()->MakeIterator();

    for (const TDataMember* p; (p = (const TDataMember*) i->Next()) != NULL; ) {
      if (!JRootClass::is_static(*p)) {
        if (this->find(p->GetName()) != this->end()                    ||
            cls.get(*p)              == JRootClass(&JHead::start_run)  ||
            cls.get(*p)              == JRootClass(&JHead::end_event)) {
          writer.put(p->GetName(), cls.get(*p), true);
        }
      }
    }

    return out << flush;
  }
  
  
  /**
   * Print header to output.
   *
   * \param  out        output stream
   * \return            output stream
   */
  std::ostream& JHead::print(std::ostream& out) const
  {
    using namespace std;
    using namespace JPP;

    const JEquationParameters& parameters = JHead::getEquationParameters();

    JRootWriter writer(out, parameters, JAAnetDictionary::getInstance());

    JRootWritableClass cls(*this);

    TIterator* i = cls.getClass()->GetListOfDataMembers()->MakeIterator();

    pair<string, JRootWritableClass> end_event("", this->end_event);

    for (const TDataMember* p; (p = (const TDataMember*) i->Next()) != NULL; ) {
      if (!JRootClass::is_static(*p)) {
        if (cls.get(*p) != JRootClass(&JHead::end_event)) 
          writer.put(p->GetName(), cls.get(*p), true);
        else
          end_event = make_pair(p->GetName(), cls.get(*p));
      }
    }

    for (JHead::const_iterator i = this->begin(); i != this->end(); ++i) {
      if (!cls.find(i->first.c_str()).is_valid()) {
        out << i->first << parameters.getDefaultSeparator() << parameters.getDefaultWhiteSpace() << i->second << parameters.getDefaultEndOfLine();
      }
    }

    writer.put(end_event.first, end_event.second, true);

    return out << flush;
  }


  /**
   * Copy header from <tt>from</tt> to <tt>to</tt>.
   *
   * \param  from            header
   * \param  to              header
   */
  void copy(const Head& from, JHead& to)
  {
    using namespace std;
    using namespace JPP;

    JRootReader        reader(null, JHead::getEquationParameters(), JAAnetDictionary::getInstance());
    JRootReadableClass cls(to);

    for (Head::const_iterator i = from.begin(); i != from.end(); ++i) {

      const JRootReadableClass& abc = cls.find(getTag(i->first).c_str());

      const string buffer = trim(i->second);

      if (abc.is_valid() && buffer != "") {

        JRedirectString redirect(reader, buffer);

        reader.getObject(abc);

        if (i->first == getTag(i->first)) {
          to.insert(*i);                                     // keep track of parsed tags
        }

      } else {

        //to.insert(*i);                                       // store data of unknown tags
      }
    }
  }


  /**
   * Copy header from <tt>from</tt> to <tt>to</tt>.
   *
   * \param  from            header
   * \param  to              header
   */
  void copy(const JHead& from, Head& to)
  {
    using namespace std;

    to = Head();

    stringstream io;

    from.write(io);

    read(to, io);
    
    // copy pending data

    for (JHead::const_iterator i = from.begin(); i != from.end(); ++i) {
      if (to.find(i->first) == to.end()) {
        to.insert(*i);
      }
    }
  }
}