Decomposition_and_debugging

#include <cassert>
#include <iostream>
#include <map>
#include <string>
#include <vector>

using namespace std;

enum class QueryType {
    NewBus,
    BusesForStop,
    StopsForBus,
    AllBuses,
};

struct Query {
    QueryType type;
    string bus;
    string stop;
    vector<string> stops;
};

istream& operator>>(istream& is, Query& q) {
    // Реализуйте эту функцию
    string type;
    is >> type;

    map <string, QueryType> m = {
        {"NEW_BUS", QueryType::NewBus},
        {"BUSES_FOR_STOP", QueryType::BusesForStop},
        {"STOPS_FOR_BUS", QueryType::StopsForBus},
        {"ALL_BUSES", QueryType::AllBuses},
        };
    q.type = m[type];
    is.ignore(1);

    switch (q.type) {
    case QueryType::NewBus:
        is >> q.bus;
        is.ignore(1);
        int stop_count;
        is >> stop_count;
        is.ignore(1);
        q.stops.clear();
        while (is.peek() != '\n') {
            string stop;
            is >> stop;
            q.stops.push_back(stop);
        }
        break;
    case QueryType::BusesForStop:
        is >> q.stop;
        break;
    case QueryType::StopsForBus:
        is >> q.bus;
        break;
    case QueryType::AllBuses:
        break;

    }

    return is;
}

struct BusesForStopResponse {
    // Наполните полями эту структуру
    vector<string> stops;
};

ostream& operator<<(ostream& os, const BusesForStopResponse& r) {
    // Реализуйте эту функцию
    if (r.stops.size() != 0) {
        os << r.stops[0];
        for (size_t i = 1; i < r.stops.size(); ++i){
            os << " " << r.stops[i];
        }
    } else {
        os << "No stop";
    }
    return os;
}

struct StopsForBusResponse {
    // Наполните полями эту структуру
    string bus;
    vector<string> stops;
    map<string, vector<string> > buses_to_stops;
};

ostream& operator<<(ostream& os, const StopsForBusResponse& r) {
    // Реализуйте эту функцию
    if (r.stops.size() != 0) {
        size_t stops_count = 0;
        for (auto& stop : r.stops) {
            os << "Stop " << stop << ":";
            if (r.buses_to_stops.count(stop) != 0) {
                size_t count = 0;
                for (auto& bus : r.buses_to_stops.at(stop)) {
                    if (r.bus != bus) {
                        os << " " << bus;
                        ++count;
                    }
                }
                if (count == 0) {
                    os << " no interchange";
                }
            } else {
                os << " no interchange";
            }
            ++stops_count;
            if ((stops_count + 1) <= r.stops.size()) {
                os << endl;
            }
        }
    } else {
        os << "No bus";
    }

    return os;
}

struct AllBusesResponse {
    // Наполните полями эту структуру
    map<string, vector<string>> buses_to_stops;
};

ostream& operator<<(ostream& os, const AllBusesResponse& r) {
    // Реализуйте эту функцию
    if (r.buses_to_stops.size() != 0) {
        size_t buses_count = 0;
        for (auto& item : r.buses_to_stops) {
            os << "Bus " << item.first << ":";
            for (auto& stop : r.buses_to_stops.at(item.first)) {
                os << " " << stop;
            }
            ++buses_count;
            if ((buses_count + 1) <= r.buses_to_stops.size()) {
                os << endl;
            }
        }
    } else {
        os << "No buses";
    }
    return os;
}

class BusManager {
public:
    void AddBus(const string& bus, const vector<string>& stops) {
        // Реализуйте этот метод
        buses_to_stops[bus] = stops;
        for (string stop : stops) {
            stops_to_buses[stop].push_back(bus);
        }
    }

    BusesForStopResponse GetBusesForStop(const string& stop) const {
        // Реализуйте этот метод
        BusesForStopResponse response;
        if (stops_to_buses.count(stop) > 0) {
            response.stops = stops_to_buses.at(stop);
        }
        return response;
    }

    StopsForBusResponse GetStopsForBus(const string& bus) const {
        // Реализуйте этот метод
        StopsForBusResponse response;
        if (buses_to_stops.count(bus) > 0) {
            response.bus = bus;
            response.stops = buses_to_stops.at(bus);
            response.buses_to_stops = stops_to_buses;
        }
        return response;
    }

    AllBusesResponse GetAllBuses() const {
        // Реализуйте этот метод
        AllBusesResponse response;
        response.buses_to_stops = buses_to_stops;
        return response;
    }

private:
    map<string, vector<string>> buses_to_stops;
    map<string, vector<string>> stops_to_buses;
};

// Не меняя тела функции main, реализуйте функции и классы выше

int main() {
    int query_count;
    Query q;

    cin >> query_count;

    BusManager bm;
    for (int i = 0; i < query_count; ++i) {
        cin >> q;
        switch (q.type) {
            case QueryType::NewBus:
                bm.AddBus(q.bus, q.stops);
                break;
            case QueryType::BusesForStop:
                cout << bm.GetBusesForStop(q.stop) << endl;
                break;
            case QueryType::StopsForBus:
                cout << bm.GetStopsForBus(q.bus) << endl;
                break;
            case QueryType::AllBuses:
                cout << bm.GetAllBuses() << endl;
                break;
        }
    }
}