JRootPrinter.hh

Go to the documentation of this file.

#ifndef __JROOT__JROOTPRINTER__
#define __JROOT__JROOTPRINTER__
 
#include <string>
#include <ostream>
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wall"
#include "TString.h"
#include "TRegexp.h"
#include "TFormula.h"
#pragma GCC diagnostic pop
 
#include "JLang/JEquationParameters.hh"
#include "JLang/JException.hh"
#include "JLang/JLangToolkit.hh"
#include "JROOT/JRootClass.hh"
#include "JROOT/JRootStreamer.hh"
#include "JROOT/JRootDictionary.hh"
 
/**
 * \file
 *
 * Print objects in ASCII format using ROOT dictionary.
 * \author mdejong
 */
namespace JROOT {}
namespace JPP { using namespace JROOT; }
 
namespace JROOT {
 
  using JLANG::JEquationParameters;
  using JLANG::JParseError;
 
  /**
   * Auxiliary class for printing objects in ASCII format using JRootWriter.
   */
  struct JRootPrinter {
    /**
     * Get equation parameters.
     *
     * \return                         equation parameters
     */
    static inline JEquationParameters& getEquationParameters()
    {
      static JEquationParameters equation("=", "\n", ".", "");
 
      return equation;
    }
 
 
    /**
     * Set equation parameters.
     *
     * \param  equation                equation parameters
     */
    static inline void setEquationParameters(const JEquationParameters& equation)
    {
      getEquationParameters() = equation;
    }
 
 
    /**
     * Write class contents to output.
     *
     * \param  writer          ROOT writer
     * \param  cls             ROOT class
     */
    static inline void print(JRootWriter& writer, const JRootWritableClass& cls)
    {
      if (cls.is_valid()) {
        if (writer.getDictionary().find(cls.getTypename()) != writer.getDictionary().end())
          writer.putObject(cls);
        else
          writer.put(cls);
      }
    }
 
 
    /**
     * Write part of object to output using ROOT dictionary.
     *
     * \param  out             output stream
     * \param  object          object
     * \param  key             data member name, optionally separated by division character
     * \param  parameters      equation parameters
     * \param  dictionary      dictionary
     */
    template<class T>
    static inline void print(std::ostream&              out,
                             const T&                   object,
                             const std::string&         key,
                             const JEquationParameters& parameters,
                             const JRootDictionary_t&   dictionary = JRootDictionary::getInstance())
    {
      using namespace std;
      using namespace JPP;
 
      JRootWritableClass cls(object);
 
      for (string::size_type il = 0, ir = 0; ir != string::npos && cls.is_valid(); il = ir + 1) {
        ir  = key.substr(il).find(parameters.getDefaultDivision());
        cls = cls.find(trim(key.substr(il, ir - il)).c_str());
      }
 
      if (cls.is_valid()) {
 
        JRootWriter writer(out, parameters, dictionary);
 
        print(writer, cls);
 
      } else {
 
        THROW(JParseError, "Invalid key " << key);
      }
    }
 
 
    /**
     * Write object to output using ROOT dictionary.
     *
     * \param  out             output stream
     * \param  object          object
     * \param  parameters      equation parameters
     * \param  dictionary      dictionary
     */
    template<class T>
    static inline void print(std::ostream&              out,
                             const T&                   object,
                             const JEquationParameters& parameters,
                             const JRootDictionary_t&   dictionary = JRootDictionary::getInstance())
    {
      JRootWriter        writer(out, parameters, dictionary);
      JRootWritableClass cls(object);
 
      print(writer, cls);
    }
 
 
    /**
     * Write part of object to output using ROOT dictionary.
     *
     * \param  out             output stream
     * \param  object          object
     * \param  key             data member name, optionally separated by division character '.'
     * \param  dictionary      dictionary
     */
    template<class T>
    static inline void print(std::ostream&            out,
                             const T&                 object,
                             const std::string&       key,
                             const JRootDictionary_t& dictionary = JRootDictionary::getInstance())
    {
      print(out, object, key, JRootPrinter::getEquationParameters(), dictionary);
    }
 
 
    /**
     * Write object to output using ROOT dictionary.
     *
     * \param  out             output stream
     * \param  object          object
     * \param  dictionary      dictionary
     */
    template<class T>
    static inline void print(std::ostream&            out,
                             const T&                 object,
                             const JRootDictionary_t& dictionary = JRootDictionary::getInstance())
    {
      print(out, object, JRootPrinter::getEquationParameters(), dictionary);
    }
  };
 
 
  /**
   * Get result of given textual formula.
   *
   * The formula may contain names of data members of the given object.
   * For example:
   * <pre>
   *         getResult("a / b.value", object, ..);
   * </pre>
   * In this, the corresponding data type should have (at least) data members <tt>a</tt> and <tt>b</tt>
   * and <tt>b</tt> should have (at least) data member <tt>value</tt>.
   *
   * \param  text           text
   * \param  object         object
   * \param  dictionary     dictionary
   * \return                value
   */
  template<class T>
  inline Double_t getResult(const TString&           text,
                            const T&                 object,
                            const JRootDictionary_t& dictionary = JRootDictionary::getInstance())
  {
    using namespace std;
    using namespace JPP;
 
    const TRegexp DOUBLE("[0-9.][eE][+-0-9]");
 
    string buffer = (const char*) text;
 
    for (string::size_type pos = 0; pos != buffer.size(); ) {
 
      if (isalpha(buffer[pos]) || buffer[pos] == '_') {
 
        string::size_type len = 1;
 
        while (pos + len != buffer.size() && (isalnum(buffer[pos+len]) || buffer[pos+len] == '_' || buffer[pos+len] == '.')) {
          ++len;
        }
 
        if (len != 1 || pos == 0 || TString(buffer.substr(pos-1).c_str()).Index(DOUBLE) != 0) {
 
          ostringstream os;
 
          os.setf(ios::fixed);
          os.precision(10);
 
          JRootPrinter::print(os, object, buffer.substr(pos,len), dictionary);
 
          buffer.replace(pos, len, os.str());
 
          pos += os.str().size();
 
          continue;
        }
      }
 
      pos += 1;
    }
 
    return TFormula("/tmp", buffer.c_str()).Eval(0.0);
  }
}
 
#endif