Спринт 12. Путешествия с RAII. Задание 1.

-----------------------------------------------------------------------
main.cpp
-----------------------------------------------------------------------
#include "trip_manager.h"

#include <cassert>
#include <iostream>
#include <stdexcept>

using namespace std;

int FlightProvider::capacity = 0;
int FlightProvider::counter = 0;

int HotelProvider::capacity = 0;
int HotelProvider::counter = 0;

void TestNoOverbooking() {
    FlightProvider::capacity = 100;
    HotelProvider::capacity = 100;
    FlightProvider::counter = 0;
    HotelProvider::counter = 0;
    {
        TripManager tm;
        auto trip = tm.Book({});
    }
    assert(FlightProvider::counter == 0);
    assert(HotelProvider::counter == 0);
}

void TestFlightOverbooking() {
    FlightProvider::capacity = 1;
    HotelProvider::capacity = 100;
    FlightProvider::counter = 0;
    HotelProvider::counter = 0;
    try {
        TripManager tm;
        auto trip = tm.Book({});
    } catch (const runtime_error&) {
        assert(FlightProvider::counter == 0);
        assert(HotelProvider::counter == 0);
        return;
    }
    cout << "Flight overbooking was expected"s << endl;
}

void TestHotelOverbooking() {
    FlightProvider::capacity = 100;
    HotelProvider::capacity = 0;
    FlightProvider::counter = 0;
    HotelProvider::counter = 0;
    try {
        TripManager tm;
        auto trip = tm.Book({});
    } catch (const runtime_error& ex) {
        assert(FlightProvider::counter == 0);
        assert(HotelProvider::counter == 0);
        return;
    }
    cout << "Hotel overbooking was expected"s << endl;
}

int main() {
    TestNoOverbooking();
    TestFlightOverbooking();
    TestHotelOverbooking();
}
-----------------------------------------------------------------------
trip_manager.h
-----------------------------------------------------------------------
#pragma once
#include "flight_provider.h"
#include "hotel_provider.h"

#include <string>
#include <deque>

class Trip {
public:

    Trip(HotelProvider& hp, FlightProvider& fp) : hotel_provider(hp), flight_provider(fp) {}

    Trip() = default;
    Trip(const Trip&) = default;
    Trip(Trip&&) = default;
    Trip& operator=(const Trip&) = default;
    Trip& operator=(Trip&&) = default;

    void add_flights(int value) {
        flights.push_back(value);
    }

    void add_hotels(int value) {
        hotels.push_back(value);
    }

    void Cancel() {

        for (size_t i = 0; i < flights.size(); ++i) {
            flight_provider.Cancel(i);
        }

        for (size_t i = 0; i < hotels.size(); ++i) {
            hotel_provider.Cancel(i);
        }
    }

    ~Trip() {
        Cancel();
    };

private:
    HotelProvider& hotel_provider;
    FlightProvider& flight_provider;

    std::deque<HotelProvider::BookingId> hotels;
    std::deque<FlightProvider::BookingId> flights;
};

class TripManager {
public:

    using BookingId = std::string;

    struct BookingData {
        std::string city_from;
        std::string city_to;
        std::string date_from;
        std::string date_to;
    };

    Trip Book(const BookingData& data) {
        Trip trip(hotel_provider_, flight_provider_);
        {
            FlightProvider::BookingData flight_booking_data;

            flight_booking_data.city_from = data.city_from;
            flight_booking_data.city_to = data.city_to;
            flight_booking_data.date = data.date_from;

            trip.add_flights(flight_provider_.Book(flight_booking_data));
        }

        {
            HotelProvider::BookingData hotel_booking_data;

            hotel_booking_data.city = data.city_to;
            hotel_booking_data.date_to = data.date_to;
            hotel_booking_data.date_from = data.date_from;

            trip.add_hotels(hotel_provider_.Book(hotel_booking_data));
        }

        {
            FlightProvider::BookingData flight_booking_data;

            flight_booking_data.city_from = data.city_from;
            flight_booking_data.city_to = data.city_to;
            flight_booking_data.date = data.date_to;

            trip.add_flights(flight_provider_.Book(flight_booking_data));
        }

        return trip;
    }

    void Cancel(Trip& trip) {
        trip.Cancel();
    }

private:
    HotelProvider hotel_provider_;
    FlightProvider flight_provider_;
};
-----------------------------------------------------------------------
hotel_provider.h
-----------------------------------------------------------------------
#pragma once
#include <stdexcept>
#include <string>

class HotelProvider {
public:
    using BookingId = int;

    struct BookingData {
        std::string city;
        std::string date_from;
        std::string date_to;
    };

    BookingId Book(const BookingData&) {
        using namespace std;
        if (counter >= capacity) {
            throw runtime_error("Hotel overbooking"s);
        }
        counter++;
        return counter;
    }

    void Cancel(const BookingId&) {
        using namespace std;
        counter--;
        if (counter < 0) {
            counter = 0;
        }
    }

public:
    static int capacity;
    static int counter;
};
-----------------------------------------------------------------------
flight_provider.h
-----------------------------------------------------------------------
#pragma once
#include <stdexcept>
#include <string>

class FlightProvider {
public:
    using BookingId = int;

    struct BookingData {
        std::string city_from;
        std::string city_to;
        std::string date;
    };

    BookingId Book(const BookingData&) {
        using namespace std;
        if (counter >= capacity) {
            throw runtime_error("Flight overbooking"s);
        }
        counter++;
        return counter;
    }
    void Cancel(const BookingId&) {
        using namespace std;
        counter--;
        if (counter < 0) {
            counter = 0;
        }
    }

public:
    static int capacity;
    static int counter;
};