MonitoredScalar.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef AthenaMonitoringKernel_MonitoredScalar_h
#define AthenaMonitoringKernel_MonitoredScalar_h
 
 
#include <vector>
#include <string_view>
#include "AthenaMonitoringKernel/IMonitoredVariable.h"
 
 
namespace Monitored {

  template <class T> class Scalar : public IMonitoredVariable {
  public:
    static_assert(std::is_convertible<T, double>::value or std::is_constructible<std::string, T>::value, "Conversion of scalar template type to double or string is impossible");


    Scalar(std::string name, const T& defaultValue = {}) :
        IMonitoredVariable(std::move(name)),
        m_value(defaultValue)
    {}
 
    // Special constructor for more effecient string usage
    Scalar(std::string name, const char* defaultValue)
        requires std::is_same_v<T, std::string>
        : IMonitoredVariable(std::move(name)),
          m_value(defaultValue)
    {}
 
    // Special constructor for more effecient string usage
    Scalar(std::string name, std::string_view defaultValue)
        requires std::is_same_v<T, std::string>
        : IMonitoredVariable(std::move(name)),
          m_value(defaultValue)
    {}

    Scalar(std::string name, const T& defaultValue, std::function<double(const T&)> valueTransform) :
        IMonitoredVariable(std::move(name)),
        m_value(defaultValue),
        m_valueTransform(std::move(valueTransform))
    {}

    Scalar(std::string name, std::function<T()> generator) :
      IMonitoredVariable(std::move(name)),
      m_valueGenerator(std::move(generator))
    {}

 
    Scalar(Scalar&&) = default;
    Scalar(Scalar const&) = delete;
 
    Scalar& operator=(Scalar const&) = delete;
    // cppcheck-suppress passedByValue
    T operator=(T value)
    {
      m_value = value;
      return value;
    }
 
    operator const T&() const { return m_value; }
    operator T&() { return m_value; }
 
    // string concatenation
    friend std::string operator+(const Scalar& lhs, const std::string& rhs) {
      return lhs.m_value + rhs;
    }
 
    friend std::string operator+(const std::string& lhs, const Scalar& rhs) {
      return lhs + rhs.m_value;
    }
 
    virtual double get(size_t) const override {
      if constexpr (std::is_convertible_v<double, T>) {
        return (m_valueGenerator ? static_cast<double>(m_valueGenerator()) :
                m_valueTransform ? m_valueTransform(m_value) : static_cast<double>(m_value));
      }
      else return 0;
    }
 
    virtual std::string getString(size_t) const override {
      if constexpr (std::is_constructible_v<std::string, T>) {
        return (m_valueGenerator ? m_valueGenerator() : m_value);
      }
      else return {};
    }
 
    virtual bool hasStringRepresentation() const override {
      return std::is_constructible<std::string, T>::value;
    }
 
    virtual size_t size() const override {
      return 1;
    }
    
  private:
    T m_value{};
    std::function<double(const T&)> m_valueTransform;
    std::function<T()> m_valueGenerator;
  };
 
} // namespace Monitored
 
#endif /* AthenaMonitoringKernel_MonitoredScalar_h */