TBranchAuxDynReader Class Reference

#include <TBranchAuxDynReader.h>

Inheritance diagram for TBranchAuxDynReader:

Collaboration diagram for TBranchAuxDynReader:

Classes
struct	BranchInfo

Public Member Functions
	TBranchAuxDynReader (TTree *tree, TBranch *base_branch)
void	init (bool standalone)
virtual void	addReaderToObject (void *object, size_t ttree_row, std::recursive_mutex *iomtx=nullptr) override final
	Attach specialized AuxStore for reading dynamic attributes. More...
BranchInfo &	getBranchInfo (const SG::auxid_t &auxid, const SG::AuxStoreInternal &store)
virtual	~TBranchAuxDynReader ()=default
const SG::auxid_set_t &	auxIDs () const
	Aux IDs of all the Aux attributes belonging to the Aux container being read. More...
bool	addAuxID (const SG::auxid_t &id)
void	addBytes (size_t bytes)
size_t	getBytesRead () const
void	resetBytesRead ()

Protected Attributes
std::string	m_baseBranchName
int	m_storeHolderOffset = -1
bool	m_initialized = false
std::string	m_key
TTree *	m_tree = nullptr
std::map< std::string, TBranch * >	m_branchMap
std::map< SG::auxid_t, BranchInfo >	m_branchInfos
SG::auxid_set_t	m_auxids
size_t	m_bytesRead = 0

Private Member Functions
SG::auxid_t	initBranch (bool standalone, const std::string &attr, TBranch *branch)

Detailed Description

Definition at line 19 of file TBranchAuxDynReader.h.

Constructor & Destructor Documentation

TBranchAuxDynReader()

TBranchAuxDynReader::TBranchAuxDynReader	(	TTree *	tree,
		TBranch *	base_branch
	)

Definition at line 171 of file TBranchAuxDynReader.cxx.

   : m_baseBranchName( base_branch->GetName() ),
     m_key( getKeyFromBranch(base_branch) ),
     m_tree( tree )
{
   // The Branch here is the object (AuxContainer) branch, not the attribute branch
   TClass *tc = nullptr, *storeTC = nullptr;
   EDataType type;
   (void)base_branch->GetExpectedType(tc, type);    //MN: Errors would be caught in isAuxDynBranch() earlier
   if( tc ) storeTC = tc->GetBaseClass("SG::IAuxStoreHolder");
   if( storeTC ) m_storeHolderOffset = tc->GetBaseClassOffset( storeTC );
   if( m_storeHolderOffset < 0 ) {
      const std::string name = (tc? tc->GetName() : m_baseBranchName);
      errorcheck::ReportMessage msg (MSG::INFO, ERRORCHECK_ARGS, "TBranchAuxDynReader");
      msg << "IAuxStoreHolder interface not found in " << name << " - will not read dynamic attributes";
   }
   
   const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
   string branch_prefix = RootAuxDynIO::auxBranchName("", m_baseBranchName);
   TObjArray *all_branches = m_tree->GetListOfBranches();
   for( int i=0; i<all_branches->GetEntriesFast(); i++ ) {
      const char *bname =  (*all_branches)[i]->GetName();
      if( strncmp(bname, branch_prefix.c_str(), branch_prefix.size()) == 0 ) {
         const string attr_inFile  = bname+branch_prefix.size();
         const string attr = r.inputRename (m_key, attr_inFile);
         m_branchMap[attr] = (TBranch*)(*all_branches)[i];
      }
   }
}

~TBranchAuxDynReader()

virtual TBranchAuxDynReader::~TBranchAuxDynReader ( )

virtualdefault

Member Function Documentation

addAuxID()

bool RootAuxDynReader::addAuxID ( const SG::auxid_t &  id )

inlineinherited

Definition at line 60 of file RootAuxDynReader.h.

                                              {
  if( id != SG::null_auxid ) {
     m_auxids.insert(id);
     return true;
  }
  return false;
}

addBytes()

void RootAuxDynReader::addBytes ( size_t  bytes )

inlineinherited

Definition at line 40 of file RootAuxDynReader.h.

                                       {
   m_bytesRead += bytes;
}

addReaderToObject()

void TBranchAuxDynReader::addReaderToObject ( void *  object, size_t  row, std::recursive_mutex *  iomtx = nullptr  )

finaloverridevirtual

Attach specialized AuxStore for reading dynamic attributes.

Parameters

object	object instance to which the store will be attached to - has to be an instance of the type the reader was created for
ttree_row	Use this method to instrument an AuxStore object AFTER it was read (every time it is read) This will attach its dynamic attributes with read-on-demand capability

Implements RootAuxDynIO::IRootAuxDynReader.

Definition at line 349 of file TBranchAuxDynReader.cxx.

{
   if( m_storeHolderOffset >= 0 ) {
      auto store_holder = reinterpret_cast<SG::IAuxStoreHolder*>((char*)object + m_storeHolderOffset);
      bool standalone { store_holder->getStoreType()==SG::IAuxStoreHolder::AST_ObjectStore };
      if( !m_initialized )
         init(standalone);
      store_holder->setStore( new TBranchAuxDynStore(*this, ttree_row, standalone, iomtx) );
   }
}

auxIDs()

const SG::auxid_set_t & RootAuxDynReader::auxIDs ( ) const

inlineinherited

Aux IDs of all the Aux attributes belonging to the Aux container being read.

Definition at line 55 of file RootAuxDynReader.h.

                               {
    return m_auxids;
}

getBranchInfo()

TBranchAuxDynReader::BranchInfo & TBranchAuxDynReader::getBranchInfo	(	const SG::auxid_t &	auxid,
		const SG::AuxStoreInternal &	store
	)

Definition at line 260 of file TBranchAuxDynReader.cxx.

{
   BranchInfo& brInfo = m_branchInfos[auxid];
   if( brInfo.status == BranchInfo::NotInitialized )
   {
      SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
      brInfo.auxid = auxid;
      brInfo.attribName = r.getName(auxid);
      // Don't match this attribute if it's been renamed.
      // For example, suppose we've renamed attribute `foo' to `foo_old',
      // and someone then comes and asks for `foo'.
      // `foo' will not be found in the m_branchMap test below
      // (`foo_old' will be in this map).  However, in the following
      // else clause, we'll recreate the branch name from `foo'.
      // This branch exists (renaming is only in the transient store),
      // so if we didn't have the condition here, then we'd then
      // make a `foo' attribute from that branch.
      if (r.inputRename (m_key, brInfo.attribName) != brInfo.attribName) {
        brInfo.status = BranchInfo::NotFound;
        return brInfo;
      }
 
      auto it = m_branchMap.find (brInfo.attribName);
      if (it != m_branchMap.end()) {
        brInfo.branch = it->second;
      }
      else {
        const string aux_branch_name = RootAuxDynIO::auxBranchName(brInfo.attribName, m_baseBranchName);
        brInfo.branch = m_tree->GetBranch( aux_branch_name.c_str() );
      }
      
      // mark initialized here so it remembers this branch was not found
      if( !brInfo.branch ) {
         brInfo.status = BranchInfo::NotFound;
         return brInfo;
      }
      if( brInfo.branch->GetExpectedType( brInfo.tclass, brInfo.edtyp) ) {
         brInfo.status = BranchInfo::TypeError;
         throw string("Error getting branch type for ") + brInfo.branch->GetName();
      }
   
      if( !store.standalone() )
         if( brInfo.tclass && strncmp( brInfo.tclass->GetName(), "SG::PackedContainer<", 20) == 0)
            brInfo.isPackedContainer = true;
 
      string elem_tname, branch_tname;
      // AuxElement TypeID
      const std::type_info* ti = getAuxElementType( brInfo.tclass, brInfo.edtyp, store.standalone(),
                                                    elem_tname, branch_tname );
      const std::type_info* reg_ti = r.getType(auxid);
      // I/O / Storage TypeID
      const std::type_info *io_tinf =  store.getIOType(auxid);
      const std::type_info *tcls_tinf = brInfo.tclass ? brInfo.tclass->GetTypeInfo() : ti;
      
      if (not io_tinf){
        brInfo.status = BranchInfo::TypeError;
        throw string("Error getting IO type for AUX branch ") + brInfo.branch->GetName();
      }
      // if there is a TClass compare the whole storage types (usually vectors), because the Element type
      // returned by CollProxy loses the pointer component and element type comparison for vector<T*> fails
      brInfo.needsSE = brInfo.tclass ?
          io_tinf != tcls_tinf && (!tcls_tinf || strcmp(io_tinf->name(), tcls_tinf->name()) != 0)
         : ti && ti != reg_ti && strcmp(ti->name(), reg_ti->name()) != 0;
      if( brInfo.needsSE ) {
         // type in registry is different than type in the file.
         // will need to use ROOT auto schema evolution 
         errorcheck::ReportMessage msg (MSG::INFO, ERRORCHECK_ARGS, "TBranchAuxDynReader");
         msg << "attribute '" << brInfo.attribName << "' (id=" << auxid
             << " typename=" << SG::normalizedTypeinfoName(*reg_ti)
             << ") has different type than the branch: " << branch_tname;
         msg << "  Marking for schema evolution.";
         
         brInfo.SE_tclass  = TClass::GetClass(*io_tinf);
         brInfo.SE_edt = kOther_t;
         if( !brInfo.SE_tclass  ) {
            brInfo.SE_edt = TDataType::GetType(*io_tinf);
            if( brInfo.SE_edt <=0 ) {
               brInfo.status = BranchInfo::TypeError;
               throw string("Error getting ROOT type for AUX branch ") + brInfo.branch->GetName()
                  + " typeinfo=" + io_tinf->name();
            }
         }
      }       
      brInfo.status = BranchInfo::Initialized;
   }
   return brInfo;
}

getBytesRead()

size_t RootAuxDynReader::getBytesRead ( ) const

inlinevirtualinherited

Implements RootAuxDynIO::IRootAuxDynReader.

Definition at line 45 of file RootAuxDynReader.h.

                                    {
   return m_bytesRead;
}

init()

void TBranchAuxDynReader::init

(

bool

standalone

)

Definition at line 247 of file TBranchAuxDynReader.cxx.

{
   if( m_initialized )  return;
   
   for( const auto& attr2branch: m_branchMap ) {
      initBranch (standalone, attr2branch.first, attr2branch.second);
   }
   m_initialized = true;
}

initBranch()

SG::auxid_t TBranchAuxDynReader::initBranch ( bool  standalone, const std::string &  attr, TBranch *  branch  )

private

Definition at line 202 of file TBranchAuxDynReader.cxx.

{
  TClass*       expectedClass = 0;
  EDataType     expectedType = kOther_t;
  if( branch->GetExpectedType(expectedClass, expectedType) != 0) {
    // raise hell
  }
 
  SG::auxid_t linked_auxid = SG::null_auxid;
  if (expectedClass) {
    std::string className = expectedClass->GetName();
    if (SG::AuxTypeRegistry::classNameHasLink (className)) {
      std::string linkedAttr = SG::AuxTypeRegistry::linkedName (attr);
      auto it = m_branchMap.find (linkedAttr);
      if (it != m_branchMap.end()) {
        linked_auxid = initBranch (standalone, linkedAttr, it->second);
      }
      if (linked_auxid == SG::null_auxid) {
        errorcheck::ReportMessage msg (MSG::WARNING, ERRORCHECK_ARGS, "TBranchAuxDynReader::initBranch");
        msg << "Could not find linked variable  for " << branch->GetName()
            << " type: " << expectedClass->GetName();
      }
    }
  }
 
  SG::auxid_t auxid = getAuxIdForAttribute(attr, expectedClass, expectedType, standalone,
                                           linked_auxid);
 
  // add AuxID to the list
  // May still be null if we don't have a dictionary for the branch.
  if (auxid != SG::null_auxid) {
     addAuxID(auxid);
  } else {
    errorcheck::ReportMessage msg (MSG::WARNING, ERRORCHECK_ARGS, "TBranchAuxDynReader::initBranch");
    msg << "Could not find auxid for " << branch->GetName()
        << " type: " << expectedClass->GetName();
 
  }
  return auxid;
}

resetBytesRead()

void RootAuxDynReader::resetBytesRead ( )

inlinevirtualinherited

Implements RootAuxDynIO::IRootAuxDynReader.

Definition at line 50 of file RootAuxDynReader.h.

                                 {
   m_bytesRead = 0;
}

Member Data Documentation

m_auxids

SG::auxid_set_t RootAuxDynReader::m_auxids

protectedinherited

Definition at line 31 of file RootAuxDynReader.h.

m_baseBranchName

std::string TBranchAuxDynReader::m_baseBranchName

protected

Definition at line 56 of file TBranchAuxDynReader.h.

m_branchInfos

std::map<SG::auxid_t, BranchInfo> TBranchAuxDynReader::m_branchInfos

protected

Definition at line 66 of file TBranchAuxDynReader.h.

m_branchMap

std::map<std::string, TBranch*> TBranchAuxDynReader::m_branchMap

protected

Definition at line 64 of file TBranchAuxDynReader.h.

m_bytesRead

size_t RootAuxDynReader::m_bytesRead = 0

protectedinherited

Definition at line 34 of file RootAuxDynReader.h.

m_initialized

bool TBranchAuxDynReader::m_initialized = false

protected

Definition at line 59 of file TBranchAuxDynReader.h.

m_key

std::string TBranchAuxDynReader::m_key

protected

Definition at line 60 of file TBranchAuxDynReader.h.

m_storeHolderOffset

int TBranchAuxDynReader::m_storeHolderOffset = -1

protected

Definition at line 58 of file TBranchAuxDynReader.h.

m_tree

TTree* TBranchAuxDynReader::m_tree = nullptr

protected

Definition at line 62 of file TBranchAuxDynReader.h.

---

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

• TBranchAuxDynReader.h
• TBranchAuxDynReader.cxx