ROOT class for writing from object. More...

#include <JRootClass.hh>

Inheritance diagram for JROOT::JRootWritableClass:

Public Types
typedef const char *	pointer_type
	Type definition of address.

Public Member Functions
	JRootWritableClass ()
	Default constructor.

template<class T >
	JRootWritableClass (const T &object)
	Constructor.

	JRootWritableClass (const JRootAddressableClass< const char * > &rc)
	Copy constructor.

	JRootWritableClass (TDictionary *dictionary, pointer_type address)
	Constructor.

template<class T >
	operator const T & () const
	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 writing from object.

Definition at line 609 of file JRootClass.hh.

Member Typedef Documentation

◆ pointer_type

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

inherited

Type definition of address.

Definition at line 390 of file JRootClass.hh.

Constructor & Destructor Documentation

◆ JRootWritableClass() [1/4]

JROOT::JRootWritableClass::JRootWritableClass ( )

inline

Default constructor.

Definition at line 615 of file JRootClass.hh.

                         :
      JRootAddressableClass<const char *>()
    {}

◆ JRootWritableClass() [2/4]

template<class T >

JROOT::JRootWritableClass::JRootWritableClass ( const T & object )

inline

Constructor.

Parameters

object template object

Definition at line 626 of file JRootClass.hh.

                                        :
      JRootAddressableClass<const char *>(object)
    {}

◆ JRootWritableClass() [3/4]

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

inline

Copy constructor.

Parameters

rc	ROOT addressable class

Definition at line 636 of file JRootClass.hh.

                                                                      :
      JRootAddressableClass<const char *>(rc)
    {}

◆ JRootWritableClass() [4/4]

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

inline

Constructor.

Parameters

dictionary	pointer to dictionary
address	address

Definition at line 647 of file JRootClass.hh.

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

Member Function Documentation

◆ operator const T &()

template<class T >

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

inline

Type conversion operator.

Returns: value

Definition at line 658 of file JRootClass.hh.

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

◆ getAddress()

pointer_type JROOT::JRootAddressableClass< const 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< const 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< const 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< const 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< const 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< const 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< const 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

Public Types

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ pointer_type

Constructor & Destructor Documentation

◆ JRootWritableClass() [1/4]

◆ JRootWritableClass() [2/4]

◆ JRootWritableClass() [3/4]

◆ JRootWritableClass() [4/4]

Member Function Documentation

◆ operator const T &()

◆ getAddress()

◆ is_valid()

◆ find() [1/2]

◆ find() [2/2]

◆ get() [1/2]

◆ get() [2/2]

◆ operator[]()

◆ getDictionary()

◆ getOffset()

◆ getClass()

◆ getTypename()

◆ equals()

◆ print() [1/3]

◆ print() [2/3]

◆ print() [3/3]

Member Data Documentation

◆ address

◆ dictionary

◆ offset