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

-----------------------------------------------------------------------
main.cpp
-----------------------------------------------------------------------
#include "new_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();
}
-----------------------------------------------------------------------
new_flight_provider.h
-----------------------------------------------------------------------
#pragma once

#include "booking.h"
#include <iostream>

#include <stdexcept>
#include <string>

class FlightProvider {
public:
    using BookingId = int;
    using Booking = raii::Booking<FlightProvider>;
    friend Booking;

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

    Booking Book(const BookingData&) {
        using namespace std;

        if (counter >= capacity) {
            throw runtime_error("Flight overbooking"s);
        }
        counter++;
        return {this, counter};
    }

private:

    void CancelOrComplete(const Booking&) {
        counter--;
        if (0 > counter) {
            counter = 0;
        }
    }

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

class HotelProvider {
public:
    using BookingId = int;
    using Booking = raii::Booking<HotelProvider>;
    friend Booking;

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

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

private:
    void CancelOrComplete(const Booking&) {
        counter--;
        if (0 > counter) {
            counter = 0;
        }
    }

public:
    static int capacity;
    static int counter;
};
-----------------------------------------------------------------------
new_trip_manager.h
-----------------------------------------------------------------------
#pragma once
#include "new_flight_provider.h"
#include "new_hotel_provider.h"

#include <vector>

class Trip {
public:
    std::vector<HotelProvider::Booking> hotels;
    std::vector<FlightProvider::Booking> flights;

    Trip() = default;
    Trip(const Trip&) = delete;
    Trip(Trip&&) = default;
    ~Trip() = default;

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

    void Cancel() {
        hotels.clear();
        flights.clear();
    }
};

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

    Trip Book(const BookingData&) {
        Trip trip;
        {
            FlightProvider::BookingData flight_booking_data;
            trip.flights.push_back(flight_provider_.Book(flight_booking_data));
        }
        {
            HotelProvider::BookingData hotel_booking_data;
            trip.hotels.push_back(hotel_provider_.Book(hotel_booking_data));
        }
        {
            FlightProvider::BookingData flight_booking_data;
            trip.flights.push_back(flight_provider_.Book(flight_booking_data));
        }
        return trip;
    }

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

private:
    HotelProvider hotel_provider_;
    FlightProvider flight_provider_;
};
-----------------------------------------------------------------------
booking.h
-----------------------------------------------------------------------
#pragma once

#include <utility>
#include <cassert>

namespace raii {

template <typename Provider>
class Booking {
public:
    using BookingId = typename Provider::BookingId;

    Booking(Provider* p, BookingId id) : provider_(p), id_(id) {}

    Booking(const Booking&) = delete;
    Booking& operator=(const Booking&) = delete;

    Booking(Booking&& other) {

        assert(provider_ == nullptr);
        provider_ = std::exchange(other.provider_, nullptr);
        id_ = std::move(other.id_);

    }

    Booking& operator=(Booking&& other) {

        if (provider_ != other.provider_) {
            provider_ = std::exchange(other.provider_, nullptr);
            id_ = std::move(other.id_);
        }

        return *this;
    }

    ~Booking() {

        provider_->CancelOrComplete(*this);
    }

    BookingId GetId() const {

        return id_;
    }

private:
    Provider* provider_ = nullptr;
    BookingId id_;

};

}//end namespace booking