MetricData.hh

#ifndef ARTDAQ_UTILITIES_PLUGINS_METRICDATA_HH
#define ARTDAQ_UTILITIES_PLUGINS_METRICDATA_HH

#include "fhiclcpp/fwd.h"
#include "messagefacility/MessageLogger/MessageLogger.h"

#include <atomic>
#include <condition_variable>
#include <list>
#include <sstream>

namespace artdaq {
enum class MetricType
{
    InvalidMetric,  
    StringMetric,   
    IntMetric,      
    DoubleMetric,   
    FloatMetric,    
    UnsignedMetric  
};

enum class MetricMode : uint32_t
{
    None = 0x0,
    LastPoint = 0x1,   
    Accumulate = 0x2,  
    Average = 0x4,     
    Rate = 0x8,        
    Minimum = 0x10,    
    Maximum = 0x20,    
};
constexpr MetricMode operator|(MetricMode a, MetricMode b)
{
    return static_cast<MetricMode>(static_cast<uint32_t>(a) | static_cast<uint32_t>(b));
}
constexpr MetricMode operator&(MetricMode a, MetricMode b)
{
    return static_cast<MetricMode>(static_cast<uint32_t>(a) & static_cast<uint32_t>(b));
}

struct MetricData
{
    MetricData(const MetricData& r) = default;

    MetricData(MetricData&& r) noexcept = default;

    MetricData& operator=(const MetricData& r) = default;

    MetricData& operator=(MetricData&& r) noexcept = default;

    std::string Name;
    std::string StringValue;

    union MetricDataValue
    {
        int i;                
        double d;             
        float f;              
        long unsigned int u;  

        MetricDataValue()
            : i(0) {}
        MetricDataValue(int v)
            : i(v) {}
        MetricDataValue(double v)
            : d(v) {}
        MetricDataValue(float v)
            : f(v) {}
        MetricDataValue(long unsigned int v)
            : u(v) {}
    };

    MetricDataValue Value;
    MetricDataValue Last; 
    MetricDataValue Min; 
    MetricDataValue Max; 

    MetricType Type;
    std::string Unit;
    int Level;
    MetricMode Mode;
    std::string MetricPrefix;
    bool UseNameOverride;
    size_t DataPointCount;

    MetricData(std::string const& name, std::string const& value, std::string const& unit, int level, MetricMode mode,
               std::string const& metricPrefix, bool useNameOverride)
        : Name(name), StringValue(value), Type(MetricType::StringMetric), Unit(unit), Level(level), Mode(mode), MetricPrefix(metricPrefix), UseNameOverride(useNameOverride), DataPointCount(1) {}

    MetricData(std::string const& name, int const& value, std::string const& unit, int level, MetricMode mode,
               std::string const& metricPrefix, bool useNameOverride)
        : Name(name), Value(value), Last(value), Min(value), Max(value), Type(MetricType::IntMetric), Unit(unit), Level(level), Mode(mode), MetricPrefix(metricPrefix), UseNameOverride(useNameOverride), DataPointCount(1) {}

    MetricData(std::string const& name, double const& value, std::string const& unit, int level, MetricMode mode,
               std::string const& metricPrefix, bool useNameOverride)
        : Name(name), Value(value), Last(value), Min(value), Max(value), Type(MetricType::DoubleMetric), Unit(unit), Level(level), Mode(mode), MetricPrefix(metricPrefix), UseNameOverride(useNameOverride), DataPointCount(1) {}

    MetricData(std::string const& name, float const& value, std::string const& unit, int level, MetricMode mode,
               std::string const& metricPrefix, bool useNameOverride)
        : Name(name), Value(value), Last(value), Min(value), Max(value), Type(MetricType::FloatMetric), Unit(unit), Level(level), Mode(mode), MetricPrefix(metricPrefix), UseNameOverride(useNameOverride), DataPointCount(1) {}

    MetricData(std::string const& name, long unsigned int const& value, std::string const& unit, int level,
               MetricMode mode, std::string const& metricPrefix, bool useNameOverride)
        : Name(name), Value(value), Last(value), Min(value), Max(value), Type(MetricType::UnsignedMetric), Unit(unit), Level(level), Mode(mode), MetricPrefix(metricPrefix), UseNameOverride(useNameOverride), DataPointCount(1) {}

    MetricData()
        : Name(""), Type(MetricType::InvalidMetric), DataPointCount(0) {}

    bool Add(MetricData other)
    {
        if (other.Name == Name && other.Type == Type && other.Unit == Unit && other.Level == Level)
        {
            switch (Type)
            {
                case MetricType::StringMetric:
                    StringValue += " " + other.StringValue;
                    break;
                case MetricType::IntMetric:
                    Value.i += other.Value.i;
                    Last.i = other.Last.i;
                    if (other.Min.i < Min.i) Min.i = other.Min.i;
                    if (other.Max.i > Max.i) Max.i = other.Max.i;
                    break;
                case MetricType::DoubleMetric:
                    Value.d += other.Value.d;
                    Last.d = other.Last.d;
                    if (other.Min.d < Min.d) Min.d = other.Min.d;
                    if (other.Max.d > Max.d) Max.d = other.Max.d;
                    break;
                case MetricType::FloatMetric:
                    Value.f += other.Value.f;
                    Last.f = other.Last.f;
                    if (other.Min.f < Min.f) Min.f = other.Min.f;
                    if (other.Max.f > Max.f) Max.f = other.Max.f;
                    break;
                case MetricType::UnsignedMetric:
                    Value.u += other.Value.u;
                    Last.u = other.Last.u;
                    if (other.Min.u < Min.u) Min.u = other.Min.u;
                    if (other.Max.u > Max.u) Max.u = other.Max.u;
                    break;
                case MetricType::InvalidMetric:
                    break;
            }
            DataPointCount += other.DataPointCount;
            return true;
        }
        return false;
    }

    void AddPoint(int point)
    {
        Last.i = point;
        Value.i += point;
        DataPointCount++;
        if (point > Max.i) Max.i = point;
        if (point < Min.i) Min.i = point;
    }
    void AddPoint(double point)
    {
        Last.d = point;
        Value.d += point;
        DataPointCount++;
        if (point > Max.d) Max.d = point;
        if (point < Min.d) Min.d = point;
    }
    void AddPoint(float point)
    {
        Last.f = point;
        Value.f += point;
        DataPointCount++;
        if (point > Max.f) Max.f = point;
        if (point < Min.f) Min.f = point;
    }
    void AddPoint(unsigned long int point)
    {
        Last.u = point;
        Value.u += point;
        DataPointCount++;
        if (point > Max.u) Max.u = point;
        if (point < Min.u) Min.u = point;
    }
};
}  // namespace artdaq

#endif /* ARTDAQ_UTILITIES_PLUGINS_METRICDATA_HH */