xAOD::Event Class Reference

Base class for the event (xAOD::TEvent and xAOD::REvent) classes. More...

#include <Event.h>

Inheritance diagram for xAOD::Event:

Collaboration diagram for xAOD::Event:

Classes
struct	BranchInfo
	Helper struct used by the IProxyDict code. More...

Public Types
using	sgkey_t = SG::sgkey_t

Public Member Functions
	Event (std::string_view name)
	Constructor with a name. More...
virtual	~Event ()
	Virtual destructor. More...
template<typename T >
bool	retrieve (const T *&obj, sgkey_t key=DEFAULT_KEY, bool silent=false)
	Function retrieving an object from the event (constant version) More...
template<typename T >
bool	retrieve (const T *&obj, const std::string &key, bool silent=false)
	Function retrieving an object from the event (constant version) More...
void	setLevel (MSG::Level lvl)
	Change the current logging level. More...

Static Public Attributes
static constexpr sgkey_t	DEFAULT_KEY = ~static_cast<sgkey_t>(0)
	Key for retrieving the "default" object of a given type. More...
static constexpr sgkey_t	KEY_MASK = DEFAULT_KEY >> 2
	Mask for the keys, used mostly internally. More...

Protected Types
using	Object_t = std::unordered_map< std::string, std::unique_ptr< TVirtualManager > >
	Definition of the internal data structure type. More...

Protected Member Functions
StatusCode	recordTypeless (void *obj, const std::string &typeName, const std::string &key, bool overwrite=false, bool metadata=true, bool isOwner=true)
	Internal function for recording an object into the output. More...
void *	getOutputObject (const std::string &key, const std::type_info &ti, bool metadata) const
	Function for retrieving an output object in a non-template way. More...
const void *	getInputObject (const std::string &key, const std::type_info &ti, bool silent, bool metadata)
	Function for retrieving an input object in a non-template way. More...
bool	contains (const std::string &key, const std::type_info &ti, bool metadata)
	Internal function checking if an object is in the input. More...
bool	transientContains (const std::string &key, const std::type_info &ti, bool metadata) const
	Internal function checking if an object is already in memory. More...
Functions to be implemented by the derived types
virtual bool	hasInput () const =0
	Check if an input file is connected to the object. More...
virtual bool	hasOutput () const =0
	Check if an output file is connected to the object. More...
virtual StatusCode	getNames (const std::string &targetClassName, std::vector< std::string > &vkeys, bool metadata=false) const =0
	Function determining the list keys associated with a type name. More...
virtual StatusCode	connectObject (const std::string &key, bool silent)=0
	Function setting up access to a particular object. More...
virtual StatusCode	connectMetaObject (const std::string &key, bool silent)=0
	Function setting up access to a particular metadata object. More...
virtual StatusCode	connectAux (const std::string &prefix, bool standalone)=0
	Function setting up access to a set of auxiliary branches. More...
virtual StatusCode	connectMetaAux (const std::string &prefix, bool standalone)=0
	Function setting up access to a set of auxiliary branches for a metadata object. More...
virtual StatusCode	setAuxStore (const std::string &key, Details::IObjectManager &mgr, bool metadata)=0
	Function connecting a DV object to its auxiliary store. More...
virtual StatusCode	record (void *obj, const std::string &typeName, const std::string &key, bool overwrite, bool metadata, bool isOwner)=0
	Record an object into a connected output file. More...
virtual StatusCode	recordAux (TVirtualManager &mgr, const std::string &key, bool metadata)=0
	Record an auxiliary store into a connected output file. More...

Protected Attributes
Object_t	m_inputObjects
	Collection of all the managed input objects. More...
std::set< std::string >	m_inputMissingObjects
	Objects that have been asked for, but were found to be missing in the current input. More...
Object_t	m_outputObjects
	Collection of all the managed output object. More...
Object_t	m_inputMetaObjects
	Collection of all the managed input meta-objects. More...
Object_t	m_outputMetaObjects
	Collection of all the managed output meta-objects. More...
EventFormat	m_inputEventFormat
	Format of the current input file. More...
EventFormat *	m_outputEventFormat = nullptr
	Format of the current output file. More...
std::unordered_map< std::string, std::set< std::string > >	m_auxItemList
	Rules for selecting which auxiliary branches to write. More...
std::set< TVirtualIncidentListener * >	m_listeners
	Listeners who should be notified when certain incidents happen. More...
std::unordered_map< std::string, std::string >	m_nameRemapping
	Container name re-mapping rules. More...
bool	m_printEventProxyWarnings = false
	Option to silence common warnings that seem to be harmless. More...

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

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

Friends
class	xAODPrivate::HolderBucket
class	xAODPrivate::Loader

Functions implementing the @c xAOD::TVirtualEvent interface
SG::sgkey_t	getHash (const std::string &key) const override
	Function returning the hash describing an object name. More...
SG::sgkey_t	getKey (const void *obj) const override
	Function returning the hash describing a known object. More...
const std::string &	getName (const void *obj) const override
	Function returning the key describing a known object. More...
const std::string &	getName (SG::sgkey_t hash) const override
	Function returning the key describing a known object. More...
void *	getOutputObject (SG::sgkey_t key, const std::type_info &ti) override
	Function for retrieving an output object in a non-template way. More...
const void *	getInputObject (SG::sgkey_t key, const std::type_info &ti, bool silent) override
	Function for retrieving an input object in a non-template way. More...

Variable(s) used in the @c IProxyDict implementation
using	upgrade_mutex_t = AthContainers_detail::upgrade_mutex
	Mutex type for multithread synchronization. More...
using	upgrading_lock_t = AthContainers_detail::upgrading_lock< upgrade_mutex_t >
	Lock type for multithread synchronization. More...
upgrade_mutex_t	m_branchesMutex
	Mutex for multithread synchronization. More...
SG::SGKeyMap< BranchInfo > m_branches	ATLAS_THREAD_SAFE
	Map from hashed sgkey to BranchInfo. More...

Detailed Description

Base class for the event (xAOD::TEvent and xAOD::REvent) classes.

It implements all the common functionality used by the different storage technologies. Leaving just the technology specific parts to the derived classes.

Definition at line 57 of file Event.h.

Member Typedef Documentation

Object_t

using xAOD::Event::Object_t = std::unordered_map<std::string, std::unique_ptr<TVirtualManager> >

protected

Definition of the internal data structure type.

Definition at line 304 of file Event.h.

sgkey_t

using xAOD::TVirtualEvent::sgkey_t = SG::sgkey_t

inherited

Definition at line 29 of file TVirtualEvent.h.

upgrade_mutex_t

using xAOD::Event::upgrade_mutex_t = AthContainers_detail::upgrade_mutex

protected

Mutex type for multithread synchronization.

Definition at line 349 of file Event.h.

upgrading_lock_t

using xAOD::Event::upgrading_lock_t = AthContainers_detail::upgrading_lock<upgrade_mutex_t>

protected

Lock type for multithread synchronization.

Definition at line 351 of file Event.h.

Constructor & Destructor Documentation

Event()

Event::Event

(

std::string_view

name

)

Constructor with a name.

Parameters

name	Name to use in printed messages

Definition at line 27 of file EventCore.cxx.

    : TVirtualEvent(),
      Details::IProxyDictBase(),
      asg::AsgMessaging(std::string{name}) {
 
  // Make sure that the I/O monitoring is active.
  PerfStats::instance();
 
  // Make this the active event.
  setActive();
}

~Event()

Event::~Event ( )

virtual

Virtual destructor.

Definition at line 39 of file EventCore.cxx.

              {
 
  // If this is set up as the active event at the moment, notify
  // the active event object that this object will no longer be
  // available.
  if (TActiveEvent::event() == this) {
    TActiveEvent::setEvent(nullptr);
  }
#ifndef XAOD_STANDALONE
  if (SG::CurrentEventStore::store() == this) {
    SG::CurrentEventStore::setStore(nullptr);
  }
#endif  // not XAOD_STANDALONE
}

Member Function Documentation

addListener()

StatusCode Event::addListener

(

TVirtualIncidentListener *

listener

)

Register an incident listener object.

This function works pretty much like IIncidentSvc::addListener does in Athena.

It tells the TEvent object that when certain "interesting incidents" happen, a given object should be notified about it.

Parameters

listener

Pointer to the object that should be notified

Returns

The usual StatusCode types

Definition at line 97 of file EventCore.cxx.

                                                                {
 
  // Check that we received a valid pointer:
  if (listener == nullptr) {
    ATH_MSG_ERROR("Received a null pointer for the listener");
    return StatusCode::FAILURE;
  }
 
  // Add the listener.
  if (m_listeners.insert(listener).second == false) {
    ATH_MSG_WARNING("Listener " << static_cast<void*>(listener)
                                << " was added previously already");
  }
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

addNameRemap()

StatusCode Event::addNameRemap	(	const std::string &	onfile,
		const std::string &	newName
	)

Add a name re-mapping rule.

The names of containers can change during the lifetime of the experiment.

One such change happened after the DC14 exercise, when many containers got a new name. (Like "ElectronCollection" became simply "Electrons".)

This function allows us to create aliases with which certain containers should be accessible. So that the analyser would be able to access older files, while using the latest container name(s).

Parameters

onfile	The name of the container as it was saved into the input file
newName	The alias with which the object/container should be accessible

Returns

The usual StatusCode types

Save the new name association:

Definition at line 155 of file EventCore.cxx.

                                                         {
 
  // Check if this name is known on the input or output already. As that's
  // not good.
  if (m_inputEventFormat.exists(newName)) {
    ATH_MSG_ERROR("Can't use \"" << newName << "\" as the target name in the \""
                                 << onfile << "\" -> \"" << newName
                                 << "\" remapping");
    return StatusCode::FAILURE;
  }
 
  // Check if this name was remapped to something already.
  auto itr = m_nameRemapping.find(newName);
  if (itr != m_nameRemapping.end()) {
    ATH_MSG_WARNING("Overriding existing name remapping \""
                    << itr->second << "\" -> \"" << itr->first << "\" with: \""
                    << onfile << "\" -> \"" << newName << "\"");
  }
 
  m_nameRemapping[newName] = onfile;
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

addToStore()

StatusCode Event::addToStore ( CLID  clid, SG::DataProxy *  proxy  )

overrideprotected

Add a new proxy to the store.

Smart pointers to objects that don't exist in the input event, can end up calling this function.

In this case warn the user that something fishy is happening, and take posession of the received proxy.

Parameters

clid	The CLID of the type. Not taken into account.
proxy	The proxy to take posession of. Not used for anything useful.

Definition at line 249 of file EventIProxyDict.cxx.

                                                          {
 
  upgrading_lock_t lock(m_branchesMutex);
 
  // Warn the user that the function got called:
  static std::atomic_flag warningPrinted ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT;
  if (!warningPrinted.test_and_set() && m_printEventProxyWarnings) {
    ATH_MSG_WARNING(
        "Function should only be called through an invalid ElementLink");
  }
 
  // Hold on to the proxy with some non-existent, hopefully unique key:
  const ::TString uniqueKey =
      ::TString::Format("NonExistentKey_%lu", m_branches.size());
  BranchInfo bi;
  bi.m_proxy.reset(proxy);
  lock.upgrade();
  m_branches.insert(
      std::make_pair(stringToKey(uniqueKey.Data(), clid), std::move(bi)));
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

clearListeners()

void Event::clearListeners

(

)

Remove all listeners from the object.

This function can be used to remove all the listeners from the internal list.

Should not be necessary under regular circumstances.

Definition at line 136 of file EventCore.cxx.

                           {
 
  m_listeners.clear();
}

clearNameRemap()

void Event::clearNameRemap

(

)

Clear the current name re-mapping.

This function simply clears out any existing name remapping declarations.

In case the remapping rules need to be changed in the code in some complicated way.

Definition at line 186 of file EventCore.cxx.

                           {
 
  m_nameRemapping.clear();
}

connectAux()

virtual StatusCode xAOD::Event::connectAux ( const std::string &  prefix, bool  standalone  )

protectedpure virtual

Function setting up access to a set of auxiliary branches.

Implemented in xAOD::Experimental::REvent.

connectMetaAux()

virtual StatusCode xAOD::Event::connectMetaAux ( const std::string &  prefix, bool  standalone  )

protectedpure virtual

Function setting up access to a set of auxiliary branches for a metadata object.

Implemented in xAOD::Experimental::REvent.

connectMetaObject()

virtual StatusCode xAOD::Event::connectMetaObject ( const std::string &  key, bool  silent  )

protectedpure virtual

Function setting up access to a particular metadata object.

Implemented in xAOD::Experimental::REvent.

connectObject()

virtual StatusCode xAOD::Event::connectObject ( const std::string &  key, bool  silent  )

protectedpure virtual

Function setting up access to a particular object.

Implemented in xAOD::Experimental::REvent.

contains() [1/2]

template<typename T >

bool xAOD::Event::contains

(

const std::string &

key

)

Function checking if an object is available from the store.

contains() [2/2]

bool xAOD::Event::contains ( const std::string &  key, const std::type_info &  ti, bool  metadata  )

protected

Internal function checking if an object is in the input.

containsMeta()

template<typename T >

bool xAOD::Event::containsMeta

(

const std::string &

key

)

Function checking if a meta-object is available from the store.

copy()

StatusCode Event::copy

(

const std::string &

pattern = ".*"

)

Copy an object directly from the input to the output.

This function can be used to easily copy a given (set of) object/container(s) to the output, without modifying the contents of it/them.

It only needs to be called on the interface object/container(s), the copying of the auxiliary data is done automatically, and is steered by the xAOD::Event::setAuxItemList function.

Parameters

pattern

Regular expression for the key(s)/name(s) of the object(s)/container(s) to copy

Definition at line 28 of file EventIO.cxx.

                                               {
 
  // Tell the user what's happening.
  ATH_MSG_DEBUG("Copying objects matching pattern \"" << pattern
                                                      << "\" to the output");
 
  // Collect a list of keys to copy.
  std::set<std::string> keys;
 
  // The regular expression to use.
  std::regex re{pattern};
 
  // Loop over the known input containers.
  for (const auto& [key, efe] : m_inputEventFormat) {
 
    // Tell the user what's happening.
    ATH_MSG_VERBOSE("Considering input object with key \"" << key << "\"");
 
    // Check if the class in question matches the requested pattern.
    if (std::regex_match(key, re) == false) {
      continue;
    }
    // Ignore objects that don't exist on the input.
    static const bool SILENT = true;
    if (connectObject(key, SILENT).isSuccess() == false) {
      continue;
    }
    // Skip all branches ending in "Aux.":
    if (key.ends_with("Aux.")) {
      continue;
    }
    // Also skip dynamic branches:
    if (efe.parentName() != "") {
      continue;
    }
    // Add the key to the list.
    ATH_MSG_VERBOSE("Matched key \"" << key << "\"");
    keys.insert(key);
  }
 
  // Check if the pattern matches any of the name remapping rules.
  for (const auto& [newname, onfile] : m_nameRemapping) {
 
    // Tell the user what's happening.
    ATH_MSG_VERBOSE("Considering remapped key \"" << newname << "\"");
 
    // Check if the remapped name matches the pattern.
    if (std::regex_match(newname, re) == false) {
      continue;
    }
    // Ignore objects that don't exist on the input.
    static const bool SILENT = true;
    if (connectObject(onfile, SILENT).isSuccess() == false) {
      continue;
    }
    // Add the remapped name to the list.
    ATH_MSG_VERBOSE("Matched remapped key \"" << newname << "\"");
    keys.insert(newname);
  }
 
  // Now loop over all of the found keys.
  for (const std::string& key : keys) {
 
    // Check if a name re-mapping should be applied or not.
    std::string keyToUse = key;
    auto remap_itr = m_nameRemapping.find(key);
    if ((remap_itr != m_nameRemapping.end()) &&
        (!m_inputEventFormat.exists(key)) &&
        m_inputEventFormat.exists(remap_itr->second)) {
      keyToUse = remap_itr->second;
    }
 
    // Make sure that the input object got connected to.
    static const bool SILENT = false;
    ATH_CHECK(connectObject(keyToUse, SILENT));
 
    // Make sure that the input object is properly updated.
    Object_t::const_iterator vobjMgr = m_inputObjects.find(keyToUse);
    if (vobjMgr == m_inputObjects.end()) {
      ATH_MSG_FATAL("Internal logic error detected");
      return StatusCode::FAILURE;
    }
    Details::IObjectManager* objMgr =
        dynamic_cast<Details::IObjectManager*>(vobjMgr->second.get());
    if (objMgr == nullptr) {
      ATH_MSG_FATAL("Internal logic error detected");
      return StatusCode::FAILURE;
    }
    static const bool METADATA = false;
    if (getInputObject(keyToUse, *(objMgr->holder()->getClass()->GetTypeInfo()),
                       SILENT, METADATA) == nullptr) {
      ATH_MSG_FATAL("Internal logic error detected");
      return StatusCode::FAILURE;
    }
 
    // Put the interface object into the output.
    static const bool OVERWRITE = true;
    static const bool IS_OWNER = true;
    ATH_CHECK(record(objMgr->object(), objMgr->holder()->getClass()->GetName(),
                     key, OVERWRITE, METADATA, IS_OWNER));
 
    // If there is also an auxiliary store for this object/container, copy that
    // as well.
    const std::string auxKey = keyToUse + "Aux.";
    if (m_inputObjects.contains(auxKey)) {
      ATH_CHECK(
          recordAux(*(m_inputObjects.at(auxKey)), key + "Aux.", METADATA));
    }
  }
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

dump()

std::string Event::dump

(

)

Function creating a user-readable dump of the current input.

This function behaves exactly like StoreGateSvc::dump().

It doesn't actually print anything to the screen, it just returns a user readable dump of the contents of the current input file/chain.

It is a pretty dumb implementation for the moment. Should be made nicer later on.

Returns

The user-readable contents of the current input file/chain

Definition at line 243 of file EventCore.cxx.

                      {
 
  // The internal stream object.
  std::ostringstream ost;
  ost << "<<<<<<<<<<<<<<<<<<<< xAOD::TEvent Dump >>>>>>>>>>>>>>>>>>>>\n";
 
  // Loop over the input EventFormat object.
  for (const auto& [key, element] : m_inputEventFormat) {
 
    // Get the type.
    ::TClass* cl = ::TClass::GetClass(element.className().c_str());
    const std::type_info* ti = (cl ? cl->GetTypeInfo() : nullptr);
    if ((cl == nullptr) || (cl->IsLoaded() == false) || (ti == nullptr)) {
      ATH_MSG_WARNING("Unknown type (" << element.className()
                                       << ") found in the event format");
      continue;
    }
 
    // Skip containers that are not available anyway.
    static const bool METADATA = false;
    if (!contains(element.branchName(), *ti, METADATA)) {
      continue;
    }
 
    // Do the printout.
    ost << " Hash: 0x" << std::setw(8) << std::setfill('0') << std::hex
        << element.hash() << " Key: \"" << element.branchName() << "\"\n";
 
    ost << "   type: " << element.className() << "\n";
    const bool isNonConst =
        transientContains(element.branchName(), *ti, METADATA);
    ost << "   isConst: " << (isNonConst ? "No" : "Yes") << "\n";
    static const bool SILENT = false;
    ost << "   Data: "
        << (isNonConst
                ? getOutputObject(element.branchName(), *ti, METADATA)
                : getInputObject(element.branchName(), *ti, SILENT, METADATA))
        << "\n";
  }
 
  // Finish with the construction:
  ost << "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>";
  return ost.str();
}

getBranchInfo()

const Event::BranchInfo * Event::getBranchInfo ( SG::sgkey_t  sgkey ) const

protected

Get the object describing one object/branch.

Definition at line 345 of file EventIProxyDict.cxx.

                                                                 {
 
  {
    // We can only hold the lock (even though it's a shared lock) for
    // this limited scope because the call to getInputObject below
    // leads to a recursion and dead-lock if not released immediately.
    upgrading_lock_t lock(m_branchesMutex);
 
    // If the object already exists, return it:
    auto it = m_branches.find(sgkey);
    if (it != m_branches.end()) {
      return &(it->second);
    }
  }
 
  // If not, construct it now:
  BranchInfo bi;
  const xAOD::EventFormatElement* efe = getEventFormatElement(sgkey);
  if (!efe) {
    // Apparently this key is not known:
    return nullptr;
  }
 
  // Helper variable(s).
  static const bool SILENT = true;
  static const bool METADATA = false;
 
  // The name of the requested object.
  const std::string& name = getName(sgkey);
  // This is a bit perverse... In order to let the "base class" figure
  // out the exact type of this object, we ask for it with an "Event
  // pointer". I use that type because I need something that has a
  // dictionary, and which should always be available when this code
  // runs. In the end it doesn't matter that the object can't be
  // retrieved as that type (of course...), it only matters that it gets
  // "set up" following these calls.
  Event* nc_this = const_cast<Event*>(this);
  static const std::type_info& dummy = typeid(Event);
  nc_this->getInputObject(name, dummy, SILENT, METADATA);
  auto itr = m_outputObjects.find(name);
  if (itr == m_outputObjects.end()) {
    itr = m_inputObjects.find(name);
    if (itr == m_inputObjects.end()) {
      // We didn't find this object in the store...
      return nullptr;
    }
  }
  const Details::IObjectManager* mgr =
      dynamic_cast<const Details::IObjectManager*>(itr->second.get());
  if (!mgr) {
    ATH_MSG_ERROR("Internal logic error found");
    return nullptr;
  }
  bi.m_class = mgr->holder()->getClass();
  // There's no need to check whether this is a "proper" dictionary
  // at this point, since if TEvent is holding on to it, the type
  // must have a proper compiled dictionary.
 
#ifndef XAOD_STANDALONE
  // Create a proper proxy for the input branch:
  SG::TransientAddress* taddr = new SG::TransientAddress(
      CLID_NULL, efe->branchName(), new GenericAddress());
  taddr->setSGKey(sgkey);
  xAODPrivate::Loader* loader = new xAODPrivate::Loader(
      *nc_this, getName(sgkey), *bi.m_class->GetTypeInfo());
  bi.m_proxy.reset(new SG::DataProxy(taddr, loader));
  loader->setProxy(*bi.m_proxy.get());
#endif  // not XAOD_STANDALONE
 
  // Add the branch info to our list:
  upgrading_lock_t lock(m_branchesMutex);
  lock.upgrade();
  auto ret = m_branches.insert(std::make_pair(sgkey, std::move(bi)));
 
  // Return a pointer to the branch info:
  return &(ret.first->second);
}

getEventFormatElement()

const xAOD::EventFormatElement * Event::getEventFormatElement ( SG::sgkey_t  sgkey ) const

protected

Get the metadata object for a given "SG key".

Definition at line 319 of file EventIProxyDict.cxx.

                           {
 
  const xAOD::EventFormatElement* efe = nullptr;
  static const bool QUIET = true;
  if (m_outputEventFormat) {
    efe = m_outputEventFormat->get(sgkey, QUIET);
  }
  if (!efe) {
    efe = m_inputEventFormat.get(sgkey, QUIET);
  }
  if (!efe) {
    static SG::SGKeySet missingSGKeys ATLAS_THREAD_SAFE;
    static mutex_t mutex;
    guard_t lock(mutex);
    if (missingSGKeys.emplace(sgkey).second) {
      if (m_printEventProxyWarnings) {
        ATH_MSG_WARNING(
            "Can't find EventFormatElement for hashed SG key: " << sgkey);
      }
      return 0;
    }
  }
  return efe;
}

getHash()

SG::sgkey_t Event::getHash ( const std::string &  key ) const

overridevirtual

Function returning the hash describing an object name.

This helper function is mostly needed by the smart pointers of the xAOD EDM.

Right now it very simply just calculates the hash just based on the key given to the function. But later on it might be good to do some tests here, checking if the event format knows about the specified key or not. This is why it's not made to be a static function

Parameters

key	String key to turn into a hash

Returns

A hash corresponding to the specified string key

Implements xAOD::TVirtualEvent.

Definition at line 27 of file EventTVirtualEvent.cxx.

                                                   {
 
  // For empty keys let's finish quickly.
  if (key == "") {
    return 0;
  }
 
  // If the key is used in the input file, let's use the same hash for
  // the output file as well.
  if (m_inputEventFormat.exists(key)) {
    return m_inputEventFormat.get(key)->hash();
  }
 
  // If it's a new key, make a new hash for it from scratch:
  return Utils::hash(key);
}

getInputObject() [1/2]

const void * Event::getInputObject ( const std::string &  key, const std::type_info &  ti, bool  silent, bool  metadata  )

protected

Function for retrieving an input object in a non-template way.

This is the function doing the heavy lifting to retrieve objects from the input file.

Parameters

key	The key (branch name) of the object to retrieve
ti	The type as which the object is to be retrieved
silent	Set to kTRUE to make the code fail silently in case the object can't be retrieved
metadata	Flag deciding whether we're looking for a metadata or event data object

Returns

A pointer to the input object if successful, or a null pointer if not

Definition at line 218 of file EventIO.cxx.

                                                 {
 
  // Check if a name remapping should be applied or not:
  std::string keyToUse = key;
  auto remap_itr = m_nameRemapping.find(key);
  if ((remap_itr != m_nameRemapping.end()) &&
      (!m_inputEventFormat.exists(key)) &&
      m_inputEventFormat.exists(remap_itr->second)) {
    keyToUse = remap_itr->second;
  }
 
  // The following catches the cases when we ask for a transient
  // ConstDataVector object to be returned as "const DataVector".
  TStore* store = TActiveStore::store();
  if (store && store->contains(keyToUse, ti) && store->isConst(keyToUse, ti)) {
    const void* result = store->getConstObject(keyToUse, ti);
    return result;
  }
 
  // A sanity check before checking for an object from the input file.
  if (hasInput() == false) {
    if (silent == false) {
      ATH_MSG_WARNING("No input file connected to the Event object");
    }
    return nullptr;
  }
 
  // Make sure that the requested input is connected to.
  const StatusCode sc = (metadata ? connectMetaObject(keyToUse, silent)
                                  : connectObject(keyToUse, silent));
  if (sc.isSuccess() == false) {
    return nullptr;
  }
 
  // Select which object container to use:
  Object_t& objects = (metadata ? m_inputMetaObjects : m_inputObjects);
 
  // Access the object's manager:
  auto itr = objects.find(keyToUse);
  if (itr == objects.end()) {
    ATH_MSG_FATAL("There is an internal logic error in the code...");
    return nullptr;
  }
 
  // This has to be an ObjectManager object:
  Details::IObjectManager* mgr =
      dynamic_cast<Details::IObjectManager*>(itr->second.get());
  if (mgr == nullptr) {
    if (key == keyToUse) {
      ATH_MSG_ERROR("Object of wrong type found for key \"" << key << "\"");
    } else {
      ATH_MSG_ERROR("Object of wrong type found for key \""
                    << key << "\"/\"" << keyToUse << "\"");
    }
    return nullptr;
  }
 
  // Make sure that the current entry is loaded for event data objects.
  if (metadata == false) {
    const Int_t readBytes = mgr->getEntry();
    if (readBytes > 0) {
      // Connect the auxiliary store to objects needing it. This call also
      // takes care of updating the dynamic store of auxiliary containers,
      // when they are getting accessed directly.
      static const bool IS_METADATA = false;
      if (setAuxStore(key, *mgr, IS_METADATA).isSuccess() == false) {
        ATH_MSG_ERROR("Failed to set the auxiliary store for "
                      << mgr->holder()->getClass()->GetName() << "/"
                      << keyToUse);
        return nullptr;
      }
    } else if (readBytes < 0) {
      ATH_MSG_ERROR("Failed to load current entry for object "
                    << mgr->holder()->getClass()->GetName() << "/" << keyToUse);
      return nullptr;
    }
  }
 
  // Ask the holder object for the object of this type:
  const void* result = mgr->holder()->getAsConst(ti, silent);
  if (result == nullptr) {
    if (!silent) {
      ATH_MSG_WARNING("Could not retrieve object with key \""
                      << keyToUse << "\" as \""
                      << SG::normalizedTypeinfoName(ti) << "\"");
    }
    return nullptr;
  }
 
  // We succeeded:
  return result;
}

getInputObject() [2/2]

const void * Event::getInputObject ( SG::sgkey_t  key, const std::type_info &  ti, bool  silent  )

overrideprotectedvirtual

Function for retrieving an input object in a non-template way.

This function is used by the TVirtualEvent interface to access an input object with a given hashed key.

The function looks up the string key belonging to the hash, and then calls the other GetInputObject(...) function in the class with that parameter.

Parameters

key	The hashed key of the input object
ti	The type description of the object requested
silent	Switch for being silent about failures or not

Returns

A pointer to the requested object, or a null pointer in case of failure

Implements xAOD::TVirtualEvent.

Definition at line 162 of file EventTVirtualEvent.cxx.

                                               {
 
  // Get a string name for this key:
  const std::string& name = getName(key);
  if (name.empty() && (silent == false)) {
    ATH_MSG_WARNING("Key 0x" << std::hex << key << " unknown");
    return nullptr;
  }
 
  // Forward the call to the function using an std::string key:
  static const bool METADATA = false;
  return getInputObject(name, ti, silent, METADATA);
}

getKey()

SG::sgkey_t Event::getKey ( const void *  obj ) const

overridevirtual

Function returning the hash describing a known object.

This function is used by the smart pointer code to find the identifier of an object that's already in the event in some way.

Parameters

obj	Pointer to the object that we want to look up

Returns

The hashed identifier of the object, or 0 if the object was not found in the event

Implements xAOD::TVirtualEvent.

Definition at line 51 of file EventTVirtualEvent.cxx.

                                             {
 
  // Make use of the getName function.
  return getHash(getName(obj));
}

getName() [1/2]

const std::string & Event::getName ( const void *  obj ) const

overridevirtual

Function returning the key describing a known object.

This function is used by the smart pointer code to find the identifier of an object that's already in the event in some way.

Parameters

obj	Pointer to the object that we want to look up

Returns

The name of the object, or an empty string if the object was not found in the event

Implements xAOD::TVirtualEvent.

Definition at line 64 of file EventTVirtualEvent.cxx.

                                                     {
 
  // First look among the output objects.
  for (const auto& [key, manager] : m_outputObjects) {
    // Check if this is our object.
    if (manager->object() == obj) {
      // If it is, let's return right away.
      return key;
    }
  }
 
  // Now look among the input objects.
  for (const auto& [key, manager] : m_inputObjects) {
    // Check if this is our object.
    if (manager->object() == obj) {
      // If it is, let's return.
      return key;
    }
  }
 
  // If it's not there either, check if it's in an active TStore object:
  const TStore* store = TActiveStore::store();
  if (store && store->contains(obj)) {
    // Get the name from the store then:
    return store->getName(obj);
  }
 
  // We didn't find the object in the event...
  ATH_MSG_WARNING("Didn't find object with pointer \"" << obj
                                                       << "\" in the event");
  static const std::string dummy;
  return dummy;
}

getName() [2/2]

const std::string & Event::getName ( SG::sgkey_t  hash ) const

overridevirtual

Function returning the key describing a known object.

This function is used primarily when getting the string key of a smart pointer that we read in from a file, or access it in memory.

Parameters

hash	The hashed key for the container/object

Returns

The name of the object, or an empty string if the object was not found in the event

Implements xAOD::TVirtualEvent.

Definition at line 105 of file EventTVirtualEvent.cxx.

                                                    {
 
  // If the branch is known from the input:
  if (m_inputEventFormat.exists(hash)) {
    return m_inputEventFormat.get(hash)->branchName();
  }
 
  // If the branch is known on the output:
  if (m_outputEventFormat && m_outputEventFormat->exists(hash)) {
    return m_outputEventFormat->get(hash)->branchName();
  }
 
  // If this is an object in the active store:
  const TStore* store = TActiveStore::store();
  if (store && store->contains(hash)) {
    return store->getName(hash);
  }
 
  // If it is unknown:
  static const std::string dummy;
  return dummy;
}

getNames()

virtual StatusCode xAOD::Event::getNames ( const std::string &  targetClassName, std::vector< std::string > &  vkeys, bool  metadata = false  ) const

protectedpure virtual

Function determining the list keys associated with a type name.

Implemented in xAOD::Experimental::REvent.

getOutputObject() [1/2]

void * Event::getOutputObject ( const std::string &  key, const std::type_info &  ti, bool  metadata  ) const

protected

Function for retrieving an output object in a non-template way.

This function does the heavy lifting of retrieving object from the list of output objects.

While it returns a typeless pointer, that pointer can be cast directly to the type described by the second parameter in the caller code.

Parameters

key	The key (branch name) of the object to retrieve
ti	The type as which the object is to be retrieved
metadata	Flag deciding whether we're looking for a metadata or event data object

Returns

A pointer to the output object if successful, or a null pointer if not

Definition at line 154 of file EventIO.cxx.

                                                  {
 
  // Select which object container to use:
  const Object_t& objects = (metadata ? m_outputMetaObjects : m_outputObjects);
 
  // Check if the object can be found:
  auto itr = objects.find(key);
  if (itr == objects.end()) {
    // Do the following only for event data:
    if (!metadata) {
      // It's not in the event. Let's check if we find it in an active
      // TStore object...
      TStore* store = TActiveStore::store();
      if ((!store) || (!store->contains(key, ti)) || store->isConst(key, ti)) {
        // Nope, not there either...
        return nullptr;
      }
      // Let's return the object from the TStore:
      void* result = store->getObject(key, ti);
      return result;
    } else {
      // For metadata we don't use external resources.
      return nullptr;
    }
  }
 
  // If the object is not set in this event yet, we can't continue:
  if (itr->second->isSet() == false) {
    return nullptr;
  }
 
  // If it does exist, check if it's the right kind of object:
  Details::IObjectManager* mgr =
      dynamic_cast<Details::IObjectManager*>(itr->second.get());
  if (mgr == nullptr) {
    ATH_MSG_ERROR("Object of wrong type found for key \"" << key << "\"");
    return nullptr;
  }
 
  // Ask the holder object for the object of this type:
  void* result = mgr->holder()->getAs(ti);
  if (result == nullptr) {
    ATH_MSG_WARNING("Couldn't retrieve object as \""
                    << SG::normalizedTypeinfoName(ti) << "\"");
    return nullptr;
  }
 
  // Return the object:
  return result;
}

getOutputObject() [2/2]

void * Event::getOutputObject ( SG::sgkey_t  key, const std::type_info &  ti  )

overrideprotectedvirtual

Function for retrieving an output object in a non-template way.

This function is used by the TVirtualEvent interface to access an output object with a given hashed key.

The function looks up the string key belonging to the hash, and then calls the other GetOutputObject(...) function in the class with that parameter.

Parameters

key	The hashed key of the output object
ti	The type description of the object requested

Returns

A pointer to the requested object, or a null pointer in case of failure

Implements xAOD::TVirtualEvent.

Definition at line 138 of file EventTVirtualEvent.cxx.

                                                                  {
 
  // Get a string name for this key.
  const std::string& name = getName(key);
  if (name.empty()) {
    return nullptr;
  }
 
  // Forward the call to the function using an std::string key.
  static const bool METADATA = false;
  return getOutputObject(name, ti, METADATA);
}

hasInput()

virtual bool xAOD::Event::hasInput ( ) const

protectedpure virtual

Check if an input file is connected to the object.

Implemented in xAOD::Experimental::REvent.

hasOutput()

virtual bool xAOD::Event::hasOutput ( ) const

protectedpure virtual

Check if an output file is connected to the object.

Implemented in xAOD::Experimental::REvent.

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();
  m_lvl = m_imsg ?
    static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
    MSG::INFO;
}

inputEventFormat()

const EventFormat * Event::inputEventFormat

(

)

const

Get information about the input objects.

Definition at line 221 of file EventCore.cxx.

                                                 {
 
  if (hasInput()) {
    return &m_inputEventFormat;
  }
  return nullptr;
}

keys()

template<typename T >

StatusCode xAOD::Event::keys	(	std::vector< std::string > &	vkeys,
		bool	metadata
	)		const

Provide a list of all data object keys associated with a specific type.

keyToString() [1/2]

const std::string * Event::keyToString ( SG::sgkey_t  key ) const

overrideprotected

Find the string corresponding to a given key.

Definition at line 292 of file EventIProxyDict.cxx.

                                                       {
 
  return &(getName(key));
}

keyToString() [2/2]

const std::string * Event::keyToString ( SG::sgkey_t  key, CLID &  clid  ) const

overrideprotected

Find the string and CLID corresponding to a given key.

Definition at line 297 of file EventIProxyDict.cxx.

                                                              {
 
  return &(getName(key));
}

metaKeys()

template<typename T >

StatusCode xAOD::Event::metaKeys

(

std::vector< std::string > &

vkeys

)

const

Provide a list of all metadata object keys associated with a specific type.

msg() [1/2]

MsgStream & asg::AsgMessaging::msg ( ) const

inherited

The standard message stream.

Returns

A reference to the default message stream of this object.

Definition at line 49 of file AsgMessaging.cxx.

                                      {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg();
#else // not XAOD_STANDALONE
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msg() [2/2]

MsgStream & asg::AsgMessaging::msg ( const MSG::Level  lvl ) const

inherited

The standard message stream.

Parameters

lvl	The message level to set the stream to

Returns

A reference to the default message stream, set to level "lvl"

Definition at line 57 of file AsgMessaging.cxx.

                                                          {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msg( lvl );
#else // not XAOD_STANDALONE
      m_msg << lvl;
      return m_msg;
#endif // not XAOD_STANDALONE
   }

msgLvl()

bool asg::AsgMessaging::msgLvl ( const MSG::Level  lvl ) const

inherited

Test the output level of the object.

Parameters

lvl	The message level to test against

Returns

boolean Indicting if messages at given level will be printed

true If messages at level "lvl" will be printed

Definition at line 41 of file AsgMessaging.cxx.

                                                       {
#ifndef XAOD_STANDALONE
      return ::AthMessaging::msgLvl( lvl );
#else // not XAOD_STANDALONE
      return m_msg.msgLevel( lvl );
#endif // not XAOD_STANDALONE
   }

name()

const std::string & Event::name ( ) const

overrideprotected

Get the name of the instance.

Definition at line 313 of file EventIProxyDict.cxx.

                                   {
 
  static const std::string result{"xAOD::Event"};
  return result;
}

outputEventFormat()

const EventFormat * Event::outputEventFormat

(

)

const

Get information about the output objects.

Definition at line 229 of file EventCore.cxx.

                                                  {
 
  return m_outputEventFormat;
}

printIOStats()

void Event::printIOStats

(

)

const

Function printing the I/O statistics of the current process.

This is a convenience function for printing basic I/O information about the current job.

It can be called at the end of a job to get an overview of what the job did exactly I/O-wise.

Definition at line 291 of file EventCore.cxx.

                               {
 
  // Simply do this via the xAODCore code:
  IOStats::instance().stats().Print("Summary");
}

printNameRemap()

void Event::printNameRemap

(

)

const

Print the current name re-mapping rules.

This function can be used for debugging, to check what container/object name remapping rules are in place for the current TEvent object.

Definition at line 194 of file EventCore.cxx.

                                 {
 
  // Print a header.
  ATH_MSG_INFO("Name remapping rules:");
 
  // In case no remapping rules have been set.
  if (m_nameRemapping.empty()) {
    ATH_MSG_INFO("   NONE");
    return;
  }
 
  // Otherwise.
  for (const auto& [newName, onfile] : m_nameRemapping) {
    ATH_MSG_INFO("   \"" << newName << "\" -> \"" << onfile << "\"");
  }
}

printProxyWarnings()

void Event::printProxyWarnings

(

bool

value = true

)

Enable warnings associated with broken element links.

These appear harmless so long as you don't actually try to access the links.

Which will cause other errors anyway.

Parameters

value

The new value for the option

Definition at line 216 of file EventCore.cxx.

                                         {
 
  m_printEventProxyWarnings = value;
}

proxies()

std::vector< const SG::DataProxy * > Event::proxies ( ) const

overrideprotected

return the list of all current proxies in store

Definition at line 273 of file EventIProxyDict.cxx.

                                                   {
 
  upgrading_lock_t lock(m_branchesMutex);
 
  std::vector<const SG::DataProxy*> ret;
  for (const auto& p : m_branches) {
    const SG::DataProxy* proxy = p.second.m_proxy.get();
    if (proxy) {
      ret.push_back(proxy);
    }
  }
  return ret;
}

proxy() [1/2]

SG::DataProxy * Event::proxy ( const CLID &  id, const std::string &  key  ) const

overrideprotected

get proxy with given id and key. Returns 0 to flag failure

Definition at line 211 of file EventIProxyDict.cxx.

                                                                 {
 
  const SG::sgkey_t sgkey = getHash(key);
  if (!sgkey) {
    return 0;
  }
  return proxy_exact(sgkey);
}

proxy() [2/2]

SG::DataProxy * Event::proxy ( const void *const  pTransient ) const

overrideprotected

get proxy for a given data object address in memory

Definition at line 183 of file EventIProxyDict.cxx.

                                                            {
 
  // Look up the name of this object
  std::string name = getName(pTransient);
  if (name.empty()) {
    // Apparently the object is not known...
    return nullptr;
  }
 
  // Get the metadata object for it:
  const xAOD::EventFormatElement* efe = 0;
  static const bool QUIET = true;
  if (m_outputEventFormat) {
    efe = m_outputEventFormat->get(name, QUIET);
  }
  if (!efe) {
    efe = m_inputEventFormat.get(name, QUIET);
  }
  if (!efe) {
    // No metadata found...
    return nullptr;
  }
 
  // Return the proxy:
  const BranchInfo* bi = getBranchInfo(efe->hash());
  return bi->m_proxy.get();
}

proxy_exact()

SG::DataProxy * Event::proxy_exact ( SG::sgkey_t  sgkey ) const

overrideprotected

Get proxy given a hashed key+clid.

Definition at line 220 of file EventIProxyDict.cxx.

                                                     {
 
  // Get the object describing this branch/object:
  const BranchInfo* bi = getBranchInfo(sgkey);
  if (!bi) {
    static SG::SGKeySet missingSGKeys ATLAS_THREAD_SAFE;
    static mutex_t mutex;
    guard_t lock(mutex);
    if (missingSGKeys.emplace(sgkey).second && m_printEventProxyWarnings) {
      ATH_MSG_WARNING("Can't find BranchInfo for: " << sgkey);
    }
    return 0;
  }
 
  // Access its data proxy:
  SG::DataProxy* proxy = bi->m_proxy.get();
 
  // Return the proxy:
  return proxy;
}

record() [1/3]

template<typename T >

StatusCode xAOD::Event::record	(	std::unique_ptr< T >	obj,
		const std::string &	key
	)

Add an output object to the event, explicitly taking ownership of it.

record() [2/3]

template<typename T >

StatusCode xAOD::Event::record	(	T *	obj,
		const std::string &	key
	)

Add an output object to the event.

record() [3/3]

virtual StatusCode xAOD::Event::record ( void *  obj, const std::string &  typeName, const std::string &  key, bool  overwrite, bool  metadata, bool  isOwner  )

protectedpure virtual

Record an object into a connected output file.

Implemented in xAOD::Experimental::REvent.

recordAux()

virtual StatusCode xAOD::Event::recordAux ( TVirtualManager &  mgr, const std::string &  key, bool  metadata  )

protectedpure virtual

Record an auxiliary store into a connected output file.

Implemented in xAOD::Experimental::REvent.

recordMeta() [1/2]

template<typename T >

StatusCode xAOD::Event::recordMeta	(	std::unique_ptr< T >	obj,
		const std::string &	key
	)

Add an object to the output file's metadata, explicitly taking ownership of it.

recordMeta() [2/2]

template<typename T >

StatusCode xAOD::Event::recordMeta	(	T *	obj,
		const std::string &	key
	)

Add an object to the output file's metadata.

recordObject()

SG::DataProxy * Event::recordObject ( SG::DataObjectSharedPtr< DataObject >  obj, const std::string &  key, bool  allowMods, bool  returnExisting  )

overrideprotected

Record an object in the store.

Definition at line 307 of file EventIProxyDict.cxx.

                                                                 {
 
  throw std::runtime_error("xAOD::Event::recordObject is not implemented");
}

recordTypeless()

StatusCode xAOD::Event::recordTypeless ( void *  obj, const std::string &  typeName, const std::string &  key, bool  overwrite = false, bool  metadata = true, bool  isOwner = true  )

protected

Internal function for recording an object into the output.

registerKey()

void Event::registerKey ( SG::sgkey_t  key, const std::string &  str, CLID  clid  )

overrideprotected

Remember an additional mapping from key to string/CLID.

Definition at line 302 of file EventIProxyDict.cxx.

                                                         {
 
  return;
}

removeListener()

StatusCode Event::removeListener

(

TVirtualIncidentListener *

listener

)

Remove an incident listener object.

This function allows us to remove a listener when for instance a metadata tool is deleted during a job.

Parameters

listener

Pointer to the listener that should be removed

Returns

The usual StatusCode types

Definition at line 121 of file EventCore.cxx.

                                                                   {
 
  // Remove the listener. Or at least try to...
  if (m_listeners.erase(listener) != 1u) {
    ATH_MSG_ERROR("Listener " << static_cast<void*>(listener) << " not known");
    return StatusCode::FAILURE;
  }
 
  // Return gracefully:
  return StatusCode::SUCCESS;
}

retrieve() [1/4]

template<typename T >

StatusCode xAOD::Event::retrieve	(	const T *&	obj,
		const std::string &	key
	)

Retrieve either an input or an output object from the event.

retrieve() [2/4]

template<typename T >

bool xAOD::TVirtualEvent::retrieve ( const T *&  obj, const std::string &  key, bool  silent = false  )

inherited

Function retrieving an object from the event (constant version)

retrieve() [3/4]

template<typename T >

bool xAOD::TVirtualEvent::retrieve ( const T *&  obj, sgkey_t  key = DEFAULT_KEY, bool  silent = false  )

inherited

Function retrieving an object from the event (constant version)

retrieve() [4/4]

template<typename T >

StatusCode xAOD::Event::retrieve	(	T *&	obj,
		const std::string &	key
	)

Retrieve an output object from the event.

retrieveMetaInput()

template<typename T >

StatusCode xAOD::Event::retrieveMetaInput	(	const T *&	obj,
		const std::string &	key
	)

Retrieve an input metadata object.

retrieveMetaOutput() [1/2]

template<typename T >

StatusCode xAOD::Event::retrieveMetaOutput	(	const T *&	obj,
		const std::string &	key
	)

Retrieve an output metadata object.

retrieveMetaOutput() [2/2]

template<typename T >

StatusCode xAOD::Event::retrieveMetaOutput	(	T *&	obj,
		const std::string &	key
	)

Retrieve an output metadata object.

setActive()

void Event::setActive

(

)

const

Set this event object as the currently active one.

Definition at line 54 of file EventCore.cxx.

                            {
 
  // The active event and current store are thread-local globals.
  Event* nc_this ATLAS_THREAD_SAFE = const_cast<Event*>(this);
  TActiveEvent::setEvent(static_cast<TVirtualEvent*>(nc_this));
#ifndef XAOD_STANDALONE
  SG::CurrentEventStore::setStore(nc_this);
#endif  // not XAOD_STANDALONE
}

setAuxItemList()

void Event::setAuxItemList	(	const std::string &	containerKey,
		const std::string &	itemList
	)

Configure which dynamic variables to write out for a given store.

This function receives the rules for selecting which dynamic auxiliary branches should be written for a given container, in the exact same format in which we need to set it in the Athena output ItemList.

Parameters

containerKey	The name of the auxiliary container in question
itemList	The variable list according to the formatting rules

Definition at line 71 of file EventCore.cxx.

                                                      {
 
  // Decoded attributes.
  std::set<std::string> attributes;
 
  // Split up the received string using "." as the separator.
  if (itemList.size()) {
    std::istringstream ss(itemList);
    std::string attr;
    while (std::getline(ss, attr, '.')) {
      attributes.insert(attr);
    }
  }
 
  // Remember the setting.
  m_auxItemList[containerKey] = std::move(attributes);
}

setAuxStore()

virtual StatusCode xAOD::Event::setAuxStore ( const std::string &  key, Details::IObjectManager &  mgr, bool  metadata  )

protectedpure virtual

Function connecting a DV object to its auxiliary store.

Implemented in xAOD::Experimental::REvent.

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;
}

stringToKey()

SG::sgkey_t Event::stringToKey ( const std::string &  str, CLID  clid  )

overrideprotected

Find the string corresponding to a given key.

Definition at line 287 of file EventIProxyDict.cxx.

                                                       {
 
  return getHash(str);
}

transientContains() [1/2]

template<typename T >

bool xAOD::Event::transientContains

(

const std::string &

key

)

const

Function checking if an object is already in memory.

transientContains() [2/2]

bool xAOD::Event::transientContains ( const std::string &  key, const std::type_info &  ti, bool  metadata  ) const

protected

Internal function checking if an object is already in memory.

transientContainsMeta()

template<typename T >

bool xAOD::Event::transientContainsMeta

(

const std::string &

key

)

const

Function checking if a meta-object is already in memory.

Friends And Related Function Documentation

xAODPrivate::HolderBucket

friend class xAODPrivate::HolderBucket

friend

Definition at line 62 of file Event.h.

xAODPrivate::Loader

friend class xAODPrivate::Loader

friend

Definition at line 63 of file Event.h.

Member Data Documentation

ATLAS_THREAD_SAFE

SG::SGKeyMap<BranchInfo> m_branches xAOD::Event::ATLAS_THREAD_SAFE

mutableprotected

Map from hashed sgkey to BranchInfo.

Definition at line 358 of file Event.h.

DEFAULT_KEY

constexpr sgkey_t xAOD::TVirtualEvent::DEFAULT_KEY = ~static_cast<sgkey_t>(0)

staticconstexprinherited

Key for retrieving the "default" object of a given type.

Definition at line 35 of file TVirtualEvent.h.

KEY_MASK

constexpr sgkey_t xAOD::TVirtualEvent::KEY_MASK = DEFAULT_KEY >> 2

staticconstexprinherited

Mask for the keys, used mostly internally.

Definition at line 37 of file TVirtualEvent.h.

m_auxItemList

std::unordered_map<std::string, std::set<std::string> > xAOD::Event::m_auxItemList

protected

Rules for selecting which auxiliary branches to write.

Definition at line 326 of file Event.h.

m_branchesMutex

upgrade_mutex_t xAOD::Event::m_branchesMutex

mutableprotected

Mutex for multithread synchronization.

Definition at line 354 of file Event.h.

m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

m_inputEventFormat

EventFormat xAOD::Event::m_inputEventFormat

protected

Format of the current input file.

Definition at line 321 of file Event.h.

m_inputMetaObjects

Object_t xAOD::Event::m_inputMetaObjects

protected

Collection of all the managed input meta-objects.

Definition at line 316 of file Event.h.

m_inputMissingObjects

std::set<std::string> xAOD::Event::m_inputMissingObjects

protected

Objects that have been asked for, but were found to be missing in the current input.

Definition at line 311 of file Event.h.

m_inputObjects

Object_t xAOD::Event::m_inputObjects

protected

Collection of all the managed input objects.

Definition at line 308 of file Event.h.

m_listeners

std::set<TVirtualIncidentListener*> xAOD::Event::m_listeners

protected

Listeners who should be notified when certain incidents happen.

Definition at line 329 of file Event.h.

m_lvl

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

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

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_nameRemapping

std::unordered_map<std::string, std::string> xAOD::Event::m_nameRemapping

protected

Container name re-mapping rules.

Definition at line 332 of file Event.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_outputEventFormat

EventFormat* xAOD::Event::m_outputEventFormat = nullptr

protected

Format of the current output file.

Definition at line 323 of file Event.h.

m_outputMetaObjects

Object_t xAOD::Event::m_outputMetaObjects

protected

Collection of all the managed output meta-objects.

Definition at line 318 of file Event.h.

m_outputObjects

Object_t xAOD::Event::m_outputObjects

protected

Collection of all the managed output object.

Definition at line 313 of file Event.h.

m_printEventProxyWarnings

bool xAOD::Event::m_printEventProxyWarnings = false

protected

Option to silence common warnings that seem to be harmless.

Definition at line 335 of file Event.h.

---

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

• Event.h
• EventCore.cxx
• EventIO.cxx
• EventIProxyDict.cxx
• EventTVirtualEvent.cxx