Control/AthContainers/Root/debug.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/

 
 
#include "AthContainers/debug.h"
#include "AthContainers/AuxTypeRegistry.h"
#include "AthContainers/JaggedVecImpl.h"
#include "AthContainers/PackedLinkImpl.h"
#include "AthContainers/tools/error.h"
#include "AthContainersInterfaces/IConstAuxStore.h"
#include "AthLinks/DataLinkBase.h"
#include "AthLinks/ElementLinkBase.h"
#ifndef XAOD_STANDALONE
# include "SGTools/DataProxy.h"
#endif
#include <print>
#include <vector>
#include <sstream>
#include <iostream>
#include <cstring>
 
 
namespace SGdebug {
 

std::string aux_var_name (SG::auxid_t id)
{
  SG::AuxTypeRegistry& reg = SG::AuxTypeRegistry::instance();
  return reg.getClassName(id) + "::" + reg.getName(id);
}
 

void print_aux_var_name (SG::auxid_t id)
{
  std::println ("{}", aux_var_name(id));
}
 
 
/******************************************************************************
 * Print the list of aux variables given some object.
 */
 

void print_aux_vars (const SG::auxid_set_t& auxids,
                     const SG::auxid_set_t& decors,
                     std::ostream& os)
{
  SG::AuxTypeRegistry& reg = SG::AuxTypeRegistry::instance();
  std::vector<SG::auxid_t> ids (auxids.begin(), auxids.end());
  std::sort (ids.begin(), ids.end());
 
  for (SG::auxid_t id : ids) {
    std::print (os , "{} {}::{} [{}",
                id, reg.getClassName(id), reg.getName(id), reg.getTypeName(id));
 
    SG::AuxVarFlags flags = reg.getFlags(id);
    if (flags & SG::AuxVarFlags::Atomic) {
      std::print (os, " (atomic)");
    }
    if (flags & SG::AuxVarFlags::Linked) {
      std::print (os, " (linked)");
    }
    if (decors.test (id)) {
      std::print (os, " (decor)");
    }
 
    std::println (os, "]");
  }
}
 

void print_aux_vars (const SG::auxid_set_t& auxids)
{
  print_aux_vars (auxids, SG::auxid_set_t(), std::cout);
}
 

void print_aux_vars (const SG::IConstAuxStore& store, std::ostream& os)
{
  print_aux_vars (store.getAuxIDs(), store.getDecorIDs(), os);
}
 

void print_aux_vars (const SG::IConstAuxStore& store)
{
  print_aux_vars (store, std::cout);
}
 

void print_aux_vars (const SG::IConstAuxStore* store)
{
  print_aux_vars (*store);
}
 

void print_aux_vars (const SG::AuxVectorData& vec, std::ostream& os)
{
  print_aux_vars (vec.getAuxIDs(), vec.getDecorIDs(), os);
}
 

void print_aux_vars (const SG::AuxVectorData& vec)
{
  print_aux_vars (vec, std::cout);
}
 

void print_aux_vars (const SG::AuxVectorData* vec)
{
  print_aux_vars (*vec);
}
 

void print_aux_vars (const SG::AuxElement& elt)
{
  print_aux_vars (elt.getAuxIDs(), elt.getDecorIDs(), std::cout);
}
 

void print_aux_vars (const SG::AuxElement* elt)
{
  print_aux_vars (*elt);
}
 
 
/******************************************************************************
 * Dump out aux variables.
 */
 
 
namespace {
 
 
template <class T>
void convert (std::ostream& os, const T& x)
{
  std::print (os, "{}", x);
}
 
 
void convert (std::ostream& os, const char x)
{
  std::print (os, "{}", static_cast<int>(x));
}
 
 
void convert (std::ostream& os, const unsigned char x)
{
  std::print (os, "{}", static_cast<unsigned>(x));
}
 
 
void convert (std::ostream& os, const float x)
{
  std::print (os, "{:.3f}", x);
}
 
 
void convert (std::ostream& os, const double x)
{
  std::print (os, "{:.3f}", x);
}
 
 
void convert (std::ostream& os, const SG::JaggedVecEltBase& x, size_t i)
{
  std::print (os, "[{},{}]", x.begin(i), x.end());
}
 
 
void convert (std::ostream& os, const DataLinkBase& x)
{
#ifdef XAOD_STANDALONE
  std::print (os, "DataLink[{}]", x.persKey());
#else
  std::print (os, "DataLink[{}/{}]", x.proxy() ? x.proxy()->clID() : CLID_NULL, x.dataID());
#endif
}
 
 
void convert (std::ostream& os, const ElementLinkBase& x)
{
#ifdef XAOD_STANDALONE
  std::print (os, "ElementLink[{}:{}]", x.persKey(), x.persIndex());
#else
  std::print (os, "ElementLink[{}/{}:{}]", x.proxy() ? x.proxy()->clID() : CLID_NULL, x.dataID(), x.index());
#endif
}
 
 
void convert (std::ostream& os, const SG::PackedLinkBase& x)
{
  std::print (os, "PackedLink[{}/{}]", x.collection(), x.index());
}
 
 
template <class T>
void convert (std::ostream& os, const std::vector<T>& x)
{
  std::print (os, "[");
  bool first = true;
  // using `decltype(auto)` in case T=bool
  // cppcheck-suppress internalAstError
  for (decltype(auto) elt : x) {
    if (first)
      first = false;
    else
      std::print (os, ", ");
    convert (os, elt);
  }
  std::print (os, "]");
}
 
 
struct AuxVarSort
{
  AuxVarSort (SG::auxid_t the_id)
    : id(the_id),
      name(aux_var_name(the_id))
  {}
 
  SG::auxid_t id;
  std::string name;
};
 
 
bool operator< (const AuxVarSort& a, const AuxVarSort& b )
{
  return a.name < b.name;
}
 
 
} // anonymous namespace
 

std::string aux_var_as_string (SG::auxid_t auxid, const void* p, size_t i)
{
  if (!p) {
    return "(null)";
  }
 
  std::ostringstream os;
 
  const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
  const std::type_info* ti = r.getType(auxid);
#define CONVERT(T) if (ti == &typeid(T) || strcmp(ti->name(), typeid(T).name())==0) convert (os, *reinterpret_cast<const T*>(p)); else
#define CONVERT1(T) CONVERT(T) CONVERT(std::vector<T>)
  CONVERT1 (int)
  CONVERT1 (unsigned int)
  CONVERT1 (short)
  CONVERT1 (unsigned short)
  CONVERT1 (char)
  CONVERT1 (unsigned char)
  CONVERT1 (long)
  CONVERT1 (unsigned long)
  CONVERT1 (long long)
  CONVERT1 (unsigned long long)
  CONVERT1 (float)
  CONVERT1 (double)
  CONVERT1 (bool)
  CONVERT1 (std::string)
  //else
  {
    std::string tiname = AthContainers_detail::typeinfoName(*ti);
    if (tiname.starts_with ("SG::JaggedVecElt<")) {
      convert (os, *reinterpret_cast<const SG::JaggedVecEltBase*>(p), i);
    }
    else if (tiname.starts_with ("DataLink<")) {
      convert (os, *reinterpret_cast<const DataLinkBase*>(p));
    }
    else if (tiname.starts_with ("ElementLink<")) {
      convert (os, *reinterpret_cast<const ElementLinkBase*>(p));
    }
    else if (tiname.starts_with ("SG::PackedLink<")) {
      convert (os, *reinterpret_cast<const SG::PackedLinkBase*>(p));
    }
    else if (tiname.starts_with ("std::vector<SG::PackedLink<")) {
      convert (os, *reinterpret_cast<const std::vector<SG::PackedLinkBase>*>(p));
    }
    else {
      std::print (os, "<??? {}>", tiname);
    }
  }
  return os.str();
}
 

void dump_aux_vars (std::ostream& os, const SG::IConstAuxStore& store, size_t i)
{
  if (i >= store.size()) return;
  SG::AuxTypeRegistry& reg = SG::AuxTypeRegistry::instance();
  const SG::auxid_set_t& ids = store.getAuxIDs();
  std::vector<AuxVarSort> vars (ids.begin(), ids.end());
  std::sort (vars.begin(), vars.end());
  for (const AuxVarSort& v : vars) {
    if (reg.isLinked (v.id)) continue;
    const void* pbeg = store.getData (v.id);
    size_t eltsz = reg.getEltSize (v.id);
    const char* p = reinterpret_cast<const char*>(pbeg) + eltsz*i;
    std::println (os, "{} {}",
                v.name, aux_var_as_string (v.id, p, i));
    SG::auxid_t linked_id = reg.linkedVariable (v.id);
    if (linked_id != SG::null_auxid) {
      std::print (os, "  linked: {} ", aux_var_name (linked_id));
      const SG::IAuxTypeVector* lv = store.linkedVector (v.id);
      if (!lv) {
        std::println (os, "(missing linkedVector)");
        continue;
      }
      size_t sz = lv->size();
      const char* lbeg = reinterpret_cast<const char*>(lv->toPtr());
      size_t leltsz = reg.getEltSize (linked_id);
      std::print (os, "[");
      bool first = true;
      for (size_t j = 0; j < sz; j++) {
        if (first)
          first = false;
        else
          std::print (os, ", ");
        const char* p = reinterpret_cast<const char*>(lbeg) + leltsz*j;
        std::print (os, "{}", aux_var_as_string (linked_id, p, i));
      }
      std::println (os, "]");
    }
  }
}
 

void dump_aux_vars (const SG::IConstAuxStore& store, size_t i)
{
  dump_aux_vars (std::cout, store, i);
}
 

void dump_aux_vars (const SG::IConstAuxStore* store, size_t i)
{
  dump_aux_vars (*store, i);
}
 

void dump_aux_vars (const SG::IConstAuxStore& store)
{
  size_t sz = store.size();
  for (size_t i = 0; i < sz; i++) {
    std::println ("=== Element {}", i);
    dump_aux_vars (store, i);
  }
}
 

void dump_aux_vars (const SG::IConstAuxStore* store)
{
  dump_aux_vars (*store);
}
 

void dump_aux_vars (const SG::AuxVectorData& vec, size_t i)
{
  const SG::IConstAuxStore* store = vec.getConstStore();
  if (store)
    dump_aux_vars (*store, i);
}
 

void dump_aux_vars (const SG::AuxVectorData* vec, size_t i)
{
  dump_aux_vars (*vec, i);
}
 

void dump_aux_vars (const SG::AuxVectorData& vec)
{
  const SG::IConstAuxStore* store = vec.getConstStore();
  if (store)
    dump_aux_vars (*store);
}
 

void dump_aux_vars (const SG::AuxVectorData* vec)
{
  dump_aux_vars (*vec);
}
 

void dump_aux_vars (const SG::AuxElement& elt)
{
  const SG::AuxVectorData* cont = elt.container();
  if (cont)
    dump_aux_vars (*cont, elt.index());
}
 

void dump_aux_vars (const SG::AuxElement* elt)
{
  dump_aux_vars (*elt);
}
 
 
} // namespace SG