traintypes.h

Go to the documentation of this file.

 
#ifndef carLocTypes_enum
#define carLocTypes_enum
 
#include <string>
#include <stdexcept>
#include "../util/vector.h"
#include "../util/error.h"
#include <map>
 
namespace TrainTypes {
 
    static const int carTypeN = 5;
 
 
    enum class _CarType {
        cargo,
        dieselTender,
        batteryTender,
        hydrogenTender,
        biodieselTender
    };
 
    using CarType = _CarType;
 
    static const Vector<CarType> carRechargableTechnologies = {
        CarType::batteryTender
    };
 
    static const Vector<CarType> carNonRechargableTechnologies = {
        CarType::dieselTender,
        CarType::hydrogenTender,
        CarType::biodieselTender
    };
 
    static const std::string carTypeStrings[] = {
    "Cargo Car",
    "Diesel Tank",
    "Battery Tender",
    "Hydrogen Tender",
    "Biodiesel Tank"
    };
 
    static const CarType carTypeArray[] = {
    CarType::cargo,
    CarType::dieselTender,
    CarType::batteryTender,
    CarType::hydrogenTender,
    CarType::biodieselTender
    };
 
    inline Vector<CarType> getCarTypeVector() {
        Vector<CarType> carTypeVector;
        for (auto c : carTypeArray) {
            carTypeVector.push_back(c);
        }
        return carTypeVector;
    }
 
 
    static const std::map<std::string, CarType> carTypeMap = {
    {"Cargo Car", CarType::cargo},
    {"Fuel Tank", CarType::dieselTender},
    {"Battery Tender", CarType::batteryTender},
    {"Hydrogen Tender", CarType::hydrogenTender},
    {"Biodiesel Tender", CarType::biodieselTender}
    };
 
    inline std::string carTypeToStr(CarType type) {
        return carTypeStrings[static_cast<int>(type)];
    }
 
    inline CarType strtoCarType(const std::string& cartype) {
        auto it = carTypeMap.find(cartype);
        if (it == carTypeMap.end()) {
            throw std::invalid_argument("Error: " + std::to_string(static_cast<int>(Error::trainWrongCarType)) +
                                        "\nInvalid car type");
        }
        return it->second;
    }
 
    inline CarType itoCarType(int cartype) {
        if (cartype < 0 || cartype >= carTypeN) {
            throw std::invalid_argument("Error: " + std::to_string(static_cast<int>(Error::trainWrongCarType)) +
                                        "\nInvalid car type");
        }
        return carTypeArray[cartype];
    }
 
    inline std::ostream& operator<<(std::ostream& ss, const CarType& obj) {
        ss << carTypeStrings[static_cast<int>(obj)];
        return ss;
    }
 
    static const int powerTypeN = 7;
    enum class _PowerType {
        diesel,
        electric,
        biodiesel,
        dieselElectric,
        dieselHybrid,
        hydrogenHybrid,
        biodieselHybrid
    };
 
    using PowerType = _PowerType;
 
    static const Vector<PowerType> locomotiveRechargableTechnologies = {
        PowerType::electric,
        PowerType::dieselHybrid,
        PowerType::hydrogenHybrid,
        PowerType::biodieselHybrid
    };
 
    static const Vector<PowerType> locomotiveNonRechargableTechnologies = {
        PowerType::diesel,
        PowerType::biodiesel,
        PowerType::dieselElectric  // it does not have a battery to store energy in
    };
 
    static const Vector<PowerType> locomotiveTankOnly = {
        PowerType::diesel,
        PowerType::biodiesel,
        PowerType::dieselElectric  // it does not have a battery to store energy in
    };
 
    static const Vector<PowerType> locomotiveBatteryOnly = {
        PowerType::electric
    };
 
    static const Vector<PowerType> locomotiveHybrid = {
        PowerType::dieselElectric,
        PowerType::dieselHybrid,
        PowerType::hydrogenHybrid,
        PowerType::biodieselHybrid
    };
 
    static const std::string powerTypeStrings[] = {
    "Diesel Locomotive",
    "Electric Locomotive",
    "Biodiesel Locomotive",
    "Diesel-Electric Locomotive",
    "Diesel-Hybrid Locomotive",
    "Hydrogen-Hybrid Locomotive",
    "Biodiesel-Hybrid Locomotive"
    };
 
    static const PowerType powerTypeArray[] = {
    PowerType::diesel, // 0
    PowerType::electric, // 1
    PowerType::biodiesel,  //2
    PowerType::dieselElectric, //3  // all locomotives now are diesel
    PowerType::dieselHybrid,  //4
    PowerType::hydrogenHybrid, //5
    PowerType::biodieselHybrid //6
    };
 
    static const std::map<std::string, PowerType> powerTypeMap = {
    {"Diesel Locomotive", PowerType::diesel},
    {"Electric Locomotive", PowerType::electric},
    {"Biodiesel Locomotive", PowerType::biodiesel},
    {"Diesel-Electric Locomotive", PowerType::dieselElectric},
    {"Diesel-Hyprid Locomotive", PowerType::dieselHybrid},
    {"Hydrogen-Hyprid Locomotive", PowerType::hydrogenHybrid},
    {"biodiesel-Hyprid Locomotive", PowerType::biodieselHybrid}
    };
 
    static const std::map<PowerType, CarType> powerToCarMap = {
        {PowerType::diesel, CarType::dieselTender},
        {PowerType::electric, CarType::batteryTender},
        {PowerType::biodiesel, CarType::biodieselTender},
        {PowerType::dieselHybrid, CarType::dieselTender},
        {PowerType::hydrogenHybrid, CarType::hydrogenTender},
        {PowerType::biodieselHybrid, CarType::biodieselTender}
    };
 
    inline std::string PowerTypeToStr(PowerType type) {
        return powerTypeStrings[static_cast<int>(type)];
    }
 
    inline PowerType strToPowerType(std::string powertype) {
        auto it = powerTypeMap.find(powertype);
        if (it == powerTypeMap.end()) {
            throw std::invalid_argument("Error: " + std::to_string(static_cast<int>(Error::trainWrongLocoType)) +
                                        "\nInvalid locomotive type");
        }
        return it->second;
    }
 
    inline PowerType iToPowerType(int powertype) {
        if (powertype < 0 || powertype >= powerTypeN) {
            throw std::invalid_argument("Error: " + std::to_string(static_cast<int>(Error::trainWrongLocoType)) +
                                        "\nInvalid locomotive type");
        }
        return powerTypeArray[powertype];
    }
 
    inline std::ostream& operator<<(std::ostream& ss, const PowerType& obj) {
        ss << powerTypeStrings[static_cast<int>(obj)];
        return ss;
    }
 
    static const int powerMethodN = 2;
    enum class _LocomotivePowerMethod {
        notApplicable,
        series,
        parallel
    };
 
    using LocomotivePowerMethod = _LocomotivePowerMethod;
    static const std::string powerMethodsStrings[] = {
        "Not Applicable"
        "Series Hybrid Power",
        "Parallel Hybrid Power"
    };
    static const LocomotivePowerMethod powerMethodArray[] = {
        LocomotivePowerMethod::notApplicable, //0
        LocomotivePowerMethod::series, // 1
        LocomotivePowerMethod::parallel //2
    };
 
    static const std::map<std::string, LocomotivePowerMethod> powerMethodMap = {
        {"Series Hybrid Power", LocomotivePowerMethod::series},
        {"Series Hybrid Power", LocomotivePowerMethod::series},
        {"Parallel Hybrid Power", LocomotivePowerMethod::parallel}
    };
 
 
    inline LocomotivePowerMethod strToPowerMethod(std::string powertype) {
        auto it = powerMethodMap.find(powertype);
        if (it == powerMethodMap.end()) {
            throw std::invalid_argument("Error: " + std::to_string(static_cast<int>(Error::trainWrongLocoType)) +
                                        "\nInvalid locomotive type");
        }
        return it->second;
    }
 
    inline LocomotivePowerMethod iToPowerMethod(int powertype) {
        if (powertype < 0 || powertype >= powerMethodN) {
            throw std::invalid_argument("Error: " + std::to_string(static_cast<int>(Error::trainWrongLocoType)) +
                                        "\nInvalid locomotive type");
        }
        return powerMethodArray[powertype];
    }
 
    inline std::ostream& operator<<(std::ostream& ss, const LocomotivePowerMethod& obj) {
        ss << powerMethodsStrings[static_cast<int>(obj)];
        return ss;
    }
 
 
    static const int fuelN = 4;
    enum class _fuelTypes {
        diesel,
        biodiesel,
        hydrogen,
        noFuel
    };
 
    using FuelType = _fuelTypes;
 
    static const std::string fuelStrings[] = {
        "Diesel Fuel",
        "Biodiesel Fuel",
        "Hydrogen-Hyprid Fuel",
        "No Fuel"
    };
 
    static const FuelType fuelArray[] = {
        FuelType::diesel,     //0
        FuelType::biodiesel,  //1
        FuelType::hydrogen,   //2
        FuelType::noFuel      //3
    };
 
    static const std::map<std::string, FuelType> fuelMap = {
        {"Diesel Fuel", FuelType::diesel},
        {"Biodiesel Fuel", FuelType::biodiesel},
        {"Hydrogen Fuel", FuelType::hydrogen},
        {"No Fuel", FuelType::noFuel}
    };
 
    static const std::map<PowerType, FuelType> powerToFuelMap = {
        {PowerType::diesel, FuelType::diesel},
        {PowerType::electric, FuelType::noFuel},
        {PowerType::biodiesel, FuelType::biodiesel},
        {PowerType::dieselHybrid, FuelType::diesel},
        {PowerType::hydrogenHybrid, FuelType::hydrogen},
        {PowerType::biodieselHybrid, FuelType::biodiesel}
    };
 
    static const std::map<CarType, FuelType> carToFuelMap = {
        {CarType::cargo, FuelType::noFuel},
        {CarType::batteryTender, FuelType::noFuel},
        {CarType::biodieselTender, FuelType::biodiesel},
        {CarType::dieselTender, FuelType::diesel},
        {CarType::hydrogenTender, FuelType::hydrogen}
    };
 
    inline std::string fuelTypeToStr(FuelType type) {
        return fuelStrings[static_cast<int>(type)];
    }
 
    inline FuelType getFuelTypeFromPowerType(PowerType theType) {
        auto it = powerToFuelMap.find(theType);
        if (it != powerToFuelMap.end()) {
            return it->second;
        } else {
            throw std::invalid_argument("Invalid PowerType");
        }
    }
 
}
 
#endif // !carLocTypes_enum