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 "TRegexp.h"
#include "TKey.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, JPointer<JValue_t> >
  {
  public:
 
    typedef std::map<JKey_t, JPointer<JValue_t> >      map_type;
 
    /**
     * Default constructor.
     */
    JManager() 
    {}
 
 
    /**
     * 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),
      map_type(),
      wc (wildcard),
      fmt(format)
    {
      using namespace std;
      using namespace JPP;
 
      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);
      }
    }
 
 
    /**
     * Copy constructor.
     *
     * Note that the master object of the given manager is cloned and the wildcard copied.
     * The client objects are not copied.
     *
     * \param  manager          manager
     */
    JManager(const JManager& manager) :
      JPointer<JValue_t>(NULL),
      map_type(),
      wc (manager.wc),
      fmt(manager.fmt)
    {
      using namespace std;
      using namespace JPP;
 
      if (manager.is_valid()) {
 
        this->set((JValue_t*) manager.get()->Clone());
 
        this->get()->Reset();
        this->get()->SetDirectory(0);
 
        if (string(this->get()->GetName()).find(wc) == string::npos) {
          THROW(JException, "JManager: Missing wildcard " << this->get()->GetName() << ' ' << wc);
        }
      }
    }
 
 
    /**
     * Clear client objects.
     */
    void clear()
    {
      for (typename map_type::iterator i = this->begin(); i != this->end(); ++i) {
        i->second.reset();
      }
 
      static_cast<map_type&>(*this).clear();
    }
 
 
    /**
     * 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_type::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;
      }
    }
 
 
    /**
     * Read objects from file into manager.
     *
     * \param  in               input file or directory 
     * \param  master           master name
     * \param  wildcard         wild card character
     * \return                  manager
     */
    static JManager Read(TDirectory& in, const char* const master, const char wildcard)
    {
      using namespace std;
 
      JManager manager;
 
      TString buffer = master;
 
      const Ssiz_t  pos = buffer.Index(wildcard);
 
      const TString a   = buffer(0,     pos); 
      const TString b   = buffer(pos+1, buffer.Length()); 
 
      buffer.ReplaceAll("[", "\\[");
      buffer.ReplaceAll("]", "\\]");
 
      buffer.ReplaceAll(wildcard, ".*");
 
      const TRegexp regexp(buffer);
 
      TIter iter(in.GetListOfKeys());
      
      for (TKey* key; (key = (TKey*) iter.Next()) != NULL; ) {
          
        const TString tag(key->GetName());
 
        // option match
 
        if (tag.Index(regexp) != -1) {
          
          JValue_t* p = dynamic_cast<JValue_t*>(key->ReadObj());
 
          if (p != NULL) {
 
            p->SetDirectory(0);
 
            string buffer = p->GetName();
 
            if (a.Length() != 0) { buffer.replace(buffer.find(a), a.Length(), ""); }
            if (b.Length() != 0) { buffer.replace(buffer.find(b), b.Length(), ""); }
 
            JKey_t key;
 
            istringstream(buffer) >> key;
 
            manager.insert(make_pair(key, p));
          }
        }
      }
 
      return manager;
    }
 
 
    /**
     * Read objects from file.
     *
     * \param  in               input file or directory
     */
    void Read(TDirectory& in)
    {
      if (this->is_valid()) {
 
        JManager buffer = Read(in, this->get()->GetName(), this->wc);
 
        this->swap(buffer);
      }
    }
 
 
    /**
     * Write objects to file.
     *
     * \param  out              output file or directory
     * \param  wm               write master
     */
    void Write(TDirectory& out, const bool wm = false)
    {
      for (typename map_type::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();
    }
 
    
    /**
     * Read manager from file.
     *
     * \param  file             file
     * \param  object           manager
     * \return                  file
     */
    inline friend TFile& operator>>(TFile& file, JManager& object)
    {
      object.Read(file);
 
      return file;
    }
 
    
    /**
     * 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;
    }
 
    char               wc;
    std::ios::fmtflags fmt;
  };
}
 
#endif