GaudiRoot::IOHandler< T > Class Template Reference

Inheritance diagram for GaudiRoot::IOHandler< T >:

Collaboration diagram for GaudiRoot::IOHandler< T >:

Public Member Functions
	IOHandler (TClass *c)
	Initializing constructor.
void	operator() (TBuffer &b, void *obj) override
	ROOT I/O callback.
virtual void	get (TBuffer &b, void *obj)
	Callback for reading the object.
virtual void	put (TBuffer &b, void *obj)
	Callback for writing the object.
void	get (TBuffer &b, void *obj)
void	put (TBuffer &b, void *obj)
void	get (TBuffer &b, void *obj)
void	put (TBuffer &b, void *obj)
void	get (TBuffer &b, void *obj)
void	put (TBuffer &, void *)

Protected Attributes
TClass *	m_root
	ROOT persistent class description.

Detailed Description

template<class T>
class GaudiRoot::IOHandler< T >

Definition at line 64 of file RootIOHandler.cpp.

Constructor & Destructor Documentation

IOHandler()

template<class T>

GaudiRoot::IOHandler< T >::IOHandler ( TClass * c )

inline

Initializing constructor.

Definition at line 71 of file RootIOHandler.cpp.

: m_root( c ) {}

Member Function Documentation

get() [1/4]

template<class T>

virtual void GaudiRoot::IOHandler< T >::get ( TBuffer & b, void * obj )

virtual

Callback for reading the object.

get() [2/4]

void GaudiRoot::IOHandler< SmartRefBase >::get	(	TBuffer &	b,
		void *	obj )

Definition at line 95 of file RootIOHandler.cpp.

                                                           {
    RefAccessor r( obj );
    UInt_t      start, count;
    Version_t   version = b.ReadVersion( &start, &count, m_root );
    m_root->ReadBuffer( b, obj, version, start, count );
    switch ( r.Base->objectType() ) {
    case SmartRefBase::DATAOBJECT:
      ( *r.ObjectRef )( Gaudi::getCurrentDataObject() );
      break;
    case SmartRefBase::CONTAINEDOBJECT:
      ( *r.ContainedRef )( Gaudi::getCurrentDataObject() );
      break;
    default:
      cout << "Hit uninitialized smartRef!!!!" << endl;
      break;
    }
  }

get() [3/4]

void GaudiRoot::IOHandler< ContainedObject >::get	(	TBuffer &	b,
		void *	obj )

Definition at line 171 of file RootIOHandler.cpp.

                                                              {
    UInt_t    start, count;
    Version_t version = b.ReadVersion( &start, &count, m_root );
    m_root->ReadBuffer( b, obj, version, start, count );
    ContainedObject* p = (ContainedObject*)obj;
    p->setParent( (ObjectContainerBase*)Gaudi::getCurrentDataObject() );
  }

get() [4/4]

void GaudiRoot::IOHandler< pool::Token >::get	(	TBuffer &	b,
		void *	obj )

Definition at line 185 of file RootIOHandler.cpp.

                                                        {
    UInt_t       start, count;
    pool::Token* t = (pool::Token*)obj;
    b.ReadVersion( &start, &count, m_root );
    b.ReadFastArray( &t->m_oid.first, 2 );
    b.CheckByteCount( start, count, m_root );
  }

operator()()

template<class T>

void GaudiRoot::IOHandler< T >::operator() ( TBuffer & b, void * obj )

inlineoverride

ROOT I/O callback.

Definition at line 73 of file RootIOHandler.cpp.

                                                      {
      try {
        if ( b.IsReading() )
          get( b, obj );
        else
          put( b, obj );
      } catch ( const exception& e ) {
        string err = "Class:" + string( m_root->GetName() ) + "> Exception in object I/O";
        err += e.what();
        throw runtime_error( err );
      } catch ( ... ) {
        string err = "Class:" + string( m_root->GetName() ) + "> Exception in object I/O";
        throw runtime_error( err );
      }
    }

put() [1/4]

void GaudiRoot::IOHandler< pool::Token >::put	(	TBuffer &	,
		void *	)

Definition at line 194 of file RootIOHandler.cpp.

                                                  {
    throw runtime_error( "Writing POOL files is not implemented!" );
  }

put() [2/4]

template<class T>

virtual void GaudiRoot::IOHandler< T >::put ( TBuffer & b, void * obj )

virtual

Callback for writing the object.

put() [3/4]

void GaudiRoot::IOHandler< SmartRefBase >::put	(	TBuffer &	b,
		void *	obj )

Definition at line 114 of file RootIOHandler.cpp.

                                                           {
    RefAccessor      r( obj );
    ContainedObject* p;
    DataObject *     curr, *pDO;
    int              hint, link;
 
    curr = Gaudi::getCurrentDataObject();
    pDO  = r.ObjectRef->data();
    hint = r.ObjectRef->hintID();
    link = r.ObjectRef->linkID();
    if ( pDO ) {
      switch ( r.Base->objectType() ) {
      case SmartRefBase::CONTAINEDOBJECT:
        p = r.ContainedRef->data();
        if ( p ) {
          const ObjectContainerBase* parent = p->parent();
          if ( parent ) {
            link = p->index();
            pDO  = const_cast<ObjectContainerBase*>( parent );
            break;
          }
        }
        pDO = nullptr;
        cout << "IOHandler<SmartRefBase>::onWrite> "
             << "Found invalid smart reference with object "
             << "having no parent." << endl;
        throw runtime_error( "IOHandler<SmartRefBase>::onWrite> "
                             "Found invalid smart reference with object "
                             "having no parent." );
        break;
      case SmartRefBase::DATAOBJECT:
        link = StreamBuffer::INVALID;
        break;
      default:
        break;
      }
      if ( pDO == last_link_object ) {
        r.Base->set( curr, last_link_hint, link );
        m_root->WriteBuffer( b, obj );
        return;
      } else if ( pDO ) {
        LinkManager* mgr = curr->linkMgr();
        IRegistry*   reg = pDO->registry();
        if ( reg && mgr ) {
          hint             = mgr->addLink( reg->identifier(), pDO );
          last_link_hint   = hint;
          last_link_object = pDO;
        }
      } else {
        hint = link = StreamBuffer::INVALID;
      }
    }
    r.Base->set( curr, hint, link );
    m_root->WriteBuffer( b, obj );
  }

put() [4/4]

void GaudiRoot::IOHandler< ContainedObject >::put	(	TBuffer &	b,
		void *	obj )

Definition at line 180 of file RootIOHandler.cpp.

                                                              {
    m_root->WriteBuffer( b, obj );
  }

Member Data Documentation

m_root

template<class T>

TClass* GaudiRoot::IOHandler< T >::m_root

protected

ROOT persistent class description.

Definition at line 67 of file RootIOHandler.cpp.

---

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

• RootCnv/src/RootIOHandler.cpp