Control/AthContainers/Root/debug.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#include "AthContainers/debug.h"
#include "AthContainers/AuxTypeRegistry.h"
#include "AthContainers/tools/error.h"
#include "AthContainersInterfaces/IConstAuxStore.h"
#include "CxxUtils/StrFormat.h"
#include <vector>
#include <sstream>
#include <iostream>
 
 
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::cout << aux_var_name(id) << "\n";
}
 
 
/******************************************************************************
 * Print the list of aux variables given some object.
 */
 
 
void print_aux_vars (const SG::auxid_set_t& auxids)
{
  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::cout << id << " "
              << reg.getClassName(id) << "::" << reg.getName(id) << " "
              << "[" << reg.getTypeName(id);
 
    SG::AuxVarFlags flags = reg.getFlags(id);
    if (flags & SG::AuxVarFlags::Atomic) {
      std::cout << " (atomic)";
    }
 
    std::cout << "]\n";
  }
}
 
 
void print_aux_vars (const SG::IConstAuxStore& store)
{
  print_aux_vars (store.getAuxIDs());
}
 
 
void print_aux_vars (const SG::IConstAuxStore* store)
{
  print_aux_vars (*store);
}
 
 
void print_aux_vars (const SG::AuxVectorData& vec)
{
  print_aux_vars (vec.getAuxIDs());
}
 
 
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());
}
 
 
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)
{
  os << x;
}
 
 
void convert (std::ostream& os, const float x)
{
  os << CxxUtils::strformat ("%.3f", x);
}
 
 
void convert (std::ostream& os, const double x)
{
  os << CxxUtils::strformat ("%.3f", x);
}
 
 
template <class T>
void convert (std::ostream& os, const std::vector<T>& x)
{
  os << "[";
  bool first = true;
  // using `decltype(auto)` in case T=bool
  // cppcheck-suppress internalAstError
  for (decltype(auto) elt : x) {
    if (first)
      first = false;
    else
      os << ", ";
    convert (os, elt);
  }
  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)
{
  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)) 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
    os << "<??? " << AthContainers_detail::typeinfoName(*ti) << ">";
  return os.str();
}
 
 
void dump_aux_vars (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) {
    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::cout << v.name << " " << aux_var_as_string (v.id, p) << "\n";
  }
}
 
 
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::cout << "=== Element " << i << "\n";
    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