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.
  static constexpr bool QUIET = true;
  if (const EventFormatElement* efe = m_inputEventFormat.get(key, QUIET)) {
    return efe->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 {
 
  // Check the active TStore first, its pointer lookup is cheap.
  const TStore* store = TActiveStore::store();
  if (store && store->contains(obj)) {
    return store->getName(obj);
  }
 
  // Then 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;
    }
  }
 
  // 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:
  static constexpr bool QUIET = true;
  if (const EventFormatElement* efe = m_inputEventFormat.get(hash, QUIET)) {
    return efe->branchName();
  }
 
  // If the branch is known on the output:
  if (const EventFormatElement* efe =
          (m_outputEventFormat ? m_outputEventFormat->get(hash, QUIET)
                               : nullptr)) {
    return efe->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