JManager.hh

Go to the documentation of this file.

#ifndef __JGIZMO__JMANAGER__
#define __JGIZMO__JMANAGER__

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

#include "TObject.h"
#include "TFile.h"

#include "JLang/JException.hh"
#include "JLang/JPointer.hh"


/**
 * \file
 *
 * Dynamic ROOT object management.
 * \author mdejong
 */
namespace JGIZMO {}
namespace JPP { using namespace JGIZMO; }

namespace JGIZMO {

  using JLANG::JException;
  using JLANG::JPointer;


  /**
   * Auxiliary class to manage set of compatible ROOT objects (e.g. histograms) using unique keys.
   * For each use of the map operator <tt>[]</tt>, it is checked whether the corresponding client object exists.
   * If the corresponding client object does not yet exists, a clone is made of the master object (i.e. the 'client'). 
   * The name of the newly created object is derived from the name of the master object by replacing
   * the wild card character with the value of the key according the optional format specifier.
   */
  template<class JKey_t, class JValue_t = TObject>
  class JManager : 
    public JPointer<JValue_t>,
    public std::map<JKey_t, JValue_t*>
  {
  public:
    /**
     * Constructor.
     *
     * Note that the manager owns the master object pointed to.
     * For saving the objects to file, use method Write 
     * (all objects are detached from the current ROOT directory).
     *
     * \param  master           master object
     * \param  wildcard         wild card character
     * \param  format           format specifier for replacement of wildcard character by value of key
     */
    JManager(JValue_t* master,
             char      wildcard        = '%', 
             std::ios::fmtflags format = std::ios::fmtflags()) :
      JPointer<JValue_t>(master),
      std::map<JKey_t, JValue_t*>(),
      wc (wildcard),
      fmt(format)
    {
      using namespace std;
      using namespace JLANG;

      if (master == NULL) {
        THROW(JException, "JManager: No master object.");
      }

      master->SetDirectory(0);
    
      if (string(master->GetName()).find(wc) == string::npos) {
        THROW(JException, "JManager: Missing wildcard " << master->GetName() << ' ' << wc);
      }
    }


    /**
     * Get pointer to object for given key.
     *
     * \param  key              key
     * \return                  pointer to client object
     */
    JValue_t* operator[](JKey_t key)
    {
      using namespace std;

      typename map<JKey_t, JValue_t*>::iterator i = this->find(key);

      if (i == this->end()) {

        string            buffer = this->get()->GetName();
        string::size_type ipos   = buffer.find(wc);

        ostringstream os;

        os.setf(fmt);
      
        os << key;
      
        buffer.replace(ipos, 1, os.str());
      
        JValue_t* p = (JValue_t*) this->get()->Clone(buffer.c_str());

        p->Reset();
        p->SetDirectory(0);

        this->insert(make_pair(key,p));
      
        return p;

      } else {
      
        return i->second;
      }
    }


    /**
     * Write objects to file.
     *
     * \param  out              output file or directory
     * \param  wm               write master
     */
    void Write(TDirectory& out, const bool wm = false)
    {
      for (typename std::map<JKey_t, JValue_t*>::iterator i = this->begin(); i != this->end(); ++i) {
        out.WriteTObject(i->second);
      }

      if (wm) {
        out.WriteTObject(this->get());
      }
    }


    /**
     * Write objects to file.
     *
     * \param  file_name        file name
     * \param  wm               write master
     */
    void Write(const char* file_name, const bool wm = false)
    {
      TFile out(file_name, "RECREATE");

      this->Write(out, wm) ;

      out.Write();
      out.Close();
    }

    
    /**
     * Write manager to file.
     *
     * \param  file             file
     * \param  object           manager
     * \return                  file
     */
    inline friend TFile& operator<<(TFile& file, JManager& object)
    {
      object.Write(file);

      return file;
    }

  protected:
    char               wc;
    std::ios::fmtflags fmt;
  };
}

#endif