Gaudi::details::BranchReadHelper Class Reference

#include </builds/gaudi/Gaudi/GaudiUtils/include/Gaudi/details/BranchReadHelper.h>

Collaboration diagram for Gaudi::details::BranchReadHelper:

Public Member Functions
	BranchReadHelper (gsl::not_null< TBranch * > b)
	BranchReadHelper (const BranchReadHelper &other)=delete
BranchReadHelper &	operator= (const BranchReadHelper &other)=delete
	BranchReadHelper (BranchReadHelper &&other) noexcept
BranchReadHelper &	operator= (BranchReadHelper &&other) noexcept
std::unique_ptr< DataObject >	adoptValue ()
	~BranchReadHelper ()

Private Attributes
TBranch *	m_branch { nullptr }
void *	m_store { nullptr }
DataObject *(*	m_extractor )(void *) = nullptr

Detailed Description

Definition at line 34 of file BranchReadHelper.h.

Constructor & Destructor Documentation

BranchReadHelper() [1/3]

Gaudi::details::BranchReadHelper::BranchReadHelper ( gsl::not_null< TBranch * > b )

explicit

Definition at line 20 of file BranchReadHelper.cpp.

                                                              : m_branch( b ) {
    TClass*   clptr    = nullptr;
    EDataType datatype = kNoType_t;
    b->GetExpectedType( clptr, datatype );
    // 64 bits of storage are enough for reading from the TBranch:
    // for simple types, we can just read the value directly into
    // this storage, and for complex types, we can read the address
    // of the object into this storage
    b->SetAddress( &m_store );
 
    // Here we compile a function that converts the value hold in m_store
    // into a DataObject. This is done by directly returning the pointer
    // if the type inherits from DataObject, or by creating a new AnyDataWrapper.
    std::ostringstream code;
    code << "static_cast<DataObject*(*)(void*)>([] (void* store) -> DataObject* {";
    if ( clptr ) {
      // complex type case: store points to an instance of the object
      code << "auto ptr = reinterpret_cast<" << clptr->GetName() << "*>(store);";
      if ( clptr->InheritsFrom( TClass::GetClass<DataObject>() ) ) {
        // for DataObject, just return the pointer
        code << "return ptr;";
      } else {
        // for other complex types, create a new AnyDataWrapper from the object
        code << "return new AnyDataWrapper(std::move(*ptr));";
      }
    } else {
      // simple type case: store is the actual value.
      // std::memcpy is safe because ROOT stores simple small types directly in void*,
      // while for complex objects clptr != nullptr. The check on clptr is equivalent to
      // verifying that the type is trivially copyable and size(value) <= sizeof(void*).
      code << TDataType::GetTypeName( datatype ) << " value;";
      code << "std::memcpy(&value, &store, sizeof(value));";
      code << "return new AnyDataWrapper(std::move(value));";
    }
    code << "})";
    gInterpreter->Declare( "#include <cstring>\n#include <functional>\n#include <GaudiKernel/AnyDataWrapper.h>\n" );
    auto val = gInterpreter->MakeInterpreterValue();
    if ( gInterpreter->Evaluate( code.str().c_str(), *val ) == 0 ) {
      throw std::runtime_error( "Failed to compile code" );
    }
    m_extractor = reinterpret_cast<DataObject* (*)( void* )>( val->GetAsPointer() );
  }

BranchReadHelper() [2/3]

Gaudi::details::BranchReadHelper::BranchReadHelper ( const BranchReadHelper & other )

delete

BranchReadHelper() [3/3]

Gaudi::details::BranchReadHelper::BranchReadHelper ( BranchReadHelper && other )

noexcept

Definition at line 63 of file BranchReadHelper.cpp.

                                                                        {
    m_branch    = other.m_branch;
    m_store     = other.m_store;
    m_extractor = std::move( other.m_extractor );
 
    other.m_branch = nullptr;
    other.m_store  = nullptr;
  }

~BranchReadHelper()

Gaudi::details::BranchReadHelper::~BranchReadHelper

(

)

Definition at line 85 of file BranchReadHelper.cpp.

{ m_branch->SetAddress( nullptr ); }

Member Function Documentation

adoptValue()

std::unique_ptr< DataObject > Gaudi::details::BranchReadHelper::adoptValue

(

)

Definition at line 87 of file BranchReadHelper.cpp.

                                                         {
    std::unique_ptr<DataObject> out( ( *m_extractor )( m_store ) );
    m_store = nullptr;
    return out;
  }

operator=() [1/2]

BranchReadHelper & Gaudi::details::BranchReadHelper::operator= ( BranchReadHelper && other )

noexcept

Definition at line 72 of file BranchReadHelper.cpp.

                                                                                 {
    if ( this == &other ) { return *this; }
 
    m_branch    = other.m_branch;
    m_store     = other.m_store;
    m_extractor = std::move( other.m_extractor );
 
    other.m_branch = nullptr;
    other.m_store  = nullptr;
 
    return *this;
  }

operator=() [2/2]

BranchReadHelper & Gaudi::details::BranchReadHelper::operator= ( const BranchReadHelper & other )

delete

Member Data Documentation

m_branch

TBranch* Gaudi::details::BranchReadHelper::m_branch { nullptr }

private

Definition at line 47 of file BranchReadHelper.h.

{ nullptr };

m_extractor

DataObject *(* Gaudi::details::BranchReadHelper::m_extractor) (void *) = nullptr

private

Definition at line 50 of file BranchReadHelper.h.

m_store

void* Gaudi::details::BranchReadHelper::m_store { nullptr }

private

Definition at line 48 of file BranchReadHelper.h.

{ nullptr };

---

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

• GaudiUtils/include/Gaudi/details/BranchReadHelper.h
• GaudiUtils/src/Lib/BranchReadHelper.cpp