Project 3

/******************************************************************************

Welcome to GDB Online.
GDB online is an online compiler and debugger tool for C, C++, Python, Java, PHP, Ruby, Perl,
C#, OCaml, VB, Swift, Pascal, Fortran, Haskell, Objective-C, Assembly, HTML, CSS, JS, SQLite, Prolog.
Code, Compile, Run and Debug online from anywhere in world.

*******************************************************************************/
#include <iostream>
#include <vector>
#include <limits>
#include <algorithm>

enum Type {
    GAS,
    DIESEL,
    ELECTRIC
};

class Vehicle {
protected:
    std::string make;
    std::string model;
    int year;
    int odometer;

public:
    Vehicle(std::string make, std::string model, int year, int odometer)
        : make(make), model(model), year(year), odometer(odometer) {}

    // Getter functions
    std::string getMake() const { return make; }
    std::string getModel() const { return model; }
    int getYear() const { return year; }
    int getOdometer() const { return odometer; }

    // Setter functions
    void setMake(std::string newMake) { make = newMake; }
    void setModel(std::string newModel) { model = newModel; }
    void setYear(int newYear) { year = newYear; }
    void setOdometer(int newOdometer) { odometer = newOdometer; }

    virtual Type getType() const = 0;
    virtual void maintenanceActivities() = 0;
};

class GasCar : public Vehicle {
public:
    GasCar(std::string make, std::string model, int year, int odometer)
        : Vehicle(make, model, year, odometer) {}

    Type getType() const override { return Type::GAS; }
    void maintenanceActivities() override {
        // Implement gas car maintenance activities here
        std::cout << "Performing maintenance activities for Gas Car." << std::endl;
    }
};

class DieselCar : public Vehicle {
public:
    DieselCar(std::string make, std::string model, int year, int odometer)
        : Vehicle(make, model, year, odometer) {}

    Type getType() const override { return Type::DIESEL; }
    void maintenanceActivities() override {
        // Implement diesel car maintenance activities here
        std::cout << "Performing maintenance activities for Diesel Car." << std::endl;
    }
};

class ElectricCar : public Vehicle {
public:
    ElectricCar(std::string make, std::string model, int year, int odometer)
        : Vehicle(make, model, year, odometer) {}

    Type getType() const override { return Type::ELECTRIC; }
    void maintenanceActivities() override {
        // Implement electric car maintenance activities here
        std::cout << "Performing maintenance activities for Electric Car." << std::endl;
    }
};

class MaintenanceTracker {
private:
    std::vector<Vehicle*> vehicles;

public:
    // Destructor to free memory for dynamically allocated vehicles
    ~MaintenanceTracker() {
        for (Vehicle* vehicle : vehicles) {
            delete vehicle;
        }
    }

    void addVehicle(Vehicle* vehicle) {
        vehicles.push_back(vehicle);
    }

    void listVehicles() const {
        for (size_t i = 0; i < vehicles.size(); i++) {
            std::cout << "Vehicle " << i + 1 << ":\n";
            std::cout << "Make: " << vehicles[i]->getMake() << ", ";
            std::cout << "Model: " << vehicles[i]->getModel() << ", ";
            std::cout << "Year: " << vehicles[i]->getYear() << ", ";
            std::cout << "Odometer: " << vehicles[i]->getOdometer() << " km\n";
            std::cout << "Fuel Type: ";
            switch (vehicles[i]->getType()) {
                case Type::GAS:
                    std::cout << "Gas" << std::endl;
                    break;
                case Type::DIESEL:
                    std::cout << "Diesel" << std::endl;
                    break;
                case Type::ELECTRIC:
                    std::cout << "Electric" << std::endl;
                    break;
                default:
                    std::cout << "Unknown" << std::endl;
                    break;
            }
        }
    }

    void updateVehicle(int index) {
        if (index >= 0 && index < vehicles.size()) {
            std::string newMake, newModel;
            int newYear, newOdometer;

            std::cout << "Enter the new make: ";
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // Ignore newline character from previous input
            std::getline(std::cin, newMake);
            std::cout << "Enter the new model: ";
            std::getline(std::cin, newModel);
            std::cout << "Enter the new year: ";
            std::cin >> newYear;
            std::cout << "Enter the new odometer reading: ";
            std::cin >> newOdometer;

            vehicles[index]->setMake(newMake);
            vehicles[index]->setModel(newModel);
            vehicles[index]->setYear(newYear);
            vehicles[index]->setOdometer(newOdometer);
        } else {
            std::cout << "Invalid index." << std::endl;
        }
    }

    void removeVehicle(int index) {
        if (index >= 0 && index < vehicles.size()) {
            delete vehicles[index];
            vehicles.erase(vehicles.begin() + index);
        } else {
            std::cout << "Invalid index." << std::endl;
        }
    }
};

// Function to get user input within a specific range
int getUserInput(int lower, int upper) {
    int input;
    while (true) {
        std::cin >> input;
        if (std::cin.fail() || input < lower || input > upper) {
            std::cout << "Invalid input. Please try again: ";
            std::cin.clear();
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        } else {
            return input;
        }
    }
}

int main() {
    MaintenanceTracker tracker;
    int choice;

    do {
        std::cout << "Menu:\n"
                  << "   0. Quit.\n"
                  << "   1. List inventory.\n"
                  << "   2. Add vehicle.\n"
                  << "   3. Update vehicle\n"
                  << "   4. Remove vehicle\n"
                  << "Enter your choice (0-4): ";

        choice = getUserInput(0, 4);

        std::string make;
        std::string model;
        int year;
        int odometer;
        int fuelType;
        Vehicle* newVehicle;

        switch (choice) {
            case 0:
                std::cout << "Exiting the program.\n";
                break;
            case 1:
                std::cout << "Listing inventory:\n";
                tracker.listVehicles();
                break;
            case 2:
                std::cout << "Adding a new vehicle:\n";
                std::cout << "Enter the make: ";
                std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // Ignore newline character from previous input
                std::getline(std::cin, make);
                std::cout << "Enter the model: ";
                std::getline(std::cin, model);
                std::cout << "Enter the year: ";
                std::cin >> year;
                std::cout << "Enter the odometer reading: ";
                std::cin >> odometer;
                std::cout << "Enter the fuel type (0-GAS, 1-DIESEL, 2-ELECTRIC): ";
                fuelType = getUserInput(0, 2);

                switch (fuelType) {
                    case 0:
                        newVehicle = new GasCar(make, model, year, odometer);
                        break;
                    case 1:
                        newVehicle = new DieselCar(make, model, year, odometer);
                        break;
                    case 2:
                        newVehicle = new ElectricCar(make, model, year, odometer);
                        break;
                    default:
                        std::cout << "Invalid fuel type." << std::endl;
                        continue;
                }
                tracker.addVehicle(newVehicle);
                break;
            case 3:
                std::cout << "Updating a vehicle:\n";
                std::cout << "Enter the index of the vehicle to update: ";
                int updateIndex;
                std::cin >> updateIndex;
                tracker.updateVehicle(updateIndex);
                break;
            case 4:
                std::cout << "Removing a vehicle:\n";
                std::cout << "Enter the index of the vehicle to remove: ";
                int removeIndex;
                std::cin >> removeIndex;
                tracker.removeVehicle(removeIndex);
                break;
            default:
                std::cout << "Invalid choice. Please try again.\n";
                break;
        }
    } while (choice != 0);

    return 0;
}

Output