JRootTypewriter.hh

Go to the documentation of this file.

#ifndef __JROOT_TYPEWRITER__
#define __JROOT_TYPEWRITER__
 
#include <string>
#include <memory>
#include <map>
#include <ostream>
 
#include "TString.h"
#include "TDictionary.h"
#include "TVirtualCollectionProxy.h"
#include "TStreamerInfo.h"
#include "TStreamerElement.h"
#include "TBaseClass.h"
#include "TDataMember.h"
#include "TArray.h"
#include "TArrayC.h"
#include "TArrayS.h"
#include "TArrayI.h"
#include "TArrayL.h"
#include "TArrayF.h"
#include "TArrayD.h"
#include "TList.h"
#include "TDirectory.h"
 
#include "JLang/JTypeList.hh"
#include "JLang/JPrimitiveTypes.hh"
 
#include "JROOT/JRootClass.hh"
 
 
namespace JROOT {}
namespace JPP { using namespace JROOT; }
 
namespace JROOT {
 
  using JLANG::JType;
 
 
  /**
   * Interface for printing of a template class.
   */
  class JAbstractTypewriter {
  public:
    /**
     * Virtual destructor.
     */
    virtual ~JAbstractTypewriter()
    {}
 
    
    /**
     * Print object.
     *
     * \param  out           output stream
     * \param  po            pointer to object
     */
    virtual void print(std::ostream& out, const char* po) const = 0;
  };
  
 
  /**
   * Implementation for printing of a template class.
   *
   * This class implements the JROOT::JAstractTypewriter interface for the given template class.
   */
  template<class T>
  class JObjectTypewriter :
    public JAbstractTypewriter
  {
  public:
    /**
     * Print object.
     *
     * \param  out           output stream
     * \param  po            pointer to object
     */
    virtual void print(std::ostream& out, const char* po) const override
    {
      out << * ((const T*) po);
    }
  };
 
 
  /**
   * Specialisation of print method for <tt>TString</tt>.
   *
   * \param  out           output stream
   * \param  po            pointer to object
   */
  template<>
  void JObjectTypewriter<TString>::print(std::ostream& out, const char* po) const
  {
    const TString* str = (const TString*) po;
 
    if (!str->IsNull()) {
      out << "\"" << *str << "\"";
    }
  }
 
 
  /**
   * Specialisation of print method for <tt>std::string</tt>.
   *
   * \param  out           output stream
   * \param  po            pointer to object
   */
  template<>
  void JObjectTypewriter<std::string>::print(std::ostream& out, const char* po) const
  {
    out << "\"" << * ((const std::string*) po) << "\"";
  }
 
 
  /**
   * Specialisation of print method for <tt>unsigned char</tt>.
   *
   * \param  out           output stream
   * \param  po            pointer to object
   */
  template<>
  void JObjectTypewriter<char>::print(std::ostream& out, const char* po) const
  {
    using namespace std;
 
    out << "0x" << hex << (int) *po << dec;
  }
 
 
  /**
   * Specialisation of print method for <tt>unsigned char</tt>.
   *
   * \param  out           output stream
   * \param  po            pointer to object
   */
  template<>
  void JObjectTypewriter<unsigned char>::print(std::ostream& out, const char* po) const
  {
    using namespace std;
 
    out << "\0x" << hex << (unsigned int) *po << dec;
  }
 
 
  /**
   * ROOT branch class.
   */
  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;
  };
 
 
  /**
   * ROOT type writer.
   */
  class JRootTypewriter :
    public std::map<std::string, std::shared_ptr<JAbstractTypewriter> >
  {
  public:
    /**
     * Default constructor.
     */
    JRootTypewriter()
    {
      using namespace JPP;
 
      for_each<JRemove<JPrimitiveTypes_t, long double>::typelist>(*this);
 
      (*this)(JType<std::string>());
      (*this)(JType<std::size_t>());
 
#define VALUE_TYPE(__TYPE__) value_type(#__TYPE__, new JObjectTypewriter<__TYPE__>())
 
      this->insert(VALUE_TYPE(Char_t));
      this->insert(VALUE_TYPE(UChar_t));
      this->insert(VALUE_TYPE(Short_t));
      this->insert(VALUE_TYPE(UShort_t));
      this->insert(VALUE_TYPE(Int_t));
      this->insert(VALUE_TYPE(UInt_t));
      this->insert(VALUE_TYPE(Long_t));
      this->insert(VALUE_TYPE(ULong_t));
      this->insert(VALUE_TYPE(Long64_t));
      this->insert(VALUE_TYPE(ULong64_t));
      this->insert(VALUE_TYPE(Float_t));
      this->insert(VALUE_TYPE(Double_t));
      this->insert(VALUE_TYPE(TString));
 
#undef VALUE_TYPE
    }
 
 
    /**
     * Print object.
     *
     * \param  out           output stream
     * \param  object        object
     */
    template<class T>
    void operator()(std::ostream& out, const T& object) const
    {
      (*this)(out, JRootWritableClass(object));
    }
    
 
    /**
     * Print object.
     *
     * \param  out           output stream
     * \param  object        object
     */
    void operator()(std::ostream& out, const JRootWritableClass& object) const
    {
      this->print(out, object.getTypename(), object);
    }
 
 
    /**
     * Print object.
     *
     * \param  out           output stream
     * \param  info          pointer to streamer information
     * \param  ps            pointer to data
     */
    void operator()(std::ostream& out, TVirtualStreamerInfo* info, const char* ps) const
    {
      this->print(out, info->GetClass()->GetName(), info, ps);
    }
    
 
    /**
     * Print object.
     *
     * \param  out           output stream
     * \param  object        object
     */
    void operator()(std::ostream& out, const JBranchClass& object) const
    {
      if (object.getClass() != NULL)
        this->print(out, object.getName(), object.getClass()->GetStreamerInfo(), static_cast<const JRootReadableClass&>(object).getAddress());
      else
        this->print(out, object.getName(), object.getDictionary()->GetName(),    static_cast<const JRootReadableClass&>(object).getAddress());
    }
 
 
    /**
     * Addition of class.
     *
     * \param  type          data type
     */
    template<class T>
    void operator()(const JType<T>& type)
    {
      this->insert(value_type(JRoot::getTypename<T>(), new JObjectTypewriter<T>()));
    }
    
 
  protected:
    /**
     * Print object.
     *
     * \param  out           output stream
     * \param  prefix        prefix
     * \param  type          type
     * \param  object        pointer to object
     */
    void print(std::ostream& out, const std::string prefix, const char* type, const char* object) const
    {     
      using namespace std;
 
      const_iterator i1 = this->find(type);
 
      out << prefix;
      out << " <" << type << ">  ";
 
      if (i1 != this->end())
        i1->second->print(out, object);
      else
        out << "?";
 
      out << endl;
    }
    
 
    /**
     * Print array of objects.
     *
     * \param  out           output stream
     * \param  prefix        prefix
     * \param  type          type
     * \param  ps            pointer to begin of array
     * \param  ns            number of elements
     * \param  size          size   of element
     */
    void print(std::ostream& out, const std::string prefix, const char* type, const char* ps, const size_t ns, const size_t size) const
    {
      using namespace std;
 
      const_iterator i1 = this->find(type);
 
      out << prefix;
      out << " <" << type << ">  ";
 
      if (i1 != this->end()) {
 
        for (size_t i = 0; i != ns; ++i) {
          i1->second->print(out, ps + i * size);
        }
 
      } else {
 
        out << "?";
      }
 
      out << endl;
    }
 
 
    /**
     * Print <tt>TArray</tt>.
     *
     * \param  out           output stream
     * \param  prefix        prefix
     * \param  pA            pointer to array
     */
    template<class TArray_t>
    void print(std::ostream& out, const std::string prefix, const TArray* pA) const
    {
      using namespace std;
 
      const TArray_t* p = dynamic_cast<const TArray_t*>(pA);
 
      if (p != NULL) {
        for (Int_t i = 0; i != p->GetSize(); ++i) {
          out << prefix << "[" << i << "]" << ' ' << p->At(i) << endl;
        }
      }
    }
 
 
    /**
     * Print object.
     *
     * \param  out           output stream
     * \param  prefix        prefix
     * \param  object        object
     */
    void print(std::ostream& out, const std::string prefix, const JRootWritableClass& object) const
    {     
      using namespace std;
 
      if (object.is_valid()) {
 
        if (this->count(object.getTypename()) != 0) {
 
          this->print(out, prefix, object.getTypename(), object.getAddress());
 
        } else if (object.getClass() != NULL) {
 
          if        (object.getClass() == TArray::Class()) {
 
            TArray* p = (TArray*) (object.getAddress());
 
            if (p->GetSize() == 0) {
              out << prefix << " <" << p->IsA()->GetName() << "> " << "{}" << endl;
            } else {
              print<TArrayC>(out, prefix, p);
              print<TArrayS>(out, prefix, p);
              print<TArrayI>(out, prefix, p);
              print<TArrayL>(out, prefix, p);
              print<TArrayF>(out, prefix, p);
              print<TArrayD>(out, prefix, p);
            }
 
          } else if (object.getClass() == TList::Class()) {
 
            int i = 0;
 
            for (TIter next((TList*) object.getAddress()); const TObject *p1 = (const TObject*) next(); ++i) {
              print(out, prefix + "[" +  to_string(i) + "]", JRootWritableClass(p1->IsA(), (const char*) p1));
            }
 
          } else if (object.getClass()->GetCollectionProxy() != NULL) {
            
            unique_ptr<TVirtualCollectionProxy> p1(object.getClass()->GetCollectionProxy()->Generate());
 
            p1->PushProxy(const_cast<char*>(object.getAddress()));
 
            if (p1->GetValueClass() == NULL) {
              for (UInt_t i = 0; i != p1->Size(); ++i) {
                this->print(out,  prefix + "[" + to_string(i) + "]", TDataType::GetTypeName(p1->GetType()),  (const char*) p1->At(i));
              }
            } else {
              for (UInt_t i = 0; i != p1->Size(); ++i) {
                this->print(out,  prefix + "[" + to_string(i) + "]", p1->GetValueClass()->GetStreamerInfo(), (const char*) p1->At(i));
              }
            }
 
          } else {
 
            if (object.getClass()->GetListOfBases() != NULL) {
 
              for (TIter next(object.getClass()->GetListOfBases()); const TBaseClass *p1 = (const TBaseClass*) next(); ) {
 
                if (JRoot::is_class(p1->GetName())) {
                  this->print(out, prefix, object.get(*p1));
                }
              }
            }
 
            if (object.getClass()->GetListOfDataMembers() != NULL) {
 
              if (!object.getClass()->InheritsFrom(TClass::GetClass<TArray>())) {
 
                for (TIter next(object.getClass()->GetListOfDataMembers()); const TDataMember *p1 = (const TDataMember*) next(); ) {
 
                  if (JRoot::is_class(p1->GetName()) && !JRoot::is_static(*p1)) {
 
                    if (!p1->IsEnum() && p1->IsPersistent()) {
                      this->print(out, prefix + "." + p1->GetName(), object.get(*p1));
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
 
 
    /**
     * Print object.
     *
     * \param  out           output stream
     * \param  prefix        prefix
     * \param  info          pointer to streamer information
     * \param  ps            pointer to data
     */
    void print(std::ostream& out, const std::string prefix, TVirtualStreamerInfo* info, const char* ps) const
    {
      using namespace std;
 
      if (info != NULL) {
 
        for (TIter next(info->GetElements()); TStreamerElement* ts = dynamic_cast<TStreamerElement*>(next()); ) {
 
          if (this->count(ts->GetTypeName()) != 0) {
 
            if (ts->GetArrayLength() == 0)
              this->print(out, prefix + "." + ts->GetName(), ts->GetTypeName(), ps + ts->GetOffset());
            else
              this->print(out, prefix + "." + ts->GetName(), ts->GetTypeName(), ps + ts->GetOffset(), ts->GetArrayLength(), ts->GetSize() / ts->GetArrayLength());
 
          } else if (ts->GetClass() != NULL) {
 
            if (ts->IsaPointer()) {
 
              char* po = NULL;
 
              memcpy(&po, ps + ts->GetOffset(), sizeof(char*));
 
              if (po != NULL) {
 
                if (ts->GetClass()->InheritsFrom(TList::Class())) {
 
                  this->print(out, prefix + "." +  ts->GetName(), JRootWritableClass(TList::Class(), po));
 
                } else {
                
                  this->print(out, prefix + "." +  ts->GetName(), ts->GetClass()->GetStreamerInfo(), po);
                }
 
              } else {
 
                out << prefix << "." << ts->GetName() << " <" << ts->GetTypeName() << "> " << "NULL" << endl;
              }
 
            } else if (ts->GetClass()->InheritsFrom(TArray::Class())) {
 
              print(out, prefix + "." +  ts->GetName(), JRootWritableClass(TArray::Class(), ps + ts->GetOffset()));
 
            } else if (ts->GetClass()->InheritsFrom(TDirectory::Class())) {
 
              // do nothing
 
            } else if (ts->GetClass()->GetCollectionProxy() != NULL) {
 
              print(out, prefix + "." +  ts->GetName(), JRootWritableClass(ts->GetClass(),  ps + ts->GetOffset()));
 
            } else {
 
              if (JRoot::is_class(ts->GetName())) {
                this->print(out, prefix + "." +  ts->GetName(), ts->GetClass()->GetStreamerInfo(), ps + ts->GetOffset());
              }
            }
          }
        }
      }
    }
  };
}
 
#endif