array_parser.hpp

#pragma once
 
#include <userver/formats/common/path.hpp>
#include <userver/formats/json/parser/typed_parser.hpp>
#include <userver/utils/meta.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace formats::json::parser {
 
// Parser for array -> vector/set/unordered_set
template <typename Item, typename ItemParser, typename Array = std::vector<Item>>
class ArrayParser final : public TypedParser<Array>, public Subscriber<Item> {
public:
    explicit ArrayParser(ItemParser& item_parser)
        : item_parser_(item_parser)
    {
        this->item_parser_.Subscribe(*this);
    }
 
    void Reset() override {
        index_ = 0;
        state_ = State::kStart;
        storage_.clear();
 
        if constexpr (meta::kIsVector<Array>) {
            /*
             * Heuristics:
             * STL impls have a small initial capacity of vector.
             * It leads to multiple reallocations during inserts.
             * We intentionally give up some maybe-unused space to lower realloc
             * count.
             */
            storage_.reserve(16);
        }
    }
 
protected:
    void StartArray() override {
        if (state_ == State::kStart) {
            state_ = State::kInside;
        } else {
            PushParser("array");
            Parser().StartArray();
        }
    }
    void EndArray() override {
        if (state_ == State::kInside) {
            this->SetResult(std::move(storage_));
            return;
        }
        // impossible?
        this->Throw("end of array");
    }
 
    void Int64(int64_t i) override {
        PushParser("integer");
        Parser().Int64(i);
    }
    void Uint64(uint64_t i) override {
        PushParser("integer");
        Parser().Uint64(i);
    }
    void Null() override {
        PushParser("null");
        Parser().Null();
    }
    void Bool(bool b) override {
        PushParser("bool");
        Parser().Bool(b);
    }
    void Double(double d) override {
        PushParser("double");
        Parser().Double(d);
    }
    void String(std::string_view sw) override {
        PushParser("string");
        Parser().String(sw);
    }
    void StartObject() override {
        PushParser("object");
        Parser().StartObject();
    }
 
    std::string Expected() const override { return "array"; }
 
    void PushParser(std::string_view what) {
        if (state_ != State::kInside) {
            // Error path must not include [x] - we're not inside an array yet
            this->parser_state_->PopMe(*this);
 
            this->Throw(std::string(what));
        }
 
        this->item_parser_.Reset();
        this->parser_state_->PushParser(item_parser_.GetParser());
        index_++;
    }
 
    void OnSend(Item&& item) override {
        if constexpr (!meta::kIsVector<Array>) {
            this->storage_.insert(std::move(item));
        } else {
            this->storage_.push_back(std::move(item));
        }
    }
 
    std::string GetPathItem() const override { return common::GetIndexString(index_ - 1); }
 
    BaseParser& Parser() { return item_parser_.GetParser(); }
 
private:
    ItemParser& item_parser_;
    std::optional<size_t> min_items_, max_items_;
 
    enum class State {
        kStart,
        kInside,
    };
    size_t index_{0};
    State state_{State::kStart};
    Array storage_;
};
 
}  // namespace formats::json::parser
 
USERVER_NAMESPACE_END