STL_Map

#include <iostream>
#include <vector>
#include <map>
#include <fstream>
#include <algorithm>
#include "Route.hpp"

#define II int,int
#define IR int,Route
#define IS int,string
#define SR string,Route
#define SS string,string
#define SI string,int

using namespace std;

std::ostream& operator<< (std::ostream& os, Route& route);
bool operator==(const Route& route1,const Route& route2);

void print_vec(vector<Route>);

void read_file(vector<Route>& _vec, string file);

int main(){
    //--------------------------------------------------------------------------------------------------------------------------
//1)
    //Make vector
    vector<Route> route_vec;
    //Read file
//2)
    read_file(route_vec, "input.txt");
    //Print vector
    print_vec(route_vec);
//3)
    //Sort by №
    sort(route_vec.begin(), route_vec.end(), [](Route route1, Route route2){return route1.get_bus_num()<route2.get_bus_num();});
    //Print vector
    print_vec(route_vec);
    //--------------------------------------------------------------------------------------------------------------------------

    //--------------------------------------------------------------------------------------------------------------------------
//5)
        {
            //Make map
            map<IR> route_map;
            for_each(route_vec.begin(), route_vec.end(), [&route_map](Route t_route)->void{
                route_map.insert(route_map.begin(), pair<IR>(t_route.get_route_num(), t_route));
            });
            //Print routes num
            cout<<"Current routes"<<endl;
            for_each(route_map.begin(), route_map.end(), [](pair<IR> temp_route){cout<<temp_route.first<<" ";});
            cout<<endl;
        }
    //--------------------------------------------------------------------------------------------------------------------------
//6)
        {
            //Make map
            multimap<IR> route_mul_map;
            for_each(route_vec.begin(), route_vec.end(), [&route_mul_map](Route t_route)->void{
                route_mul_map.insert(route_mul_map.begin(), pair<IR>(t_route.get_route_num(), t_route));
            });
            {
                //Print route buses
                cout<<"Type route to print its buses"<<endl;
                int temp_route_num;
                cin>>temp_route_num;
                cout<<"Buses by "<<temp_route_num<<" route"<<endl;
                for_each(route_mul_map.lower_bound(temp_route_num), route_mul_map.upper_bound(temp_route_num), [](pair<IR> temp_route){
                    cout<<temp_route.second.get_bus_num()<<" "<<temp_route.second.get_bus_brand()<<endl;
                });
            }
//7)
            {
                //Print route buses
                cout<<"Type route to print its drivers"<<endl;
                int temp_route_num;
                cin>>temp_route_num;
                cout<<"Drivers by "<<temp_route_num<<" route"<<endl;
                for_each(route_mul_map.lower_bound(temp_route_num), route_mul_map.upper_bound(temp_route_num), [](pair<IR> temp_route){
                    cout<<temp_route.second.get_driver_name()<<" ";
                });
                cout<<endl;
            }
        }
    //--------------------------------------------------------------------------------------------------------------------------
//8)
        {
            //Make map
            multimap<SS> route_mul_map;
            for_each(route_vec.begin(), route_vec.end(), [&route_mul_map](Route t_route)->void{
                route_mul_map.insert(route_mul_map.begin(), pair<SS>(t_route.get_bus_brand(), t_route.get_driver_name()));
            });
            //Print driver list
            cout<<"Type bus brand to print its drivers"<<endl;
            string temp_bus_brand;
            cin>>temp_bus_brand;
            cout<<"Drivers by "<<temp_bus_brand<<" brand"<<endl;
            for_each(route_mul_map.lower_bound(temp_bus_brand), route_mul_map.upper_bound(temp_bus_brand), [](pair<SS> temp_route){
                cout<<temp_route.second<<" ";
            });
            cout<<endl;
        }
    //--------------------------------------------------------------------------------------------------------------------------
//9)
        {
            //Make map
            multimap<IR> route_mul_map;
            for_each(route_vec.begin(), route_vec.end(), [&route_mul_map](Route t_route)->void{
                route_mul_map.insert(route_mul_map.begin(), pair<IR>(t_route.get_route_num(), t_route));
            });
            //Print map
            cout<<"Routes map"<<endl;
            for_each(route_mul_map.begin(), route_mul_map.end(), [](pair<IR> temp_route){cout<<temp_route.second<<endl;});
            //Erase route
            cout<<"Type route to delete it"<<endl;
            int temp_route_num;
            cin>>temp_route_num;
            route_mul_map.erase(temp_route_num);
            //Print map
            cout<<"Routes map"<<endl;
            for_each(route_mul_map.begin(), route_mul_map.end(), [](pair<IR> temp_route){cout<<temp_route.second<<endl;});
            //Change bus
        }
    //--------------------------------------------------------------------------------------------------------------------------
//10)
        {
            //Make map
            map<SR> route_map;
            for_each(route_vec.begin(), route_vec.end(), [&route_map](Route t_route)->void{
                route_map.insert(route_map.begin(), pair<SR>(t_route.get_driver_name(), t_route));
            });
            //Change bus
            cout<<"Type driver's name to change his/her bus"<<endl;
            string temp_driver_name;
            cin>>temp_driver_name;
            cout<<"Type new bus num"<<endl;
            string new_bus_num;
            cin>>new_bus_num;
            cout<<"Type new bus brand"<<endl;
            string new_bus_brand;
            cin>>new_bus_brand;
            map<SR>::iterator it=route_map.find(temp_driver_name);
            it->second.set_bus_num(new_bus_num);
            it->second.set_bus_brand(new_bus_brand);
            //Print map
            cout<<"Routes map"<<endl;
            for_each(route_map.begin(), route_map.end(), [](pair<SR> temp_route){cout<<temp_route.second<<endl;});
        }
    //--------------------------------------------------------------------------------------------------------------------------
//11)
    {
        //Make map
        map<SR> route_map;
        for_each(route_vec.begin(), route_vec.end(), [&route_map](Route t_route)->void{
            route_map.insert(route_map.begin(), pair<SR>(t_route.get_bus_num(), t_route));
        });
        //Change driver
        cout<<"Type bus num to change its driver"<<endl;
        string temp_bus_num;
        cin>>temp_bus_num;
        cout<<"Type new driver's name"<<endl;
        string new_driver_name;
        cin>>new_driver_name;
        map<SR>::iterator it=route_map.find(temp_bus_num);
        it->second.set_driver_name(new_driver_name);
        //Print map
        cout<<"Routes map"<<endl;
        for_each(route_map.begin(), route_map.end(), [](pair<SR> temp_route){cout<<temp_route.second<<endl;});
    }
    //--------------------------------------------------------------------------------------------------------------------------

    //--------------------------------------------------------------------------------------------------------------------------
//12)
    {
        //Make map
        multimap<IR> route_mul_map;
        for_each(route_vec.begin(), route_vec.end(), [&route_mul_map](Route t_route)->void{
            route_mul_map.insert(route_mul_map.begin(), pair<IR>(t_route.get_route_num(), t_route));
        });
        //Make map for each route
        map<II> route_map;
        for_each(route_mul_map.begin(), route_mul_map.end(), [&route_map](pair<IR> temp_route)->void{
            route_map[temp_route.first]=0;
        });
        //Count buses for each route
        for_each(route_map.begin(), route_map.end(), [&route_map, route_mul_map](pair<II> temp_route){
            route_map[temp_route.first]=(int)route_mul_map.count(temp_route.first);
        });
        //Print map for each route
        for_each(route_map.begin(), route_map.end(), [](pair<II> temp_route){
            cout<<temp_route.second<<" bus(es) for "<<temp_route.first<<" route"<<endl;
        });
    }
    //--------------------------------------------------------------------------------------------------------------------------
//13)
    {
        //Make map
        map<SI> route_map;
        for_each(route_vec.begin(), route_vec.end(), [&route_map](Route t_route)->void{
            route_map.insert(route_map.begin(), pair<SI>(t_route.get_driver_name(), t_route.get_route_num()));
        });
        //Find route for bus driver
        cout<<"Type driver's name"<<endl;
        string temp_driver_name;
        cin>>temp_driver_name;
        cout<<"Its route is "<<route_map[temp_driver_name];
    }
    //--------------------------------------------------------------------------------------------------------------------------
//14)
    {
        //Make multimap
        multimap<IS> route_mul_map;
        for_each(route_vec.begin(), route_vec.end(), [&route_mul_map](Route t_route)->void{
            route_mul_map.insert(route_mul_map.begin(), pair<IS>(t_route.get_route_num(), t_route.get_bus_brand()));
        });
        //Make map
        map<II> route_map;
        //Find
        for_each(route_mul_map.begin(), route_mul_map.end(), [route_mul_map, &route_map](pair<IS> temp_route){
            vector<string> temp_vec;
            int size1=0, size2=0;
            for_each(route_mul_map.lower_bound(temp_route.first), route_mul_map.upper_bound(temp_route.first), [&temp_vec, &route_map](pair<IS> temp_temp_route){
                temp_vec.push_back(temp_temp_route.second);
            });
            sort(temp_vec.begin(), temp_vec.end());
            size1=(int)temp_vec.size();
            vector<string>::iterator it=unique(temp_vec.begin(), temp_vec.end());
            temp_vec.resize(distance(temp_vec.begin(), it));
            size2=(int)temp_vec.size();
            if(size2==1){
            route_map[temp_route.first]=size2;
            }
        });
        //Print map
        cout<<"Routes with the same brand: "<<endl;
        for_each(route_map.begin(), route_map.end(), [](pair<II> temp_route){
            cout<<temp_route.first<<" ";
        });
        cout<<endl;
    }
    //--------------------------------------------------------------------------------------------------------------------------
//15)
    {
        //Make map
        map<SR> route_map;
        for_each(route_vec.begin(), route_vec.end(), [&route_map](Route t_route)->void{
            route_map.insert(route_map.begin(), pair<SR>(t_route.get_bus_brand(), t_route));
        });
        //Print bus_brands
        cout<<"Brand list: ";
        for_each(route_map.begin(), route_map.end(), [](pair<SR> temp_route){
            cout<<temp_route.first<<" ";;
        });
        cout<<endl;
    }
    //--------------------------------------------------------------------------------------------------------------------------
//16)
    {
        //Make multimap
        multimap<IS> route_mul_map;
        for_each(route_vec.begin(), route_vec.end(), [&route_mul_map](Route t_route)->void{
            route_mul_map.insert(route_mul_map.begin(), pair<IS>(t_route.get_route_num(), t_route.get_bus_brand()));
        });
        //Make map
        map<II> route_map;
        for_each(route_vec.begin(), route_vec.end(), [&route_map](Route t_route)->void{
            route_map.insert(route_map.begin(), pair<II>(t_route.get_route_num(), 0));
        });

        for_each(route_mul_map.begin(), route_mul_map.end(), [route_mul_map, &route_map](pair<IS> temp_route){
            vector<string> temp_vec;
            int size1=0, size2=0;
            for_each(route_mul_map.lower_bound(temp_route.first), route_mul_map.upper_bound(temp_route.first), [&temp_vec, &route_map](pair<IS> temp_temp_route){
                temp_vec.push_back(temp_temp_route.second);
            });
            sort(temp_vec.begin(), temp_vec.end());
            size1=(int)temp_vec.size();
            vector<string>::iterator it=unique(temp_vec.begin(), temp_vec.end());
            temp_vec.resize(distance(temp_vec.begin(), it));
            size2=(int)temp_vec.size();
            route_map[temp_route.first]=size2;
        });
        //Print map
        for_each(route_map.begin(), route_map.end(), [](pair<II> temp_route){
            cout<<"Route: "<<temp_route.first<<" brands:"<<temp_route.second<<endl;
        });
    }
    return 0;
}

std::ostream& operator<< (std::ostream& os, Route& route) {
    os<<route.to_string();
    return os;
}
void print_vec(vector<Route> route_vec){
    cout<<"Routes vector:"<<endl;
    //Print
    for_each(route_vec.begin(), route_vec.end(), [](Route temp_route){
        cout<<temp_route<<endl;
    });
}

void read_file(vector<Route>& _vec, string file){
    //Open file
    ifstream ifile;
    ifile.open("input.txt");
    //Read input.txt
    if(ifile.is_open()){
        //Make temp values
        string route_num="";
        string driver_name="";
        string bus_num_let="";
        string bus_num_dig="";
        string brand_bus="";

        string bus_num_let_temp="";
        //Start reading
        while(!ifile.eof()){
            ifile>>route_num;
            ifile>>driver_name;
            ifile>>bus_num_dig;
            ifile>>bus_num_let;
            if(bus_num_let_temp==bus_num_let)
                break;
            bus_num_let_temp=bus_num_let;
            ifile>>brand_bus;
            Route route_temp(atoi(route_num.c_str()), bus_num_dig+bus_num_let, driver_name, brand_bus);
            _vec.push_back(route_temp);
        }
    }
    //End reading
    ifile.close();
}

bool operator==(const Route& route1,const Route& route2){
    if(route1.bus_num!=route2.bus_num)
        return 0;
    else{
        if(route1.driver_name!=route2.driver_name)
            return 0;
        else{
            if(route1.brand_bus!=route2.brand_bus)
                return 0;
            else{
                if(route1.route_num!=route2.route_num)
                    return 0;
            }
        }
    }
    return 1;
}

//////////////////////////////////////////////////////////////////////////////////////////
Route.hpp
//////////////////////////////////////////////////////////////////////////////////////////
#ifndef Route_hpp
#define Route_hpp

#include <stdio.h>
#include <string>

class Route{
private:
    int route_num;
    std::string bus_num;
    std::string driver_name;
    std::string brand_bus;
public:
    Route(): route_num(0), bus_num(0), driver_name(""), brand_bus("") {}
    Route(int r_num, std::string b_num, std::string d_name, std::string b_bus): route_num(r_num), bus_num(b_num), driver_name(d_name), brand_bus(b_bus) {}
    Route(const Route& route): route_num(route.route_num), bus_num(route.bus_num), driver_name(route.driver_name), brand_bus(route.brand_bus) {}

    std::string to_string();

    int get_route_num();
    std::string get_bus_num();
    std::string get_driver_name();
    std::string get_bus_brand();

    void set_driver_name(std::string new_driver_name);
    void set_bus_num(std::string new_bus_num);
    void set_bus_brand(std::string new_brand_bus);

    Route& operator=(const Route& route);

    friend std::ostream& operator<<(std::ostream&os, Route& route);
    friend bool operator==(const Route& route1,const Route& route2);

};

#endif /* Route_hpp */
//////////////////////////////////////////////////////////////////////////////////////////
Route.cpp
//////////////////////////////////////////////////////////////////////////////////////////
#include "Route.hpp"
#include <sstream>

std::string Route::to_string(){
    std::ostringstream os;
    os<<"RN:\t"<<route_num<<"\tDN\t"<<driver_name<<"\tBN\t"<<bus_num<<"\tBB\t"<<brand_bus;
    return os.str();
}
std::string Route::get_bus_num(){
    return bus_num;
}
std::string Route::get_bus_brand(){
    return brand_bus;
}
int Route::get_route_num(){
    return route_num;
}
std::string Route::get_driver_name(){
    return driver_name;
}
void Route::set_driver_name(std::string new_driver_name){
    driver_name=new_driver_name;
}
void Route::set_bus_num(std::string new_bus_num){
    bus_num=new_bus_num;
}
void Route::set_bus_brand(std::string new_brand_bus){
    brand_bus=new_brand_bus;
}
Route& Route::operator=(const Route& route){
    bus_num=route.bus_num;
    driver_name=route.driver_name;
    brand_bus=route.brand_bus;
    route_num=route.route_num;
    return *this;
}