Project 3

Here's the code for above problem statement

#include <iostream>
#include <vector>
#include <string>
#include <limits>
#include <memory>

enum class FuelType {
GAS,
DIESEL,
ELECTRIC
};

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

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

virtual ~Vehicle() {}

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

virtual FuelType getFuelType() const = 0;

virtual void checkTireRotation() const {
std::cout << "Checking tire rotation for " << make << " " << model << std::endl;
}

void updateOdometer(int newOdometer) {
odometer = newOdometer;
}
};

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

FuelType getFuelType() const override {
return FuelType::GAS;
}
};

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

FuelType getFuelType() const override {
return FuelType::DIESEL;
}
};

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

FuelType getFuelType() const override {
return FuelType::ELECTRIC;
}

void checkChargerPower() const {
std::cout << "Checking charger power for " << make << " " << model << std::endl;
}

void checkTireRotation() const override {
if (odometer % 50000 == 0)
std::cout << "Tire rotation is needed for " << make << " " << model << std::endl;
else
std::cout << "Tires are in good condition for " << make << " " << model << std::endl;
}
};

class MaintenanceSystem {
private:
std::vector<std::unique_ptr<Vehicle>> vehicles;

public:
bool empty() const {
return vehicles.empty();
}

size_t size() const {
return vehicles.size();
}

void addVehicle(Vehicle* vehicle) {
vehicles.push_back(std::unique_ptr<Vehicle>(vehicle));
}

void listVehicles() const {
for (const auto& vehicle : vehicles) {
std::cout << "Make: " << vehicle->getMake() << ", Model: " << vehicle->getModel()
<< ", Year: " << vehicle->getYear() << ", Odometer: " << vehicle->getOdometer() << std::endl;
}
}

void updateVehicle(int index, int newOdometer) {
if (index >= 0 && index < vehicles.size()) {
vehicles[index]->checkTireRotation();
ElectricCar* electricCar = dynamic_cast<ElectricCar*>(vehicles[index].get());
if (electricCar)
electricCar->checkChargerPower();
vehicles[index]->updateOdometer(newOdometer); // Update odometer reading
}
}

void removeVehicle(int index) {
if (index >= 0 && index < vehicles.size()) {
vehicles.erase(vehicles.begin() + index);
}
}

void tireRotation() const {
std::cout << "Checking tire rotation for all vehicles:" << std::endl;
for (const auto& vehicle : vehicles) {
vehicle->checkTireRotation();
}
}

void oilChange() const {
std::cout << "Checking oil change for all vehicles:" << std::endl;
for (const auto& vehicle : vehicles) {
if (vehicle->getOdometer() % 5000 == 0) {
std::cout << "Oil change required for: ";
std::cout << "Make: " << vehicle->getMake() << ", Model: " << vehicle->getModel()
<< ", Year: " << vehicle->getYear() << ", Odometer: " << vehicle->getOdometer() << std::endl;
}
}
}

void recharge() const {
std::cout << "Checking recharge for electric vehicles:" << std::endl;
for (const auto& vehicle : vehicles) {
ElectricCar* electricCar = dynamic_cast<ElectricCar*>(vehicle.get());
if (electricCar) {
electricCar->checkChargerPower();
}
}
}
};

std::string getNewMake() {
std::string make;
do {
std::cout << "Enter the vehicle's make: ";
std::getline(std::cin, make);
} while (make.empty());
return make;
}

std::string getNewModel() {
std::string model;
do {
std::cout << "Enter the vehicle's model: ";
std::getline(std::cin, model);
} while (model.empty());
return model;
}

int getYear() {
int year;
do {
std::cout << "Enter the vehicle's year (4 digits): ";
std::cin >> year;
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // Clear the input buffer
} while (year < 1000 || year > 9999);
return year;
}

int getNewOdometer() {
int odometer;
do {
std::cout << "Enter the vehicle's odometer reading: ";
std::cin >> odometer;
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // Clear the input buffer
} while (std::cin.fail());
return odometer;
}

FuelType getNewFuelType() {
int type;
do {
std::cout << "Enter the vehicle's fuel type (0 - Gas, 1 - Diesel, 2 - Electric): ";
std::cin >> type;
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // Clear the input buffer
} while (type < 0 || type > 2);
return static_cast<FuelType>(type);
}

int selectCar(int vehicleCount) {
int choice;
do {
std::cout << "Select a vehicle (1-" << vehicleCount << "): ";
std::cin >> choice;
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // Clear the input buffer
} while (choice < 1 || choice > vehicleCount);
return choice - 1; // Return index (0-based) of selected vehicle
}

int getNewOdometerReading() {
return getNewOdometer(); // For simplicity, assume the same function for new odometer reading
}

void addVehicle(MaintenanceSystem& maintenanceSystem) {
std::string make = getNewMake();
std::string model = getNewModel();
int year = getYear();
int odometer = getNewOdometer();
FuelType type = getNewFuelType();

switch (type) {
case FuelType::GAS: {
GasCar* gasCar = new GasCar(make, model, year, odometer);
maintenanceSystem.addVehicle(gasCar);
break;
}
case FuelType::DIESEL: {
DieselCar* dieselCar = new DieselCar(make, model, year, odometer);
maintenanceSystem.addVehicle(dieselCar);
break;
}
case FuelType::ELECTRIC: {
ElectricCar* electricCar = new ElectricCar(make, model, year, odometer);
maintenanceSystem.addVehicle(electricCar);
break;
}
default:
std::cout << "Invalid fuel type.\n";
break;
}

std::cout << "Vehicle added successfully.\n";
}

void updateVehicle(MaintenanceSystem& maintenanceSystem) {
maintenanceSystem.listVehicles();
if (maintenanceSystem.empty()) {
std::cout << "No vehicles to update.\n";
return;
}

int index = selectCar(maintenanceSystem.size());
int newOdometer = getNewOdometerReading();

maintenanceSystem.updateVehicle(index, newOdometer);
std::cout << "Vehicle updated successfully.\n";
}

void removeVehicle(MaintenanceSystem& maintenanceSystem) {
maintenanceSystem.listVehicles();
if (maintenanceSystem.empty()) {
std::cout << "No vehicles to remove.\n";
return;
}

int index = selectCar(maintenanceSystem.size());
maintenanceSystem.removeVehicle(index);
std::cout << "Vehicle removed successfully.\n";
}

int getUserInput() {
int choice;
std::cout << "Select an option: ";
std::cin >> choice;
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // Clear the input buffer
return choice;
}

int main() {
MaintenanceSystem maintenanceSystem;

int choice;
do {
std::cout << "Menu:" << std::endl;
std::cout << "0. Quit\n"
<< "1. List inventory\n"
<< "2. Add vehicle\n"
<< "3. Update vehicle\n"
<< "4. Remove vehicle\n"
<< "5. Tire Rotation\n"
<< "6. Oil Change\n"
<< "7. Recharge\n";

choice = getUserInput();

switch (choice) {
case 0:
std::cout << "Quitting...\n";
break;
case 1:
maintenanceSystem.listVehicles();
break;
case 2:
addVehicle(maintenanceSystem);
break;
case 3:
updateVehicle(maintenanceSystem);
break;
case 4:
removeVehicle(maintenanceSystem);
break;
case 5:
maintenanceSystem.tireRotation();
break;
case 6:
maintenanceSystem.oilChange();
break;
case 7:
maintenanceSystem.recharge();
break;
default:
std::cout << "Invalid choice. Please try again.\n";
break;
}
} while (choice != 0);

return 0;
}

output of the above code