Спринт 10. Зови меня по имени. Задание 1.

-----------------------------------------------------------------------
json.cpp
-----------------------------------------------------------------------
#include "json.h"

using namespace std;

Node::Node(vector<Node> array)
    : as_array_(move(array)) {
}

Node::Node(map<string, Node> map)
    : as_map_(move(map)) {
}

Node::Node(int value)
    : as_int_(value) {
}

Node::Node(string value)
    : as_string_(move(value)) {
}

const vector<Node>& Node::AsArray() const {
    return as_array_;
}

const map<string, Node>& Node::AsMap() const {
    return as_map_;
}

int Node::AsInt() const {
    return as_int_;
}

const string& Node::AsString() const {
    return as_string_;
}

Document::Document(Node root)
    : root_(move(root)) {
}

const Node& Document::GetRoot() const {
    return root_;
}

Node LoadNode(istream& input);

Node LoadArray(istream& input) {
    vector<Node> result;

    for (char c; input >> c && c != ']';) {
        if (c != ',') {
            input.putback(c);
        }
        result.push_back(LoadNode(input));
    }

    return Node(move(result));
}

Node LoadInt(istream& input) {
    int result = 0;
    while (isdigit(input.peek())) {
        result *= 10;
        result += input.get() - '0';
    }
    return Node(result);
}

Node LoadString(istream& input) {
    string line;
    getline(input, line, '"');
    return Node(move(line));
}

Node LoadDict(istream& input) {
    map<string, Node> result;

    for (char c; input >> c && c != '}';) {
        if (c == ',') {
            input >> c;
        }

        string key = LoadString(input).AsString();
        input >> c;
        result.insert({move(key), LoadNode(input)});
    }

    return Node(move(result));
}

Node LoadNode(istream& input) {
    char c;
    input >> c;

    if (c == '[') {
        return LoadArray(input);
    } else if (c == '{') {
        return LoadDict(input);
    } else if (c == '"') {
        return LoadString(input);
    } else {
        input.putback(c);
        return LoadInt(input);
    }
}

Document Load(istream& input) {
    return Document{LoadNode(input)};
}
-----------------------------------------------------------------------
main.cpp
-----------------------------------------------------------------------
#include <algorithm>
#include <cassert>
#include <iostream>
#include <numeric>
#include <vector>

#include "json.h"

using namespace std;

struct Spending {
    string category;
    int amount;
};

int CalculateTotalSpendings(const vector<Spending>& spendings) {
    return accumulate(
        spendings.begin(), spendings.end(), 0, [](int current, const Spending& spending){
            return current + spending.amount;
        });
}

string FindMostExpensiveCategory(const vector<Spending>& spendings) {
    assert(!spendings.empty());
    auto compare_by_amount = [](const Spending& lhs, const Spending& rhs) {
        return lhs.amount < rhs.amount;
    };
    return max_element(begin(spendings), end(spendings), compare_by_amount)->category;
}

vector<Spending> LoadFromJson(istream& input) {
    std::vector<Spending> result;

    auto nod = Load(input).GetRoot().AsArray();

    for (auto node : nod) {
        for (auto& [amount_, category_] : node.AsMap()) {

            Spending helper;

            if (category_.AsString().empty()) {
                continue;
            }
            helper.amount = category_.AsInt();
            helper.category = category_.AsString();

            result.push_back(move(helper));
        }
    }
    return result;
}

int main() {
    const vector<Spending> spendings = LoadFromJson(cin);
    cout << "Total "sv << CalculateTotalSpendings(spendings) << '\n';
    cout << "Most expensive is "sv << FindMostExpensiveCategory(spendings) << '\n';
}
-----------------------------------------------------------------------
json.h
-----------------------------------------------------------------------
#pragma once

#include <istream>
#include <map>
#include <string>
#include <unordered_map>
#include <vector>

class Node {
public:
    explicit Node(std::vector<Node> array);
    explicit Node(std::map<std::string, Node> map);
    explicit Node(int value);
    explicit Node(std::string value);

    const std::vector<Node>& AsArray() const;
    const std::map<std::string, Node>& AsMap() const;
    int AsInt() const;
    const std::string& AsString() const;

private:
    std::vector<Node> as_array_;
    std::map<std::string, Node> as_map_;
    int as_int_;
    std::string as_string_;
};

class Document {
public:
    explicit Document(Node root);

    const Node& GetRoot() const;

private:
    Node root_;
};

Document Load(std::istream& input);