EventTVirtualEvent.cxx

Go to the documentation of this file.

// Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
//
// File holding the implementation of the xAOD::Event functions that implement
// the TVirtualEvent interface.
//
 
// Local include(s).
#include "xAODRootAccess/Event.h"
 
#include "xAODRootAccess/TActiveStore.h"
#include "xAODRootAccess/TStore.h"
#include "xAODRootAccess/tools/TVirtualManager.h"
#include "xAODRootAccess/tools/Utils.h"
 
namespace xAOD {
 
SG::sgkey_t Event::getHash(const std::string& key) const {
 
  // 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);
}
 
SG::sgkey_t Event::getKey(const void* obj) const {
 
  // Make use of the getName function.
  return getHash(getName(obj));
}
 
const std::string& Event::getName(const void* obj) const {
 
  // 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;
}
 
const std::string& Event::getName(SG::sgkey_t hash) const {
 
  // 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;
}
 
void* Event::getOutputObject(SG::sgkey_t key, const std::type_info& ti) {
 
  // 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);
}
 
const void* Event::getInputObject(SG::sgkey_t key, const std::type_info& ti,
                                  bool silent) {
 
  // 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);
}
 
}  // namespace xAOD