RootAuxDynIO::RNTupleAuxDynReader Class Reference

#include <RNTupleAuxDynReader.h>

Inheritance diagram for RootAuxDynIO::RNTupleAuxDynReader:

Collaboration diagram for RootAuxDynIO::RNTupleAuxDynReader:

Classes
struct	FieldInfo

Public Member Functions
	RNTupleAuxDynReader (const std::string &field_name, const std::string &field_type, ROOT::RNTupleReader *reader)
	create Reader for Aux attributes of an AuxContainer object stored in a given field
void	init (bool standalone)
	initialize once the mode of the Aux store is known
virtual void	addReaderToObject (void *object, size_t row, std::recursive_mutex *iomtx=nullptr) override final
	attach RNTupleAuxStore to the current Aux container @object
FieldInfo &	getFieldInfo (const SG::auxid_t &auxid, const SG::AuxStoreInternal &store)
	get field informatino for auxid
ROOT::RNTupleReader *	getNativeReader ()
virtual	~RNTupleAuxDynReader ()=default
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.
const SG::auxid_set_t &	auxIDs () const
	Aux IDs of all the Aux attributes belonging to the Aux container being read.
bool	addAuxID (const SG::auxid_t &id)
void	addBytes (size_t bytes)
size_t	getBytesRead () const
void	resetBytesRead ()

Protected Attributes
std::string	m_storeFieldName
int	m_storeHolderOffset = -1
bool	m_initialized = false
std::string	m_key
std::map< SG::auxid_t, FieldInfo >	m_fieldInfos
ROOT::RNTupleReader *	m_ntupleReader
SG::auxid_set_t	m_auxids
size_t	m_bytesRead = 0

Private Member Functions
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

Definition at line 22 of file RNTupleAuxDynReader.h.

Constructor & Destructor Documentation

RNTupleAuxDynReader()

RootAuxDynIO::RNTupleAuxDynReader::RNTupleAuxDynReader	(	const std::string &	field_name,
		const std::string &	field_type,
		ROOT::RNTupleReader *	reader )

create Reader for Aux attributes of an AuxContainer object stored in a given field

Definition at line 152 of file RNTupleAuxDynReader.cxx.

      : AthMessaging( std::string("RNTupleAuxDynReader[")+field_name+"]" ),
        m_storeFieldName( field_name ),
        m_ntupleReader( reader )
   {
      const std::string field_prefix = field_type + "_";
      if( m_storeFieldName.rfind( field_type, 0 ) != std::string::npos ) {
         m_key = m_storeFieldName.substr( field_type.size()+1 );
      }
      else if( m_storeFieldName.ends_with( "Aux:" ) ) {
        m_key = m_storeFieldName.substr( 0, m_storeFieldName.size() - 4 );
      }
      ATH_MSG_VERBOSE("field name=" << m_storeFieldName << "  field_prefix=" << field_prefix << "  key=" << m_key);
      TClass *tc = TClass::GetClass( field_type.c_str() );
      if( tc ) {
         TClass *storeTC = tc->GetBaseClass("SG::IAuxStoreHolder");
         if( storeTC ) {
            m_storeHolderOffset = tc->GetBaseClassOffset( storeTC );
         } else {
            throw std::runtime_error(string("Class ") + tc->GetName() +" does not implement SG::IAuxStoreHolder");
         }
      } else {
         throw std::runtime_error(string("Class ") + field_type +" could not be found");
      }
   }

~RNTupleAuxDynReader()

virtual RootAuxDynIO::RNTupleAuxDynReader::~RNTupleAuxDynReader ( )

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 RootAuxDynIO::RNTupleAuxDynReader::addReaderToObject ( void * object, size_t row, std::recursive_mutex * iomtx = nullptr )

finaloverridevirtual

attach RNTupleAuxStore to the current Aux container @object

Implements RootAuxDynIO::IRootAuxDynReader.

Definition at line 285 of file RNTupleAuxDynReader.cxx.

   {
      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 RNTupleAuxDynStore(*this, 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;
}

getBytesRead()

size_t RootAuxDynReader::getBytesRead ( ) const

inlinevirtualinherited

Implements RootAuxDynIO::IRootAuxDynReader.

Definition at line 45 of file RootAuxDynReader.h.

                                    {
   return m_bytesRead;
}

getFieldInfo()

RNTupleAuxDynReader::FieldInfo & RootAuxDynIO::RNTupleAuxDynReader::getFieldInfo	(	const SG::auxid_t &	auxid,
		const SG::AuxStoreInternal &	store )

get field informatino for auxid

Definition at line 220 of file RNTupleAuxDynReader.cxx.

   {
      FieldInfo& fieldInfo = m_fieldInfos[auxid];
      if( fieldInfo.status == FieldInfo::NotInitialized )
      {
         SG::AuxTypeRegistry& reg = SG::AuxTypeRegistry::instance();
         fieldInfo.auxid = auxid;
         fieldInfo.attribName = reg.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_fieldMap test below
         // (`foo_old' will be in this map).  However, in the following
         // else clause, we'll recreate the field name from `foo'.
         // This field 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 field.
         if( reg.inputRename(m_key, fieldInfo.attribName) != fieldInfo.attribName ) {
            fieldInfo.status = FieldInfo::NotFound;
            return fieldInfo;
         }
 
         if( fieldInfo.fieldName.empty() ) {
            // mark initialized here so it remembers this field was not found
            fieldInfo.status = FieldInfo::NotFound;
            return fieldInfo;
         }
 
         if( !store.standalone() and fieldInfo.fieldName.rfind("SG::PackedContainer<", 0) == 0 )
            fieldInfo.isPackedContainer = true;
 
         /*
           string elem_tname, branch_tname;
           const type_info* ti = getAuxElementType( fieldInfo.tclass, typ, store.standalone(),
           elem_tname, branch_tname );
           const type_info* reg_ti = reg.getType(auxid);
           if( ti && ti != reg_ti && strcmp(ti->name(), reg_ti->name()) != 0 )
           {
           // type in registry is different than type in the file.
           // will need to use ROOT auto schema evolution
           fieldInfo.needsSE = true;
           errorcheck::ReportMessage msg (MSG::INFO, ERRORCHECK_ARGS, "RNTupleAuxDynReader");
           msg << "attribute " << fieldInfo.attribName << " (id=" << auxid <<
           " typename=" << SG::AuxTypeRegistry::instance().getType(auxid)->name()
           << ") has different type than the branch " << branch_tname;
 
           const std::type_info *tinf =  store.getIOType(auxid);
           fieldInfo.SE_tclass  = TClass::GetClass(*tinf);
           fieldInfo.SE_edt = kOther_t;
           if( !fieldInfo.SE_tclass  ) {
           fieldInfo.SE_edt = TDataType::GetType(*tinf);
           if( fieldInfo.SE_edt <=0 ) {
           fieldInfo.status = FieldInfo::TypeError;
           throw string("Error getting ROOT type for AUX branch ") + fieldInfo.branch->GetName()
           + " typeinfo=" + tinf->name();
           }
           }
           }
         */
         fieldInfo.status = FieldInfo::Initialized;
      }
      return fieldInfo;
   }

getNativeReader()

ROOT::RNTupleReader * RootAuxDynIO::RNTupleAuxDynReader::getNativeReader ( )

inline

Definition at line 75 of file RNTupleAuxDynReader.h.

                                                                  {
      return m_ntupleReader;
   }

init()

void RootAuxDynIO::RNTupleAuxDynReader::init

(

bool

standalone

)

initialize once the mode of the Aux store is known

Definition at line 183 of file RNTupleAuxDynReader.cxx.

   {
      if( m_initialized )  return;
   
      const SG::AuxTypeRegistry& reg = SG::AuxTypeRegistry::instance();
      const string field_prefix = RootAuxDynIO::auxFieldName("", m_storeFieldName);
      const auto& desc = m_ntupleReader->GetDescriptor();
      for( const auto &f : desc.GetTopLevelFields() ) {
         const string field_name = f.GetFieldName();
         if( field_name.starts_with(field_prefix) ) {
            const string attr_infile = field_name.substr(field_prefix.size());
            const string attr_name = reg.inputRename(m_key, attr_infile);
            const string field_type = f.GetTypeName();
 
            SG::auxid_t auxid = getAuxIdForAttribute(reg, desc, field_prefix,
                                                     attr_name, field_type, standalone);
            // add AuxID to the list
            // May still be null if we don't have a dictionary for this field
            if( auxid != SG::null_auxid ) {
               addAuxID(auxid);
               m_fieldInfos[auxid].fieldName = field_name;
               // Can't use type_info because of default template argument in DataVectors ATEAM-1087
               const std::string& tiname = (standalone and !reg.isLinked(auxid))? reg.getTypeName(auxid) : reg.getVecTypeName(auxid);
               m_fieldInfos[auxid].view = m_ntupleReader->GetView(field_name, nullptr, tiname);
            } else {
               errorcheck::ReportMessage msg (MSG::WARNING, ERRORCHECK_ARGS, "RNTupleAuxDynReader::init");
               msg << "Could not find auxid for " << attr_infile << " type: " << field_type
                   << "  standalone=" << standalone;
            }
         } 
      }
      m_initialized = true;
   }

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 163 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 178 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

resetBytesRead()

void RootAuxDynReader::resetBytesRead ( )

inlinevirtualinherited

Implements RootAuxDynIO::IRootAuxDynReader.

Definition at line 50 of file RootAuxDynReader.h.

                                 {
   m_bytesRead = 0;
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_auxids

SG::auxid_set_t RootAuxDynReader::m_auxids

protectedinherited

Definition at line 31 of file RootAuxDynReader.h.

m_bytesRead

size_t RootAuxDynReader::m_bytesRead = 0

protectedinherited

Definition at line 34 of file RootAuxDynReader.h.

m_fieldInfos

std::map<SG::auxid_t, FieldInfo> RootAuxDynIO::RNTupleAuxDynReader::m_fieldInfos

protected

Definition at line 68 of file RNTupleAuxDynReader.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_initialized

bool RootAuxDynIO::RNTupleAuxDynReader::m_initialized = false

protected

Definition at line 64 of file RNTupleAuxDynReader.h.

m_key

std::string RootAuxDynIO::RNTupleAuxDynReader::m_key

protected

Definition at line 65 of file RNTupleAuxDynReader.h.

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_ntupleReader

ROOT::RNTupleReader* RootAuxDynIO::RNTupleAuxDynReader::m_ntupleReader

protected

Definition at line 71 of file RNTupleAuxDynReader.h.

m_storeFieldName

std::string RootAuxDynIO::RNTupleAuxDynReader::m_storeFieldName

protected

Definition at line 61 of file RNTupleAuxDynReader.h.

m_storeHolderOffset

int RootAuxDynIO::RNTupleAuxDynReader::m_storeHolderOffset = -1

protected

Definition at line 63 of file RNTupleAuxDynReader.h.

---

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

• RNTupleAuxDynReader.h
• RNTupleAuxDynReader.cxx