Counter.hpp

#pragma once
 
#include "util/Assert.hpp"
#include "util/prometheus/MetricBase.hpp"
#include "util/prometheus/OStream.hpp"
#include "util/prometheus/impl/AnyCounterBase.hpp"
 
#include <cstdint>
#include <string>
#include <type_traits>
#include <utility>
 
namespace util::prometheus {

template <SomeNumberType NumberType>
struct AnyCounter : MetricBase, impl::AnyCounterBase<NumberType> {
    using ValueType = NumberType;

    template <impl::SomeCounterImpl ImplType = impl::CounterImpl<ValueType>>
        requires std::same_as<ValueType, typename std::remove_cvref_t<ImplType>::ValueType>
    AnyCounter(std::string name, std::string labelsString, ImplType&& impl = ImplType{})
        : MetricBase(std::move(name), std::move(labelsString))
        , impl::AnyCounterBase<ValueType>(std::forward<ImplType>(impl))
    {
    }

    AnyCounter&
    operator++()
    {
        this->pimpl_->add(ValueType{1});
        return *this;
    }

    AnyCounter&
    operator+=(ValueType const value)
    {
        ASSERT(value >= 0, "Cannot decrease a counter");
        this->pimpl_->add(value);
        return *this;
    }

    void
    set(ValueType value)
    {
        ASSERT(value >= this->value(), "Cannot decrease a counter {}", this->name());
        this->pimpl_->set(value);
    }

    void
    reset()
    {
        this->pimpl_->set(ValueType{0});
    }

    ValueType
    value() const
    {
        return this->pimpl_->value();
    }

    void
    serializeValue(OStream& stream) const override
    {
        stream << name() << labelsString() << ' ' << value();
    }
};

using CounterInt = AnyCounter<std::uint64_t>;

using CounterDouble = AnyCounter<double>;
 
}  // namespace util::prometheus