labels.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/utils/statistics/labels.hpp
/// @brief Owning and non owning labels representations.
 
#include <string>
#include <string_view>
#include <type_traits>
 
#include <fmt/format.h>
 
#include <userver/utils/assert.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace utils::statistics {
 
class Label;
 
/// @ingroup userver_universal
///
/// @brief Non owning label name+value storage.
class LabelView final {
public:
    LabelView() = delete;
    LabelView(Label&& label) = delete;
    explicit LabelView(const Label& label);
    constexpr LabelView(std::string_view name, std::string_view value)
        : name_(name),
          value_(value)
    {
        UINVARIANT(!name_.empty(), "The label name must not be empty.");
    }
 
    template <class T, std::enable_if_t<std::is_arithmetic_v<T>>* = nullptr>
    constexpr LabelView(std::string_view, T) {
        static_assert(sizeof(T) && false, "Labels should not be arithmetic values, only strings!");
    }
 
    constexpr explicit operator bool() const { return !name_.empty(); }
 
    constexpr std::string_view Name() const { return name_; }
    constexpr std::string_view Value() const { return value_; }
 
private:
    std::string_view name_{};
    std::string_view value_{};
};
 
bool operator<(const LabelView& x, const LabelView& y) noexcept;
bool operator==(const LabelView& x, const LabelView& y) noexcept;
 
/// @ingroup userver_universal
///
/// @brief Label name+value storage.
class Label final {
public:
    Label() = default;
    explicit Label(LabelView view);
    Label(std::string name, std::string value);
 
    template <class T, std::enable_if_t<std::is_arithmetic_v<T>>* = nullptr>
    Label(std::string, T) {
        static_assert(sizeof(T) && false, "Labels should not be arithmetic values, only strings!");
    }
 
    explicit operator bool() const { return !name_.empty(); }
    explicit operator LabelView() const { return {name_, value_}; }
 
    const std::string& Name() const { return name_; }
    const std::string& Value() const& { return value_; }
    std::string& Value() & { return value_; }
    std::string&& Value() && { return std::move(value_); }
 
private:
    std::string name_;
    std::string value_;
};
 
bool operator<(const Label& x, const Label& y) noexcept;
bool operator==(const Label& x, const Label& y) noexcept;
 
/// @ingroup userver_universal
///
/// @brief View over a continuous range of LabelView.
class LabelsSpan final {
public:
    using iterator = const LabelView*;
    using const_iterator = const LabelView*;
 
    LabelsSpan() = default;
    LabelsSpan(const LabelView* begin, const LabelView* end) noexcept;
    LabelsSpan(std::initializer_list<LabelView> il) noexcept : LabelsSpan(il.begin(), il.end()) {}
 
    template <
        class Container,
        std::enable_if_t<
            std::is_same_v<
                decltype(*(std::declval<const Container&>().data() + std::declval<const Container&>().size())),
                const LabelView&>,
            int> = 0>
    /*implicit*/ LabelsSpan(const Container& cont) noexcept : LabelsSpan(cont.data(), cont.data() + cont.size()) {}
 
    const LabelView* begin() const noexcept { return begin_; }
    const LabelView* end() const noexcept { return end_; }
    std::size_t size() const noexcept { return end_ - begin_; }
    bool empty() const noexcept { return end_ == begin_; }
 
private:
    const LabelView* begin_{nullptr};
    const LabelView* end_{nullptr};
};
 
}  // namespace utils::statistics
 
USERVER_NAMESPACE_END
 
template <>
struct fmt::formatter<USERVER_NAMESPACE::utils::statistics::LabelView> {
    constexpr static auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    template <typename FormatContext>
    auto format(USERVER_NAMESPACE::utils::statistics::LabelView value, FormatContext& ctx) const {
        return fmt::format_to(ctx.out(), "{}={}", value.Name(), value.Value());
    }
};
 
template <>
struct fmt::formatter<USERVER_NAMESPACE::utils::statistics::Label>
    : public fmt::formatter<USERVER_NAMESPACE::utils::statistics::LabelView> {
    template <typename FormatContext>
    auto format(const USERVER_NAMESPACE::utils::statistics::Label& value, FormatContext& ctx) const {
        return formatter<USERVER_NAMESPACE::utils::statistics::LabelView>::format(
            USERVER_NAMESPACE::utils::statistics::LabelView{value},
            ctx
        );
    }
};
 
template <>
struct fmt::formatter<USERVER_NAMESPACE::utils::statistics::LabelsSpan> {
    constexpr static auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    fmt::format_context::iterator format(
        USERVER_NAMESPACE::utils::statistics::LabelsSpan value,
        fmt::format_context& ctx
    ) const;
};