MonitoredGroup.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef AthenaMonitoringKernel_MonitoredGroup_h
#define AthenaMonitoringKernel_MonitoredGroup_h
 
#include <functional>
#include <string>
#include <vector>
#include <stdexcept>
 
#include "GaudiKernel/ToolHandle.h"
 
#include "AthenaMonitoringKernel/GenericMonitoringTool.h"
#include "AthenaMonitoringKernel/IMonitoredVariable.h"
 
namespace Monitored {
  class Group {
  public:
    template <typename... T>
    Group(const ToolHandle<GenericMonitoringTool>& tool, T&&... monitoredGroup) 
      : m_tool(tool),
      m_autoFill(true),
      m_monitoredGroup{monitoredGroup...}
    { }
 
     Group(const ToolHandle<GenericMonitoringTool>& tool, const std::vector<std::reference_wrapper<IMonitoredVariable>>& monitoredGroup)
      : m_tool(tool),
      m_autoFill(true),
      m_monitoredGroup(monitoredGroup)
      { }
 
     Group(const ToolHandle<GenericMonitoringTool>& tool, std::vector<std::reference_wrapper<IMonitoredVariable>>&& monitoredGroup)
      : m_tool(tool),
      m_autoFill(true),
      m_monitoredGroup(std::move(monitoredGroup))
    { }
    
    ~Group() {
      if (m_autoFill) {
        try {
          fill();
        }
        catch (std::exception &) {
          // fill can throw due to dereferencing a Gaudi handle
          //or boost container exception
          std::abort();
        }
      }
    }
 
    void fill() {
      if ( m_tool.empty() ) return;
      setAutoFill(false);
      m_tool->invokeFillers(m_monitoredGroup);
    }
 
    void setAutoFill(bool isEnabled) { m_autoFill = isEnabled; }
 
  protected:
    ToolHandle<GenericMonitoringTool> m_tool;
    bool m_autoFill;
    const std::vector<std::reference_wrapper<IMonitoredVariable>> m_monitoredGroup;
  };
 
  template <typename... T>
  void fill(const ToolHandle<GenericMonitoringTool>& tool, T&&... variables) {
    if (!tool.empty()) {
      tool->invokeFillers({std::forward<T>(variables)...});
    }
  }
 
  // Sub-namespace for internal-use functions
  namespace detail {
    template <typename T = int>
    int findToolIndex( const ToolHandleArray<GenericMonitoringTool>& toolArray, const std::string& name ) {
      auto it = std::find_if(toolArray.begin(),toolArray.end(),[&](const auto& r) {return r.name()==name;});
      return it!=toolArray.end()
        ? std::distance(toolArray.begin(),it)
        : throw std::runtime_error("The tool "+name+" could not be found in the tool array.");
    }
  }
 
  template<typename V,typename std::enable_if_t<std::is_integral_v<V>>* =nullptr>
  std::vector<V> buildToolMap(ToolHandleArray<GenericMonitoringTool> tools, const std::string& baseName, int nHist) {
    std::vector<int> indexArray;
    for ( int iHist=0; iHist<nHist; iHist++ ) {
      std::string groupName = baseName + "_" + std::to_string(iHist);
      indexArray.push_back(detail::findToolIndex(tools,groupName));
    }
    return indexArray;
  }
 
  template<typename V,typename std::enable_if_t<!std::is_integral_v<V>>* =nullptr,typename...T>
  std::vector<V> buildToolMap(ToolHandleArray<GenericMonitoringTool> tools, const std::string& baseName, int nHist, T... dimensions) {
    std::vector<V> indexArray;
    for ( int iHist=0; iHist<nHist; iHist++ ) {
      std::string groupName = baseName + "_" + std::to_string(iHist);
      indexArray.push_back(buildToolMap<typename V::value_type>(tools,groupName,dimensions...));
    }
    return indexArray;
  }
 
  template<typename V,typename std::enable_if_t<std::is_integral_v<V>>* =nullptr>
  std::map<std::string,int> buildToolMap(ToolHandleArray<GenericMonitoringTool> tools, const std::string& baseName, const std::vector<std::string>& labels) {
    std::map<std::string,int> indexMap;
    for ( const std::string& label : labels ) {
      std::string groupName = baseName + "_" + label;
      indexMap[label] = detail::findToolIndex(tools,groupName);
    }
    return indexMap;
  }
 
  template<typename V,typename std::enable_if_t<!std::is_integral_v<V>>* =nullptr,typename...T>
  std::map<std::string,V> buildToolMap(ToolHandleArray<GenericMonitoringTool> tools, const std::string& baseName, const std::vector<std::string>& labels, T... dimensions) {
    std::map<std::string,V> indexMap;
    for ( const std::string& label : labels ) {
      std::string groupName = baseName + "_" + label;
      indexMap[label] = buildToolMap<typename V::mapped_type>(tools,groupName,dimensions...);
    }
    return indexMap;
  }
 
} // namespace Monitored
 
#endif /* AthenaMonitoringKernel_MonitoredGroup_h */