items.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/formats/common/items.hpp
/// @brief @copybrief formats::common::Items()
/// @ingroup userver_universal
 
#include <cstddef>
#include <iterator>
#include <string>
#include <type_traits>
 
USERVER_NAMESPACE_BEGIN
 
namespace formats::common {
 
/// @see formats::common::ItemsWrapper
template <typename Value>
struct ItemsWrapperValue final {
    std::string key;
    typename decltype(std::declval<Value&>().begin())::reference value;
};
 
/// @brief Wrapper for handy python-like iteration over a map.
///
/// See formats::common::Items() for usage example
template <typename Value>
class ItemsWrapper final {
public:
    /// Exposition-only, do not instantiate directly, use `iterator` and
    /// `const_iterator` aliases instead.
    template <bool Const>
    class Iterator final {
        using Base = std::conditional_t<Const, const Value, Value>;
        using RawIterator = decltype(std::declval<Base&>().begin());
 
    public:
        using iterator_category = std::forward_iterator_tag;
        using difference_type = std::ptrdiff_t;
        using value_type = ItemsWrapperValue<Base>;
        using reference = value_type;
        using pointer = void;
 
        /// @cond
        explicit Iterator(RawIterator it) : it_(std::move(it)) {}
        /// @endcond
 
        Iterator(const Iterator& other) = default;
        Iterator(Iterator&& other) noexcept = default;
 
        Iterator& operator=(const Iterator& other) = default;
        Iterator& operator=(Iterator&& other) noexcept = default;
 
        reference operator*() const { return {it_.GetName(), *it_}; }
 
        Iterator operator++(int) {
            auto it = *this;
            ++*this;
            return it;
        }
 
        Iterator& operator++() {
            ++it_;
            return *this;
        }
 
        bool operator==(const Iterator& other) const { return it_ == other.it_; }
 
        bool operator!=(const Iterator& other) const { return !(*this == other); }
 
    private:
        RawIterator it_;
    };
 
    /// @brief Satisfies `std::forward_iterator`, `std::common_iterator`,
    /// with `std::iter_reference_t` equal to
    /// formats::common::ItemsWrapperValue<Value>.
    using iterator = Iterator<false>;
 
    /// @brief Satisfies `std::forward_iterator`, `std::common_iterator`,
    /// with `std::iter_reference_t` equal to
    /// formats::common::ItemsWrapperValue<const Value>.
    using const_iterator = Iterator<true>;
 
    /// @cond
    explicit ItemsWrapper(Value&& value) : value_(static_cast<Value&&>(value)) {}
    /// @endcond
 
    iterator begin() { return iterator(value_.begin()); }
    iterator end() { return iterator(value_.end()); }
    const_iterator begin() const { return const_iterator(value_.begin()); }
    const_iterator end() const { return const_iterator(value_.end()); }
 
private:
    Value value_;
};
 
/// @brief Wrapper for handy python-like iteration over a map
///
/// @code
/// for (const auto& [name, value]: Items(map)) ...
/// @endcode
///
/// To move out values:
/// @code
/// for (auto [name, value]: Items(map)) {
///   vector.push_back(std::move(name));
///   // value is a const reference and can not be moved
/// }
/// @endcode
template <typename Value>
ItemsWrapper<Value> Items(Value&& value) {
    // when passed an lvalue, store by reference
    // when passed an rvalue, store by value
    return ItemsWrapper<Value>(static_cast<Value&&>(value));
}
 
}  // namespace formats::common
 
USERVER_NAMESPACE_END