MonitoredCollection.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef AthenaMonitoringKernel_MonitoredCollection_h
#define AthenaMonitoringKernel_MonitoredCollection_h
 
#include <functional>
#include <type_traits>
#include <vector>
 
#include "AthenaMonitoringKernel/IMonitoredVariable.h"
 
namespace Monitored {
 
  // Forward declares
  template <class T> class ValuesCollection;
  template <class T> class ValuesRefCollection;
  template <class T, class R> class ObjectsCollection;
  template <class T, class R> class ObjectsRefCollection;

  template <class T> ValuesCollection<T> Collection(std::string name, const T& collection) {
    return ValuesCollection<T>(std::move(name), collection);
  }
 
  // Disallow temporaries
  template <class T> ValuesCollection<T> Collection(std::string name, T const&& collection) = delete;

  template <class T> ValuesRefCollection<T> Collection(std::string name, const std::reference_wrapper<T>& collection) {
    return ValuesRefCollection<T>(std::move(name), collection);
  }
 
  // Disallow temporaries
  template <class T> ValuesRefCollection<T> Collection(std::string name, const std::reference_wrapper<T>&& collection) = delete;
 

  template <class T>
  ObjectsCollection<T, double>
  Collection(std::string name, const T& collection,
             std::function<double(const typename ObjectsCollection<T, double>::const_value_type&)> accessor) {
    return ObjectsCollection<T, double>(std::move(name), collection, std::move(accessor));
  }
 
  template <class T>
  ObjectsCollection<T, double>
  Collection(std::string name, const T&& collection,
             std::function<double(const typename ObjectsCollection<T, double>::const_value_type&)> accessor) = delete;
 
 
  template <class T>
  ObjectsCollection<T, std::string>
  Collection(std::string name, const T& collection,
         std::function<std::string(const typename ObjectsCollection<T, std::string>::const_value_type&)> accessor) {
    return ObjectsCollection<T, std::string>(std::move(name), collection, std::move(accessor));
  }
 
  template <class T>
  ObjectsCollection<T, std::string>
  Collection(std::string name, const T&& collection,
             std::function<std::string(const typename ObjectsCollection<T, std::string>::const_value_type&)> accessor) = delete;
 

  template <class T>
  ObjectsRefCollection<T, double>
  Collection(std::string name, const std::reference_wrapper<T>& collection,
               std::function<double(const typename ObjectsRefCollection<T, double>::const_value_type&)> accessor) {
    return ObjectsRefCollection<T, double>(std::move(name), collection, std::move(accessor));
  }
 
  template <class T>
  ObjectsRefCollection<T, double>
  Collection(std::string name, const std::reference_wrapper<T>&& collection,
             std::function<double(const typename ObjectsRefCollection<T, double>::const_value_type&)> accessor) = delete;
 
  template <class T>
  ObjectsRefCollection<T, std::string>
  Collection(std::string name, const std::reference_wrapper<T>& collection,
         std::function<std::string(const typename ObjectsRefCollection<T, std::string>::const_value_type&)> accessor) {
    return ObjectsRefCollection<T, std::string>(std::move(name), collection, std::move(accessor));
  }
 
  template <class T>
  ObjectsRefCollection<T, std::string>
  Collection(std::string name, const std::reference_wrapper<T>&& collection,
             std::function<std::string(const typename ObjectsRefCollection<T, std::string>::const_value_type&)> accessor) = delete;
 
 
  namespace detail {
    template <typename T> struct get_value_type { typedef typename T::value_type value_type; };
    template <typename T, size_t N> struct get_value_type<T[N]> { typedef T value_type; };
    
    template <typename T> struct get_value_type<std::reference_wrapper<T>> { typedef typename T::value_type value_type; };
    template <typename T, size_t N> struct get_value_type<std::reference_wrapper<T[N]>> { typedef T value_type; };
 
    template <typename T> struct make_pointer_const { typedef T type; };
    template <typename T> struct make_pointer_const<T*> { typedef const T* type; };
  } // namespace detail
 

  template <class T> class ValuesCollection : public IMonitoredVariable {
  public:
    using value_type = typename detail::get_value_type<T>::value_type;
 
    static_assert(std::is_convertible<value_type, double>::value or std::is_constructible<std::string, value_type>::value, "Conversion of collection values to double or string is impossible");
 
    // @brief .     \if empty doc string required due to https://github.com/doxygen/doxygen/issues/6251 \endif
    friend ValuesCollection<T> Collection<T>(std::string name, const T& collection);
    friend ValuesCollection<T> Collection<T>(std::string name, const T&& collection);
 
    ValuesCollection(ValuesCollection&&) = default;
 
    virtual double get([[maybe_unused]] size_t i) const override {
      if constexpr (std::is_convertible_v<value_type, double>)
        return m_collection[i];
      else
        return -1;
    }
 
    virtual std::string getString([[maybe_unused]] size_t i) const override {
      if constexpr (std::is_constructible_v<std::string, value_type>)
        return m_collection[i];
      else
        return {};
    }
 
    virtual bool hasStringRepresentation() const override {
      return std::is_constructible<std::string, value_type>::value;
    }
 
    virtual size_t size() const override {
      return std::size(m_collection);
    }
 
  private:
    const T& m_collection;
 
 
    ValuesCollection(std::string vname, const T& collection)
      : IMonitoredVariable(std::move(vname)), m_collection{collection} {
    }
 
    ValuesCollection(ValuesCollection const&) = delete;
    ValuesCollection& operator=(ValuesCollection const&) = delete;
  };
 

  template <class T> class ValuesRefCollection : public IMonitoredVariable {
  public:
    using value_type = typename detail::get_value_type<T>::value_type;
 
    static_assert(std::is_convertible<value_type, double>::value or std::is_constructible<std::string, value_type>::value, "Conversion of collection values to double or string is impossible");
 
    // @brief .     \if empty doc string required due to https://github.com/doxygen/doxygen/issues/6251 \endif
    friend ValuesRefCollection<T> Collection<T>(std::string name, const std::reference_wrapper<T>& collection);
    friend ValuesRefCollection<T> Collection<T>(std::string name, const std::reference_wrapper<T>&& collection);
 
    ValuesRefCollection(ValuesRefCollection&&) = default;
 
    virtual double get([[maybe_unused]] size_t i) const override {
      if constexpr (std::is_convertible_v<value_type, double>)
        return m_collection.get()[i];
      else
        return -1;
    }
 
    virtual std::string getString([[maybe_unused]] size_t i) const override {
      if constexpr (std::is_constructible_v<std::string, value_type>)
        return m_collection.get()[i];
      else
        return {};
    }
 
    virtual bool hasStringRepresentation() const override {
      return std::is_constructible<std::string, value_type>::value;
    }
 
    virtual size_t size() const override {
      return std::size(m_collection.get());
    }
 
  private:
    const std::reference_wrapper<T>& m_collection;
 
 
    ValuesRefCollection(std::string vname, const std::reference_wrapper<T>& collection)
      : IMonitoredVariable(std::move(vname)), m_collection{collection} {
    }
 
    ValuesRefCollection(ValuesRefCollection const&) = delete;
    ValuesRefCollection& operator=(ValuesRefCollection const&) = delete;
  };
 

  template <class T, class R> class ObjectsCollection : public IMonitoredVariable {
  public:
    using value_type = typename detail::get_value_type<T>::value_type;
    using const_value_type = typename detail::make_pointer_const<value_type>::type;
 
    static_assert(std::is_convertible<R, double>::value or std::is_constructible<std::string, R>::value, "Conversion from type returned by the converter/accessor to double or string is impossible");
 
    // @brief .     \if empty doc string required due to https://github.com/doxygen/doxygen/issues/6251 \endif
    template <class U> friend ObjectsCollection<U, double>
    Collection(std::string name, const U& collection,
               std::function<double(const typename ObjectsCollection<U, double>::const_value_type&)> accessor);
 
    template <class U> friend ObjectsCollection<U, std::string>
    Collection(std::string name, const U& collection,
               std::function<std::string(const typename ObjectsCollection<U, std::string>::const_value_type&)> converterToString);
 
    ObjectsCollection(ObjectsCollection&&) = default;
 
    virtual double get([[maybe_unused]] size_t i) const override {
      if constexpr (std::is_convertible_v<R, double>)
        return m_converterToR(m_collection[i]);
      else
        return -1;
    }
 
    virtual std::string getString([[maybe_unused]] size_t i) const override {
      if constexpr (std::is_constructible_v<std::string, R>)
        return m_converterToR(m_collection[i]);
      else
        return {};
    }
 
    virtual bool hasStringRepresentation() const override {
      return std::is_constructible<std::string, R>::value;
    };
    virtual size_t size() const override {
      return std::size(m_collection);
    }
 
  private:
    const T& m_collection;
    std::function<R(const const_value_type&)> m_converterToR;
 
    ObjectsCollection(std::string name, const T& collection,
                      std::function<R(const const_value_type&)> converterToR)
        : IMonitoredVariable(std::move(name)),
      m_collection(collection),
          m_converterToR(std::move(converterToR)) {}
 
    ObjectsCollection(ObjectsCollection const&) = delete;
 
    ObjectsCollection& operator=(ObjectsCollection const&) = delete;
 
  };
 

  template <class T, class R> class ObjectsRefCollection : public IMonitoredVariable {
  public:
    using value_type = typename detail::get_value_type<T>::value_type;
    using const_value_type = typename detail::make_pointer_const<value_type>::type;
 
    static_assert(std::is_convertible<R, double>::value or std::is_constructible<std::string, R>::value, "Conversion from type returned by the converter/accessor to double or string is impossible");
 
    // @brief .     \if empty doc string required due to https://github.com/doxygen/doxygen/issues/6251 \endif
    template <class U> friend ObjectsRefCollection<U, double>
    Collection(std::string name, const std::reference_wrapper<U>& collection,
               std::function<double(const typename ObjectsRefCollection<U, double>::const_value_type&)> accessor);
 
    template <class U> friend ObjectsRefCollection<U, std::string>
    Collection(std::string name, const std::reference_wrapper<U>& collection,
               std::function<std::string(const typename ObjectsRefCollection<U, std::string>::const_value_type&)> converterToString);
 
    ObjectsRefCollection(ObjectsRefCollection&&) = default;
 
    virtual double get([[maybe_unused]] size_t i) const override {
      if constexpr (std::is_convertible_v<R, double>)
        return m_converterToR(m_collection.get()[i]);
      else
        return -1;
    }
 
    virtual std::string getString([[maybe_unused]] size_t i) const override {
      if constexpr (std::is_constructible_v<std::string, R>)
        return m_converterToR(m_collection.get()[i]);
      else
        return {};
    }
 
    virtual bool hasStringRepresentation() const override {
      return std::is_constructible<std::string, R>::value;
    };
    virtual size_t size() const override {
      return std::size(m_collection.get());
    }
 
  private:
    const std::reference_wrapper<T>& m_collection;
    std::function<R(const const_value_type&)> m_converterToR;
 
    ObjectsRefCollection(std::string name, const std::reference_wrapper<T>& collection,
                         std::function<R(const const_value_type&)> converterToR)
        : IMonitoredVariable(std::move(name)),
            m_collection(collection),
          m_converterToR(std::move(converterToR)) {}
 
    ObjectsRefCollection(ObjectsRefCollection const&) = delete;
 
    ObjectsRefCollection& operator=(ObjectsRefCollection const&) = delete;
 
  };
 
} // namespace Monitored
 
#endif /* AthenaMonitoringKernel_MonitoredCollection_h */