JROOT::JRootReadableClass Struct Reference

ROOT class for reading into object. More...

#include <JRootClass.hh>

Inheritance diagram for JROOT::JRootReadableClass:

Public Types
typedef char *	pointer_type
	Type definition of address.

Public Member Functions
	JRootReadableClass ()
	Default constructor.
template<class T >
	JRootReadableClass (T &object)
	Constructor.
	JRootReadableClass (const JRootAddressableClass< char * > &rc)
	Copy constructor.
	JRootReadableClass (TDictionary *dictionary, pointer_type address)
	Constructor.
template<class T >
	operator const T & () const
	Type conversion operator.
template<class T >
	operator T& ()
	Type conversion operator.
pointer_type	getAddress () const
	Get address.
bool	is_valid () const
	Check validity of this addressable class.
JRootAddressableClass	find (const char *const name) const
	Find addressable base class or data member with given name within current class.
JRootClass	find (const char *const name, const bool option=true) const
	Find base class or data member with given name within current class.
JRootAddressableClass	get (const TDataMember &object) const
	Get addressable class of given data member.
JRootAddressableClass	get (const TBaseClass &object) const
	Get addressable class of given base class.
JRootAddressableClass	operator[] (const char *const name) const
	Find addressable base class or data member with given name within current class.
TDictionary *	getDictionary () const
	Get dictionary.
int	getOffset () const
	Get offset of this class with respect to parent class.
TClass *	getClass () const
	Get class.
const char *	getTypename () const
	Get type name.
bool	equals (const JRootClass &object) const
	Test equality of ROOT classes.
void	print (std::ostream &out) const
	Print ROOT class information.

Protected Member Functions
void	print (std::ostream &out, const std::string &prefix) const
	Print ROOT class information.

Static Protected Member Functions
static void	print (std::ostream &out, const std::string &name, const std::string &type)
	Print ROOT class information.

Protected Attributes
pointer_type	address
TDictionary *	dictionary
	pointer to ROOT dictionary
int	offset
	offset with respect to data structure [B]

Detailed Description

ROOT class for reading into object.

Definition at line 530 of file JRootClass.hh.

Member Typedef Documentation

pointer_type

char * JROOT::JRootAddressableClass< char * >::pointer_type

inherited

Type definition of address.

Definition at line 390 of file JRootClass.hh.

Constructor & Destructor Documentation

JRootReadableClass() [1/4]

JROOT::JRootReadableClass::JRootReadableClass ( )

inline

Default constructor.

Definition at line 536 of file JRootClass.hh.

                         :
      JRootAddressableClass<char *>()
    {}

JRootReadableClass() [2/4]

template<class T >

JROOT::JRootReadableClass::JRootReadableClass ( T & object )

inline

Constructor.

Parameters

object

template object

Definition at line 547 of file JRootClass.hh.

                                  :
      JRootAddressableClass<char *>(object)
    {}

JRootReadableClass() [3/4]

JROOT::JRootReadableClass::JRootReadableClass ( const JRootAddressableClass< char * > & rc )

inline

Copy constructor.

Parameters

rc	ROOT addressable class

Definition at line 557 of file JRootClass.hh.

                                                                :
      JRootAddressableClass<char *>(rc)
    {}

JRootReadableClass() [4/4]

JROOT::JRootReadableClass::JRootReadableClass ( TDictionary * dictionary, pointer_type address )

inline

Constructor.

Parameters

dictionary	pointer to dictionary
address	address

Definition at line 568 of file JRootClass.hh.

                                                                      :
      JRootAddressableClass<char *>(JRootClass(dictionary,0), address)
    {}

Member Function Documentation

operator const T &()

template<class T >

JROOT::JRootReadableClass::operator const T & ( ) const

inline

Type conversion operator.

Returns

value

Definition at line 579 of file JRootClass.hh.

    {
      if (static_cast<const JRootClass&>(*this) == JRootClass(JType<T>())) {
        return * (const T*) this->getAddress();
      } else {
        THROW(JCastException, "JRootReadableClass::operator const T&");
      }
    }

operator T&()

template<class T >

JROOT::JRootReadableClass::operator T& ( )

inline

Type conversion operator.

Returns

value

Definition at line 595 of file JRootClass.hh.

    {
      if (static_cast<const JRootClass&>(*this) == JRootClass(JType<T>())) {
        return * (T*) this->getAddress();
      } else {
        THROW(JCastException, "JRootReadableClass::operator T&");
      }
    }

getAddress()

pointer_type JROOT::JRootAddressableClass< char * >::getAddress ( ) const

inlineinherited

Get address.

Returns

pointer to object

Definition at line 409 of file JRootClass.hh.

    {
      return this->address + getOffset();
    }

is_valid()

bool JROOT::JRootAddressableClass< char * >::is_valid ( ) const

inlineinherited

Check validity of this addressable class.

Returns

true if valid addressable class; else false

Definition at line 420 of file JRootClass.hh.

    {
      return (JRootClass::is_valid() && this->address != NULL);
    }

find() [1/2]

JRootAddressableClass JROOT::JRootAddressableClass< char * >::find ( const char *const name ) const

inlineinherited

Find addressable base class or data member with given name within current class.

Parameters

name	name of base class or data member

Returns

ROOT addressable class

Definition at line 432 of file JRootClass.hh.

    {
      return JRootAddressableClass(JRootClass::find(name), this->address);
    }

find() [2/2]

JRootClass JROOT::JRootClass::find ( const char *const name, const bool option = true ) const

inlineinherited

Find base class or data member with given name within current class.

Parameters

name	name of base class or data member
option	case insensitive

Returns

ROOT class

Definition at line 161 of file JRootClass.hh.

    {
      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() [1/2]

JRootAddressableClass JROOT::JRootAddressableClass< char * >::get ( const TDataMember & object ) const

inlineinherited

Get addressable class of given data member.

Parameters

object

data member

Returns

ROOT addressable class

Definition at line 444 of file JRootClass.hh.

    {
      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() [2/2]

JRootAddressableClass JROOT::JRootAddressableClass< char * >::get ( const TBaseClass & object ) const

inlineinherited

Get addressable class of given base class.

Parameters

object

base class

Returns

ROOT addressable class

Definition at line 484 of file JRootClass.hh.

    {
      return JRootAddressableClass(JRootClass::get(object), this->address);
    }

operator[]()

JRootAddressableClass JROOT::JRootAddressableClass< char * >::operator[] ( const char *const name ) const

inlineinherited

Find addressable base class or data member with given name within current class.

Parameters

name	name of base class or data member

Returns

ROOT addressable class

Definition at line 496 of file JRootClass.hh.

    {
      return this->find(name);
    }

getDictionary()

TDictionary * JROOT::JRootClass::getDictionary ( ) const

inlineinherited

Get dictionary.

Returns

pointer to dictionary

Definition at line 87 of file JRootClass.hh.

    {
      return dictionary;
    }

getOffset()

int JROOT::JRootClass::getOffset ( ) const

inlineinherited

Get offset of this class with respect to parent class.

Returns

offset

Definition at line 98 of file JRootClass.hh.

    {
      return offset;
    }

getClass()

TClass * JROOT::JRootClass::getClass ( ) const

inlineinherited

Get class.

Returns

pointer to class

Definition at line 109 of file JRootClass.hh.

    {
      return dynamic_cast<TClass*>(dictionary);
    }

getTypename()

const char * JROOT::JRootClass::getTypename ( ) const

inlineinherited

Get type name.

Returns

type name

Definition at line 120 of file JRootClass.hh.

    {
      if (dictionary != NULL)
        return dictionary->GetName();
      else
        return NULL;
    }

equals()

bool JROOT::JRootClass::equals ( const JRootClass & object ) const

inlineinherited

Test equality of ROOT classes.

Parameters

object

ROOT class

Returns

true if both ROOT classes are same type; else false

Definition at line 146 of file JRootClass.hh.

    {
      return (this-> getTypename() != NULL &&
              object.getTypename() != NULL &&
              strcmp(this->getTypename(), object.getTypename()) == 0);
    }

print() [1/3]

void JROOT::JRootClass::print ( std::ostream & out ) const

inlineinherited

Print ROOT class information.

Parameters

out	output stream

Definition at line 233 of file JRootClass.hh.

    {
      print(out, getTypename());
    }

print() [2/3]

void JROOT::JRootClass::print ( std::ostream & out, const std::string & prefix ) const

inlineprotectedinherited

Print ROOT class information.

Parameters

out	output stream
prefix	prefix

Definition at line 260 of file JRootClass.hh.

    {
      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() [3/3]

static void JROOT::JRootClass::print ( std::ostream & out, const std::string & name, const std::string & type )

inlinestaticprotectedinherited

Print ROOT class information.

Parameters

out	output stream
name	name
type	type

Definition at line 293 of file JRootClass.hh.

    {
      using namespace std; 
 
      out << name << "  " << '(' << type << ')' << endl;
    }

Member Data Documentation

address

pointer_type JROOT::JRootAddressableClass< char * >::address

protectedinherited

Definition at line 523 of file JRootClass.hh.

dictionary

TDictionary* JROOT::JRootClass::dictionary

protectedinherited

pointer to ROOT dictionary

Definition at line 241 of file JRootClass.hh.

offset

int JROOT::JRootClass::offset

protectedinherited

offset with respect to data structure [B]

Definition at line 242 of file JRootClass.hh.

---

The documentation for this struct was generated from the following file:

• JRootClass.hh