map_parser.hpp

#pragma once
 
#include <userver/formats/json/parser/typed_parser.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace formats::json::parser {
 
template <typename Map, typename ValueParser>
class MapParser final : public TypedParser<Map>,
                        public Subscriber<typename Map::mapped_type> {
 public:
  using Value = typename Map::mapped_type;
 
  explicit MapParser(ValueParser& value_parser) : value_parser_(value_parser) {}
 
  void Reset() override { this->state_ = State::kStart; }
 
  void StartObject() override {
    switch (state_) {
      case State::kStart:
        this->state_ = State::kInside;
        break;
 
      case State::kInside:
        this->Throw("{");
    }
  }
 
  void Key(std::string_view key) override {
    if (state_ != State::kInside) this->Throw("object");
 
    key_ = key;
    this->value_parser_.Reset();
    this->value_parser_.Subscribe(*this);
    this->parser_state_->PushParser(this->value_parser_.GetParser());
  }
 
  void EndObject() override {
    if (state_ == State::kInside) {
      this->SetResult(std::move(result_));
      return;
    }
    // impossible?
    this->Throw("}");
  }
 
  std::string Expected() const override {
    switch (state_) {
      case State::kInside:
        return "string";
 
      case State::kStart:
        return "object";
    }
 
    UINVARIANT(false, "Unexpected parser state");
  }
 
 private:
  void OnSend(Value&& value) override {
    this->result_.emplace(std::move(key_), std::move(value));
  }
 
  std::string GetPathItem() const override { return key_; }
 
  enum class State {
    kStart,
    kInside,
  };
  State state_;
  std::string key_;
  Map result_;
  ValueParser& value_parser_;
};
 
}  // namespace formats::json::parser
 
USERVER_NAMESPACE_END