JRootClass.hh

Go to the documentation of this file.

#ifndef __JROOT__JROOTCLASS__
#define __JROOT__JROOTCLASS__
 
#include <string>
#include <ostream>
#include <cstring>
#include <typeinfo>
#include <vector>
 
#include <TDictionary.h>
#include <TClass.h>
#include <TDataMember.h>
#include <TBaseClass.h>
#include <TIterator.h>
#include <TList.h>
#include <TBranch.h>
 
#include "JLang/JType.hh"
#include "JLang/JException.hh"
#include "JLang/JEquals.hh"
 
#include "JROOT/JRoot.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JROOT {}
namespace JPP { using namespace JROOT; }
 
namespace JROOT {
 
  using JLANG::JEquals;
  using JLANG::JType;
  using JLANG::JCastException;
 
 
  /**
   * Auxiliary class to manage access to base classes and data members of ROOT class.
   */
  struct JRootClass :
    public JEquals<JRootClass>
  {
    /**
     * Constructor.
     *
     * \param  type         data type
     */
    template<class JType_t>
    JRootClass(const JType<JType_t>& type) :
      dictionary(TDictionary::GetDictionary(typeid(JType_t))),
      offset(0)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  pd           pointer to C++ data member
     */
    template<class JType_t, class JClass_t>
    JRootClass(JType_t JClass_t::*pd) :
      dictionary(TDictionary::GetDictionary(typeid(JType_t))),
      offset((char*) &(((JClass_t*) NULL)->*pd) - (char*) NULL)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  dictionary   pointer to dictionary
     * \param  offset       offset
     */
    JRootClass(TDictionary* dictionary, 
               int          offset = 0) :
      dictionary(dictionary),
      offset    (offset)
    {}
 
 
    /**
     * Get dictionary.
     *
     * \return              pointer to dictionary
     */
    TDictionary* getDictionary() const
    {
      return dictionary;
    }
 
 
    /**
     * Get offset of this class with respect to parent class.
     *
     * \return              offset
     */
    int getOffset() const
    {
      return offset;
    }
 
 
    /**
     * Get class.
     *
     * \return              pointer to class
     */
    TClass* getClass() const
    {
      return dynamic_cast<TClass*>(dictionary);
    }
 
    
    /**
     * Get type name.
     *
     * \return              type name 
     */
    const char* getTypename() const
    {
      if (dictionary != NULL)
        return dictionary->GetName();
      else
        return NULL;
    }
 
 
    /**
     * Check validity of this class.
     *
     * \return              true if valid class; else false
     */
    bool is_valid() const
    {
      return (this->getDictionary() != NULL && JRoot::is_class(this->getTypename()));
    }
 
 
    /**
     * Test equality of ROOT classes.
     *
     * \param  object       ROOT class
     * \return              true if both ROOT classes are same type; else false
     */
    bool equals(const JRootClass& object) const
    {
      return (this-> getTypename() != NULL &&
              object.getTypename() != NULL &&
              strcmp(this->getTypename(), object.getTypename()) == 0);
    }
 
 
    /**
     * Find base class or data member with given name within current class.
     *
     * \param  name         name of base class or data member
     * \param  option       case insensitive
     * \return              ROOT class
     */
    JRootClass find(const char* const name, const bool option = true) const
    {
      if (name != NULL && strlen(name) != 0) {
 
        if (strcmp(getTypename(), name) == 0) {
          return *this;
        }
 
        if (this->getClass() != NULL) {
 
          // check for data members
 
          for (TIter next(this->getClass()->GetListOfDataMembers(kFALSE)); const TDataMember *p = (const TDataMember*) next(); ) {
            if (( option  &&  strcmp    (p->GetName(), name) == 0) ||
                (!option  &&  strcasecmp(p->GetName(), name) == 0)) { 
              return this->get(*p);
            }
          }
          
          // check for base classes
          
          for (TIter next(this->getClass()->GetListOfBases()); const TBaseClass *p = (const TBaseClass*) next(); ) {
            
            if (JRoot::is_class(*p) && !JRoot::is_STLcontainer(*p)) {
              
              JRootClass rcs = this->get(*p);
 
              rcs = rcs.find(name, option);
              
              if (rcs.is_valid()) {
                return rcs;
              }
            }
          }
        }
      }
 
      return JRootClass();  // invalid value
    }
 
 
    /**
     * Get ROOT class of given data member.
     *
     * \param  object       data member
     * \return              ROOT class
     */
    JRootClass get(const TDataMember& object) const
    {
      return JRootClass(TDictionary::GetDictionary(object.GetTypeName()), 
                        this->getOffset() + object.GetOffset());
    }
 
 
    /**
     * Get ROOT class of given base class
     *
     * \param  object       base class
     * \return              ROOT class
     */
    JRootClass get(const TBaseClass& object) const
    {
      return JRootClass(TDictionary::GetDictionary(object.GetName()),
                        this->getOffset() + const_cast<TBaseClass&>(object).GetDelta());
    }
 
 
    /**
     * Print ROOT class information.
     *
     * \param  out          output stream
     */
    inline void print(std::ostream& out) const
    {
      print(out, getTypename());
    }
    
 
  protected:
 
    TDictionary* dictionary;    //!< pointer to ROOT dictionary
    int          offset;        //!< offset with respect to data structure [B]
 
 
    /**
     * Default constructor.
     */
    JRootClass() :
      dictionary(NULL),
      offset(0)
    {}
 
    
    /**
     * Print ROOT class information.
     *
     * \param  out          output stream
     * \param  prefix       prefix
     */
    inline void print(std::ostream& out, const std::string& prefix) const
    {
      if (this->is_valid()) {
 
        print(out, prefix, this->getTypename());
 
        if (this->getClass() != NULL) {
 
          for (TIter next(this->getClass()->GetListOfBases()); const TBaseClass *p = (const TBaseClass*) next(); ) {
            if (!JRoot::is_STLcontainer(*p))
              this->get(*p).print(out, prefix + "::" + p->GetName());
            else
              print(out, prefix + "::" + p->GetName(), this->get(*p).getTypename());
          }
          
          for (TIter next(this->getClass()->GetListOfDataMembers(kFALSE)); const TDataMember *p = (const TDataMember*) next(); ) {
            if (!JRoot::is_STLstring(*p) && !JRoot::is_STLcontainer(*p))
              this->get(*p).print(out, prefix + (JRoot::is_static(*p) ?  "::" : ".") + p->GetName());
            else
              print(out, prefix + (JRoot::is_static(*p) ?  "::" : ".") + p->GetName(), this->get(*p).getTypename());
          }
        }
      }
    }
 
 
    /**
     * Print ROOT class information.
     *
     * \param  out          output stream
     * \param  name         name
     * \param  type         type
     */
    inline static void print(std::ostream& out, const std::string& name, const std::string& type) 
    {
      using namespace std; 
 
      out << name << "  " << '(' << type << ')' << endl;
    }
  };
 
 
  /**
   * Get ROOT data member for given parent and member class.
   *
   * \param  parent       ROOT parent class
   * \param  member       ROOT member class
   * \return              pointer to ROOT data member
   */
  inline const TDataMember* getDataMember(const JRootClass& parent,
                                          const JRootClass& member)
  {
    if (parent.getClass() != NULL) {
 
      for (TIter next(parent.getClass()->GetListOfDataMembers(kFALSE)); const TDataMember *p = (const TDataMember*) next(); ) {
      
        const JRootClass abc = parent.get(*p);
      
        if (abc == member && abc.getOffset() == member.getOffset()) {
          return p;
        }
      }
 
      for (TIter next(parent.getClass()->GetListOfBases()); const TBaseClass *p = (const TBaseClass*) next(); ) {
            
        if (JRoot::is_class(*p) && !JRoot::is_STLcontainer(*p)) {
              
          const TDataMember* q = getDataMember(parent.get(*p), member);
 
          if (q != NULL) {
            return q;
          } 
        }
      }
    }
 
    return NULL;
  }
 
 
  /**
   * Get ROOT data member for given C++ data member.
   *
   * \param  pd           pointer to C++  data member
   * \return              pointer to ROOT data member
   */
  template<class JType_t, class JClass_t>
  inline const TDataMember* getDataMember(JType_t JClass_t::*pd)
  {
    return getDataMember(JRootClass(JType<JClass_t>()), JRootClass(pd));
  }
 
 
  /**
   * Get list of ROOT data members for given class.
   */
  template<class T>
  inline std::vector<TDataMember*> getListOfDataMembers()
  {
    static std::vector<TDataMember*> buffer;
 
    if (buffer.empty()) {
 
      TClass* rc = dynamic_cast<TClass*>(TDictionary::GetDictionary(typeid(T)));
 
      if (rc != NULL) {
        for (TIter next(rc->GetListOfDataMembers(kFALSE)); TDataMember *p = (TDataMember*) next(); ) {
          if (JRoot::is_class(p->GetName())) {
            buffer.push_back(p);
          }
        }
      }
    }
 
    return buffer;
  }
 
 
  /**
   * Auxiliary class to manage access to base classes and data members of ROOT class objects.
   *
   * This class augments the class JRootClass with addressing capabilities.
   */
  template<class JPointer_t>
  struct JRootAddressableClass :
    public JRootClass
  {
    /**
     * Type definition of address.
     */
    typedef JPointer_t  pointer_type;
 
    /**
     * Constructor.
     *
     * \param  object       template object
     */
    template<class T>
    JRootAddressableClass(T& object) :
      JRootClass(JType<T>()),
      address((pointer_type) &object)
    {}
 
 
    /**
     * Get address.
     *
     * \return              pointer to object
     */
    pointer_type getAddress() const
    {
      return this->address + getOffset();
    }
 
 
    /**
     * Check validity of this addressable class.
     *
     * \return              true if valid addressable class; else false
     */
    bool is_valid() const
    {
      return (JRootClass::is_valid() && this->address != NULL);
    }
 
 
    /**
     * Find addressable base class or data member with given name within current class.
     *
     * \param  name         name of base class or data member
     * \return              ROOT addressable class
     */
    JRootAddressableClass find(const char* const name) const
    {
      return JRootAddressableClass(JRootClass::find(name), this->address);
    }
 
 
    /**
     * Get addressable class of given data member.
     *
     * \param  object       data member
     * \return              ROOT addressable class
     */
    JRootAddressableClass get(const TDataMember& object) const
    {
      using namespace std;
 
      if (object.IsaPointer()) {
 
        char* po = NULL;
 
        memcpy(&po, this->getAddress() + object.GetOffset(), sizeof(char*));
 
        return JRootAddressableClass(JRootClass(TDictionary::GetDictionary(object.GetTypeName())), po);
 
      } else if (strstr(object.GetTypeName(), "unique_ptr") != NULL) {
 
        char* po = NULL;
 
        memcpy(&po, this->getAddress() + object.GetOffset(), sizeof(char*));
 
        string buffer(object.GetTypeName());
 
        const string::size_type il = buffer.find_first_of("<");
        const string::size_type ir = buffer.find_first_of(">,");
 
        buffer = buffer.substr(il + 1, ir - il - 1);
 
        return JRootAddressableClass(JRootClass(TDictionary::GetDictionary(buffer.c_str())), po);
 
      } else {
 
        return JRootAddressableClass(JRootClass::get(object), this->address);
      }
    }
 
 
    /**
     * Get addressable class of given base class
     *
     * \param  object       base class
     * \return              ROOT addressable class
     */
    JRootAddressableClass get(const TBaseClass& object) const
    {
      return JRootAddressableClass(JRootClass::get(object), this->address);
    }
 
 
    /**
     * Find addressable base class or data member with given name within current class.
     *
     * \param  name         name of base class or data member
     * \return              ROOT addressable class
     */
    JRootAddressableClass operator[](const char* const name) const
    {
      return this->find(name);
    }
 
 
  protected:
    /**
     * Default constructor.
     */
    JRootAddressableClass() :
      JRootClass(),
      address(NULL)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  rc           ROOT class
     * \param  address      address
     */
    JRootAddressableClass(const JRootClass& rc, pointer_type address) :
      JRootClass(rc),
      address(address)
    {}
 
    pointer_type address;
  };
 
 
  /**
   * ROOT class for reading into object.
   */
  struct JRootReadableClass :
    public JRootAddressableClass<char *>
  {
    /**
     * Default constructor.
     */
    JRootReadableClass() :
      JRootAddressableClass<char *>()
    {}
 
 
    /**
     * Constructor.
     *
     * \param  object       template object
     */
    template<class T>
    JRootReadableClass(T& object) :
      JRootAddressableClass<char *>(object)
    {}
 
 
    /**
     * Copy constructor.
     *
     * \param  rc           ROOT addressable class
     */
    JRootReadableClass(const JRootAddressableClass<char *>& rc) :
      JRootAddressableClass<char *>(rc)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  dictionary   pointer to dictionary
     * \param  address      address
     */
    JRootReadableClass(TDictionary* dictionary, pointer_type address) :
      JRootAddressableClass<char *>(JRootClass(dictionary,0), address)
    {}
 
 
    /**
     * Type conversion operator.
     *
     * \return              value
     */
    template<class T>
    operator const T&() const
    {
      if (static_cast<const JRootClass&>(*this) == JRootClass(JType<T>())) {
        return * (const T*) this->getAddress();
      } else {
        THROW(JCastException, "JRootReadableClass::operator const T&");
      }
    }
 
 
    /**
     * Type conversion operator.
     *
     * \return              value
     */
    template<class T>
    operator T&() 
    {
      if (static_cast<const JRootClass&>(*this) == JRootClass(JType<T>())) {
        return * (T*) this->getAddress();
      } else {
        THROW(JCastException, "JRootReadableClass::operator T&");
      }
    }
  };
 
 
  /**
   * ROOT class for writing from object.
   */
  struct JRootWritableClass :
    public JRootAddressableClass<const char*>
  {
    /**
     * Default constructor.
     */
    JRootWritableClass() :
      JRootAddressableClass<const char *>()
    {}
 
 
    /**
     * Constructor.
     *
     * \param  object       template object
     */
    template<class T>
    JRootWritableClass(const T& object) :
      JRootAddressableClass<const char *>(object)
    {}
 
 
    /**
     * Copy constructor.
     *
     * \param  rc           ROOT addressable class
     */
    JRootWritableClass(const JRootAddressableClass<const char *>& rc) :
      JRootAddressableClass<const char *>(rc)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  dictionary   pointer to dictionary
     * \param  address      address
     */
    JRootWritableClass(TDictionary* dictionary, pointer_type address) :
      JRootAddressableClass<const char *>(JRootClass(dictionary,0), address)
    {}
 
 
    /**
     * Type conversion operator.
     *
     * \return              value
     */
    template<class T>
    operator const T&() const
    {
      if (static_cast<const JRootClass&>(*this) == JRootClass(JType<T>())) {
        return * (const T*) this->getAddress();
      } else {
        THROW(JCastException, "JRootWritableClass::operator const T&");
      }
    }
  };
 
 
  /**
   * ROOT readable class for <tt>TBranch</tt>.
   */
  struct JBranchClass :
    public JRootReadableClass
  {
    /**
     * Default constructor.
     */
    JBranchClass() :
      JRootReadableClass()
    {}
 
 
    /**
     * Copy constructor.
     *
     * \param  bc            branch class
     */
    JBranchClass(const JBranchClass& bc) :
      JRootReadableClass(static_cast<const JRootReadableClass&>(bc))
    {
      this->name = bc.name;
      this->type = bc.type;
 
      if (this->type != kOther_t) {
        this->address = new char[TDataType::GetDataType(this->type)->Size()];
      }
    }
 
 
    /**
     * Constructor.
     *
     * \param  pb            pointer to branch
     */
    JBranchClass(TBranch* pb) :
      JRootReadableClass()
    {
      if (pb != NULL) {
 
        this->name = pb->GetName();
 
        TClass* cs;
 
        if (pb->GetExpectedType(cs, this->type) == 0) {
 
          if (cs != NULL)
            this->dictionary = cs;
          else
            this->dictionary = TDictionary::GetDictionary(TDataType::GetTypeName(this->type));
 
          if (this->type != kOther_t) {
            this->address = new char[TDataType::GetDataType(this->type)->Size()];
          }
        }
      }
    }
 
 
    /**
     * Destructor.
     */
    ~JBranchClass()
    {
      if (this->type != kOther_t) {
        if (this->address != NULL) {
          delete [] this->address;
        }
      }
    }
 
 
    /**
     * Get name.
     *
     * \return               name
     */
    const char* const getName() const
    {
      return this->name.c_str();
    }
 
 
    /**
     * Get type.
     *
     * \return               type
     */
    EDataType getType() const
    {
      return this->type;
    }
 
 
    /**
     * Get branch address.
     * 
     * \return               address
     */
    void* getAddress()
    {
      return (type == kOther_t ? (void*) (&this->address) : (void*) this->address);
    }
 
  private:
    std::string  name;
    EDataType    type  = kNoType_t;
  };
}
 
#endif