/* public eVehicleType VehicleType
* {
* get
* {
* return m_vehicleType;
* }
* set
* {
* m_vehicleType = value;
* }
* }*/
public static Vehicle CreateNewVehicle(eVehicleType i_VehicleType, VehicleInformation i_vehicleInformation, Dictionary <string, Object> i_specificInformation)
{
Vehicle newVehicle;
switch (i_VehicleType)
{
case eVehicleType.ElectricCar:
newVehicle = CreateElectricCar(i_vehicleInformation, i_specificInformation);
break;
case eVehicleType.ElectricMotorcycle:
newVehicle = CreateElectricMotorcycle(i_vehicleInformation, i_specificInformation);
break;
case eVehicleType.FuelBasedCar:
newVehicle = CreateFuelCar(i_vehicleInformation, i_specificInformation);
break;
case eVehicleType.FuelBasedMotorcycle:
newVehicle = CreateFuelMotorcycle(i_vehicleInformation, i_specificInformation);
break;
case eVehicleType.FuelBasedTruck:
newVehicle = CreateFuelTruck(i_vehicleInformation, i_specificInformation);
break;
default: throw new ArgumentException();
}
return(newVehicle);
}
private static Vehicle createFuelVehicle(eVehicleType i_VehicleType)
{
Vehicle createdVehicle = null;
FuelEngine createdFuelEngine = null;
switch (i_VehicleType)
{
case eVehicleType.Car:
createdFuelEngine = new FuelEngine(0, 60, FuelEngine.eFuelType.Octan96);
createdVehicle = createCar(createdFuelEngine);
break;
case eVehicleType.Motorbike:
createdFuelEngine = new FuelEngine(0, 7, FuelEngine.eFuelType.Octan95);
createdVehicle = createMotorbike(createdFuelEngine);
break;
case eVehicleType.Truck:
createdFuelEngine = new FuelEngine(0, 120, FuelEngine.eFuelType.Soler);
createdVehicle = createTruck(createdFuelEngine);
break;
}
return(createdVehicle);
}
public static Vehicle BuildVehicle(eVehicleType i_SelectedType)
{
Vehicle newVehicle = null;
switch (i_SelectedType)
{
case eVehicleType.FuelTruck:
newVehicle = new FuelTruck();
break;
case eVehicleType.ElectricCar:
newVehicle = new ElectricCar();
break;
case eVehicleType.ElectricBike:
newVehicle = new ElectricBike();
break;
case eVehicleType.FuelBike:
newVehicle = new FuelBike();
break;
case eVehicleType.FuelCar:
newVehicle = new FuelCar();
break;
}
return(newVehicle);
}
public static Vehicle CreateVehicle(string i_LicenseNumber, eVehicleType i_Type, string i_Model)
{
Vehicle newVehicle = null;
switch (i_Type)
{
case eVehicleType.ElectricCar:
case eVehicleType.FuelCar:
newVehicle = new Car(i_LicenseNumber, i_Model);
break;
case eVehicleType.ElectricMotorcycle:
case eVehicleType.FuelMotorcycle:
newVehicle = new Motorcycle(i_LicenseNumber, i_Model);
break;
case eVehicleType.Truck:
newVehicle = new Truck(i_LicenseNumber, i_Model);
break;
default:
throw new FormatException("Invalid Vehicle Type");
}
return(newVehicle);
}
private static void getWheelsInfo(eVehicleType i_Type, Vehicle i_Vehicle)
{
string manufacturer = ConsoleUI.GetField("Manufacturer name: ", !v_LettersNumbersOnly, !v_NumbersOnly, v_LettersOnly);
float airPressure = ConsoleUI.ConvertToFloat(ConsoleUI.GetUserInput("Current air pressure: "));
setWheels(manufacturer, airPressure, i_Type, i_Vehicle);
}
private List <string> getBasicParametersList(eVehicleType i_VehicleType)
{
//// Basic user display parameters
List <string> parameterList =
new List <string>()
{
"Owner Name", "Owner Phone Number", "Wheels Manufacturer", "Wheels Pressure"
};
switch (i_VehicleType)
{
case eVehicleType.FuelBasedCar:
case eVehicleType.FuelBasedMotorcycle:
case eVehicleType.FuelBasedTruck:
parameterList.Add("Current Fuel Amount (liters)");
break;
case eVehicleType.ElectricCar:
case eVehicleType.ElectricMotorcycle:
parameterList.Add("Time left in Battery (hours)");
break;
}
return(parameterList);
}
public Vehicle CreateVehicle(string i_LicenseNumber, string i_ModelName, eVehicleType i_VehicleType)
{
Vehicle vehicle = null;
Engine engine = createEngine(i_VehicleType);
switch (i_VehicleType)
{
case eVehicleType.ElectricCar:
case eVehicleType.FuelBasedCar:
vehicle = new Car(i_LicenseNumber, i_ModelName, engine);
break;
case eVehicleType.ElectricMotorcycle:
case eVehicleType.FuelBasedMotorcycle:
vehicle = new Motorcycle(i_LicenseNumber, i_ModelName, engine);
break;
case eVehicleType.FuelBasedTruck:
vehicle = new Truck(i_LicenseNumber, i_ModelName, engine);
break;
}
vehicle.VehicleType = i_VehicleType;
addWheels(vehicle, i_VehicleType);
return(vehicle);
}
private static Vehicle createTruck(List <string> i_VehicleParametersStrings, eVehicleType i_VehicleType)
{
string modelName;
string licenseNumber;
float energyPercentageLeft;
string tireManufactureName;
float tireCurrentAirPressure;
bool isContainingHazardousMaterials =
i_VehicleParametersStrings[(int)eExtraParametersInputOrder.TruckHazardousMaterials] == "1";
float maxCarryingWeight = Convert.ToSingle(
i_VehicleParametersStrings[(int)eExtraParametersInputOrder.TruckMaxCarryingWeight]);
getVehicleParameters(
i_VehicleParametersStrings,
out modelName,
out licenseNumber,
out energyPercentageLeft,
out tireManufactureName,
out tireCurrentAirPressure);
Engine engine = createFuelEngine(Truck.k_FuelType, Truck.k_MaxTankCapacity);
Truck truck = new Truck(i_VehicleType, modelName, licenseNumber, new Tire[Truck.k_NumberOfTires], engine, energyPercentageLeft, tireManufactureName, tireCurrentAirPressure, maxCarryingWeight, isContainingHazardousMaterials);
return(truck);
}
/* Public Methods */
public static void MakeNewVehicle(eVehicleType i_VehicleType, out Vehicle o_Vehicle)
{
o_Vehicle = null;
switch (i_VehicleType)
{
case (eVehicleType.ElectricBasedMotorcycle):
o_Vehicle = new ElectricBasedMotorcycle();
break;
case (eVehicleType.ElectricBasedCar):
o_Vehicle = new ElectricBasedCar();
break;
case (eVehicleType.FuelBasedMotorcycle):
o_Vehicle = new FuelBasedMotorcycle();
break;
case (eVehicleType.FuelBasedCar):
o_Vehicle = new FuelBasedCar();
break;
case (eVehicleType.FuelBasedTruck):
o_Vehicle = new FuelBasedTruck();
break;
default:
break;
}
}
private void initVehicleBuilder(eVehicleType i_VehicleType)
{
switch (i_VehicleType)
{
case eVehicleType.FuelCar:
m_VehicleBuilder = new FuelCarBuilder();
break;
case eVehicleType.ElectricCar:
m_VehicleBuilder = new ElectricCarBuilder();
break;
case eVehicleType.FuelMotorcycle:
m_VehicleBuilder = new FuelMotorcycleBuilder();
break;
case eVehicleType.ElectricMotorcycle:
m_VehicleBuilder = new ElectricMotorcycleBuilder();
break;
case eVehicleType.FuelTruck:
m_VehicleBuilder = new TruckBuilder();
break;
}
}
// Adding wheels information from user
private List <Wheel> GetWheelList(eVehicleType i_VehicleType)
{
List <Wheel> newWheelList = new List <Wheel>();
float inputNumberOfWheels = NumOfWheels(i_VehicleType);
for (int numOfWheel = 0; numOfWheel < inputNumberOfWheels; numOfWheel++)
{
Console.WriteLine("Wheel No." + (numOfWheel + 1) + " :");
float inputMaxPossiblePressure = MaxPossiblePressure(i_VehicleType);
string inputWheelManufacture = string.Empty;
float inputAirPressure;
inputMaxPossiblePressure = MaxPossiblePressure(i_VehicleType);
// Check if its not empty wheel manufacture name string
while (inputWheelManufacture == string.Empty)
{
Console.WriteLine("Please type the wheel No." + (numOfWheel + 1) + " manufacture name");
inputWheelManufacture = Console.ReadLine();
}
inputAirPressure = ChooseNumOf("air pressoure in wheel No." + (numOfWheel + 1) + "(float)", 0, inputMaxPossiblePressure);
Wheel newWheel = new Wheel(inputWheelManufacture, inputAirPressure, inputMaxPossiblePressure);
newWheelList.Add(newWheel);
}
return(newWheelList);
}
public static List <ParameterChecker> BuildExtraParametersInfo(eVehicleType i_VehicleType)
{
List <ParameterChecker> extraParameterProcessors;
switch (i_VehicleType)
{
case eVehicleType.Bike:
case eVehicleType.ElectricBike:
extraParameterProcessors = Bike.BuildExtraParametersList();
break;
case eVehicleType.Car:
case eVehicleType.ElectricCar:
extraParameterProcessors = Car.BuildExtraParametersList();
break;
case eVehicleType.Truck:
extraParameterProcessors = Truck.BuildExtraParametersList();
break;
default: throw new ArgumentOutOfRangeException();
}
return(extraParameterProcessors);
}
public VehicleCreation(Dictionary <string, string> i_Parametres, eVehicleType i_VehicleType)
{
this.m_Parametres = i_Parametres;
this.m_Vehicletype = i_VehicleType;
this.m_wheelType = createWheel();
m_Parametres.TryGetValue("Model Type", out this.m_ModelType);
string engineType;
m_Parametres.TryGetValue("Engine Type", out engineType);
m_Parametres.TryGetValue("Licence Number", out m_LicenceNum);
this.m_Engine = createEngine(engineType);
this.m_EnergyLeft = this.m_Engine.EnergyLeft / this.m_Engine.Capacity;
if (i_VehicleType == eVehicleType.ElectricCar || i_VehicleType == eVehicleType.RegularCar)
{
createCar();
}
if (i_VehicleType == eVehicleType.ElectricMotorcycle || i_VehicleType == eVehicleType.RegularMotorcycle)
{
createMotorcycle();
}
if (i_VehicleType == eVehicleType.Truck)
{
createTruck();
}
}
public static Vehicle ConstructVehicle(eVehicleType vehicleTypeToConstruct)
{
Vehicle constructedVehicle;
bool electricVehicle = true;
switch (vehicleTypeToConstruct)
{
case eVehicleType.FuelPoweredCar:
constructedVehicle = new Car(!electricVehicle);
break;
case eVehicleType.ElectricityPoweredCar:
constructedVehicle = new Car(electricVehicle);
break;
case eVehicleType.FuelPoweredMotorcycle:
constructedVehicle = new Motorcycle(!electricVehicle);
break;
case eVehicleType.ElectricityPoweredMotorcycle:
constructedVehicle = new Motorcycle(electricVehicle);
break;
case eVehicleType.FuelPoweredTruck:
constructedVehicle = new Truck(!electricVehicle);
break;
default:
throw new System.Exception("Type of vehicle not supported.");
}
return(constructedVehicle);
}
private static float verifyValidWheelPressure(eVehicleType i_VehicleType)
{
int maxAirPressureAccordingToVehicleType = 0;
switch (i_VehicleType)
{
case eVehicleType.ElectricBike:
case eVehicleType.FuelBike:
{
maxAirPressureAccordingToVehicleType = 33;
break;
}
case eVehicleType.ElectricCar:
case eVehicleType.FuelCar:
{
maxAirPressureAccordingToVehicleType = 30;
break;
}
case eVehicleType.Truck:
{
maxAirPressureAccordingToVehicleType = 32;
break;
}
}
return((float)manageUserInput(0, maxAirPressureAccordingToVehicleType));
}
public static List <Wheel> CreateWheels(eVehicleType i_VehicleType, string i_Manufacturer, float i_CurrAirPressure)
{
List <Wheel> wheels = new List <Wheel>();
int maxAirPressure;
int amountOfWheels;
if (i_VehicleType == eVehicleType.Car)
{
maxAirPressure = 32;
amountOfWheels = 4;
}
else if (i_VehicleType == eVehicleType.Motorcycle)
{
maxAirPressure = 28;
amountOfWheels = 2;
}
else
{
maxAirPressure = 16;
amountOfWheels = 30;
}
for (int i = 0; i < amountOfWheels; i++)
{
wheels.Add(new Wheel(i_Manufacturer, i_CurrAirPressure, maxAirPressure));
}
return(wheels);
}
public static Vehicle CreateNewVehicle(eVehicleType i_VehicleType, string i_plateNumber)
{
Vehicle newVehicle = null;
switch (i_VehicleType)
{
case eVehicleType.FuelCar:
newVehicle = new Car(eVehicleType.FuelCar, i_plateNumber);
break;
case eVehicleType.ElectricCar:
newVehicle = new Car(eVehicleType.ElectricCar, i_plateNumber);
break;
case eVehicleType.FuelMotorbike:
newVehicle = new Motorbike(eVehicleType.FuelMotorbike, i_plateNumber);
break;
case eVehicleType.ElectricMotorbike:
newVehicle = new Motorbike(eVehicleType.ElectricMotorbike, i_plateNumber);
break;
case eVehicleType.Truck:
newVehicle = new Truck(eVehicleType.Truck, i_plateNumber);
break;
default:
break;
}
return(newVehicle);
}
// Get number of wheels for the vehicle by the type
private int NumOfWheels(eVehicleType i_VehicleType)
{
int numOfWheels;
switch (i_VehicleType)
{
case eVehicleType.MotoricBike:
numOfWheels = 2;
break;
case eVehicleType.ElecticBike:
numOfWheels = 2;
break;
case eVehicleType.MotoricCar:
numOfWheels = 4;
break;
case eVehicleType.ElectricCar:
numOfWheels = 4;
break;
case eVehicleType.Truck:
numOfWheels = 16;
break;
default:
numOfWheels = (int)ChooseNumOf("number of wheels (int)");
break;
}
return(numOfWheels);
}
public static Vehicle CreateNewVehicle(eVehicleType i_VehicleType, string i_LicenseNumber, string i_OwnerName, string i_OwnerPhoneNumber, string i_ModelName)
{
Vehicle newVehicle;
switch (i_VehicleType)
{
case eVehicleType.FuelBasedMotorcycle:
newVehicle = new FuelBasedMotorcycle(i_LicenseNumber, i_OwnerName, i_OwnerPhoneNumber, i_ModelName);
break;
case eVehicleType.FuelBasedCar:
newVehicle = new FuelBasedCar(i_LicenseNumber, i_OwnerName, i_OwnerPhoneNumber, i_ModelName);
break;
case eVehicleType.ElectricMotorcycle:
newVehicle = new ElectricMotorcycle(i_LicenseNumber, i_OwnerName, i_OwnerPhoneNumber, i_ModelName);
break;
case eVehicleType.ElectricCar:
newVehicle = new ElectricCar(i_LicenseNumber, i_OwnerName, i_OwnerPhoneNumber, i_ModelName);
break;
default:
newVehicle = new FuelBasedTruck(i_LicenseNumber, i_OwnerName, i_OwnerPhoneNumber, i_ModelName);
break;
}
return(newVehicle);
}
// Get maximum air pressure in wheel by vehicle type.
private float MaxPossiblePressure(eVehicleType i_VehicleType)
{
float maxAirPressureInWheel;
switch (i_VehicleType)
{
case eVehicleType.MotoricBike:
maxAirPressureInWheel = 31;
break;
case eVehicleType.ElecticBike:
maxAirPressureInWheel = 31F;
break;
case eVehicleType.MotoricCar:
maxAirPressureInWheel = 30F;
break;
case eVehicleType.ElectricCar:
maxAirPressureInWheel = 30F;
break;
case eVehicleType.Truck:
maxAirPressureInWheel = 28F;
break;
default:
maxAirPressureInWheel = ChooseNumOf("maximum air pressure in wheel (float)");
break;
}
return(maxAirPressureInWheel);
}
// we first start the vehicle production, then by the type of the car we will update the next data then create the vehicle
public void VehicleInProduction(eVehicleType i_VehicleType, string i_ModelName, string i_LicenseNumber, float i_EnergyLeft)
{
vehicleType = i_VehicleType;
modelName = i_ModelName;
licenseNumber = i_LicenseNumber;
energyLeft = i_EnergyLeft;
}
// Helper to get energy type by vehicle type.
private eEnergyType getEnergyInput(eVehicleType i_VehicleType)
{
eEnergyType newEnergyType;
switch (i_VehicleType)
{
case eVehicleType.MotoricBike:
newEnergyType = eEnergyType.Octan95;
break;
case eVehicleType.ElecticBike:
newEnergyType = eEnergyType.Electricity;
break;
case eVehicleType.MotoricCar:
newEnergyType = eEnergyType.Octan98;
break;
case eVehicleType.ElectricCar:
newEnergyType = eEnergyType.Electricity;
break;
case eVehicleType.Truck:
newEnergyType = eEnergyType.Soler;
break;
default:
newEnergyType = eEnergyType.DeFault;
break;
}
return(newEnergyType);
}
private Engine createEngine(eVehicleType i_VehicleType)
{
Engine engine = null;
switch (i_VehicleType)
{
case eVehicleType.ElectricCar:
engine = new ElectricEngine(k_ElectricCarMaxHours);
break;
case eVehicleType.ElectricMotorcycle:
engine = new ElectricEngine(k_ElectricMotorcycleMaxHours);
break;
case eVehicleType.FuelBasedCar:
engine = new FuelEngine(k_CarFuelType, k_CarMaxFuel);
break;
case eVehicleType.FuelBasedMotorcycle:
engine = new FuelEngine(k_MotorCycleFuelType, k_MotorcycleMaxFuel);
break;
case eVehicleType.FuelBasedTruck:
engine = new FuelEngine(k_TruckFuelType, k_TruckMaxFuel);
break;
}
return(engine);
}
public static Vehicle CreateVehicle(string i_VehicleTypeString, List <string> i_VehicleParametersStrings)
{
Vehicle vehicle;
eVehicleType vehicleType = CheckVehicleType(i_VehicleTypeString);
switch (vehicleType)
{
case eVehicleType.Bike:
vehicle = createBike(Engine.eEngineType.FuelEngine, i_VehicleParametersStrings, eVehicleType.Bike);
break;
case eVehicleType.ElectricBike:
vehicle = createBike(Engine.eEngineType.ElectricEngine, i_VehicleParametersStrings, eVehicleType.ElectricBike);
break;
case eVehicleType.Car:
vehicle = createCar(Engine.eEngineType.FuelEngine, i_VehicleParametersStrings, eVehicleType.Car);
break;
case eVehicleType.ElectricCar:
vehicle = createCar(Engine.eEngineType.ElectricEngine, i_VehicleParametersStrings, eVehicleType.ElectricCar);
break;
case eVehicleType.Truck:
vehicle = createTruck(i_VehicleParametersStrings, eVehicleType.Truck);
break;
default:
throw new ArgumentOutOfRangeException();
}
setCurrentEnergyQuantity(vehicle);
return(vehicle);
}
public List <string> GetExtendedParametersList(eVehicleType i_VehicleType)
{
//// Basic user display parameters + specific parameters for each vehicle
List <string> parameterList = getBasicParametersList(i_VehicleType);
switch (i_VehicleType)
{
case eVehicleType.ElectricCar:
case eVehicleType.FuelBasedCar:
parameterList.Add("Color");
parameterList.Add("Number Of Doors");
break;
case eVehicleType.ElectricMotorcycle:
case eVehicleType.FuelBasedMotorcycle:
parameterList.Add("License Type");
parameterList.Add("Engine Volume");
break;
case eVehicleType.FuelBasedTruck:
parameterList.Add("if it Contains Dangerous Materials");
parameterList.Add("Volume of Cargo");
break;
}
return(parameterList);
}
internal static Vehicle createVehicle(eVehicleType i_VehicleType, string i_LicenseNumber)
{
Vehicle newVehicle = null;
switch (i_VehicleType)
{
case eVehicleType.FuelMotorcycle:
newVehicle = new FuelMotorcycle(i_LicenseNumber);
break;
case eVehicleType.ElectricMotorcycle:
newVehicle = new ElectricMotorcycle(i_LicenseNumber);
break;
case eVehicleType.FuelCar:
newVehicle = new FuelCar(i_LicenseNumber);
break;
case eVehicleType.ElectricCar:
newVehicle = new ElectricCar(i_LicenseNumber);
break;
case eVehicleType.FuelTruck:
newVehicle = new FuelTruck(i_LicenseNumber);
break;
}
return(newVehicle);
}
// Constructors:
public static Vehicle CreateVehicle(string i_LicenseNumber, string i_Model, eVehicleType i_VehicleType)
{
Engine engineOfVehicle;
Vehicle vehicleToCreate = null;
switch (i_VehicleType)
{
case eVehicleType.ElectricBike:
engineOfVehicle = createEngine(Engine.eEngineType.Electric, ElectricEngine.k_BikeBatteryTime);
vehicleToCreate = new Bike(i_Model, i_LicenseNumber, engineOfVehicle);
break;
case eVehicleType.Bike:
engineOfVehicle = createEngine(Engine.eEngineType.Gas, GasEngine.k_BikeTank, GasEngine.eGasType.Octan95);
vehicleToCreate = new Bike(i_Model, i_LicenseNumber, engineOfVehicle);
break;
case eVehicleType.ElectricCar:
engineOfVehicle = createEngine(Engine.eEngineType.Electric, ElectricEngine.k_CarBatteryTime);
vehicleToCreate = new Car(i_Model, i_LicenseNumber, engineOfVehicle);
break;
case eVehicleType.Car:
engineOfVehicle = createEngine(Engine.eEngineType.Gas, GasEngine.k_CarTank, GasEngine.eGasType.Octan96);
vehicleToCreate = new Car(i_Model, i_LicenseNumber, engineOfVehicle);
break;
case eVehicleType.Truck:
engineOfVehicle = createEngine(Engine.eEngineType.Gas, GasEngine.k_TruckTank, GasEngine.eGasType.Soler);
vehicleToCreate = new Truck(i_Model, i_LicenseNumber, engineOfVehicle);
break;
}
return(vehicleToCreate);
}
internal static Vehicle CreateVehicle(eVehicleType i_VehicleType, bool i_IsElectric)
{
Vehicle retVehicle = null;
switch (i_VehicleType)
{
case eVehicleType.Car:
if (i_IsElectric)
{
retVehicle = new ElectricCar();
}
else
{
retVehicle = new FuelCar();
}
break;
case eVehicleType.MotorCycle:
if (i_IsElectric)
{
retVehicle = new ElectricMotorCycle();
}
else
{
retVehicle = new FuelMotorCycle();
}
break;
case eVehicleType.Truck:
retVehicle = new FuelTruck();
break;
}
return(retVehicle);
}
public static string StringFromType(eVehicleType i_VehicleType)
{
string result;
switch (i_VehicleType)
{
case eVehicleType.FuelCar:
result = "Fuel Car";
break;
case eVehicleType.ElectricCar:
result = "Electric Car";
break;
case eVehicleType.FuelMotorcycle:
result = "Fuel Motorcycle";
break;
case eVehicleType.ElectricMotorcycle:
result = "Electric Motorcycle";
break;
case eVehicleType.FuelTruck:
result = "Fuel Truck";
break;
default:
throw new ArgumentException("Unknown Vehicle Type");
}
return(result);
}
private static Dictionary <string, string> expendVehicleParameter(eVehicleType i_VehicleType, Dictionary <string, string> i_Parameters)
{
Dictionary <string, string> aditionalInfo = DictionaryAddapter.AditionalInfo(i_VehicleType);
bool validationFlag = !true;
while (!validationFlag)
{
foreach (KeyValuePair <string, string> info in aditionalInfo)
{
System.Console.WriteLine(info.Key.ToString() + "?");
i_Parameters[info.Key] = System.Console.ReadLine();
}
try
{
validationFlag = Validation.SpecValidation(i_VehicleType, i_Parameters);
}
catch (Exception e)
{
validationFlag = !true;
System.Console.WriteLine(e.Message);
}
}
return(i_Parameters);
}
public Vehicle(
eVehicleType i_VehicleType,
string i_ModelName,
string i_ID,
Engine i_Engine,
List<Wheel> i_Wheels,
List<Component> i_Components)
{
r_VehicleType = i_VehicleType;
r_ModelName = i_ModelName;
r_ID = i_ID;
r_Engine = i_Engine;
r_Wheels = i_Wheels;
r_Components = i_Components;
}
public bool AddVehicleToGarage(eEnergyType i_EnergyType, eVehicleType i_VehicleType, string i_Model, string i_LicenseNumber, float i_CurrentEnergy
, string i_ManufacturerWheelName, float i_CurrentAirPressure, string i_OwnerName, string i_OwnerPhone)
{
bool isAddedSuccessfully = false;
if (!isOwnerNameCorrectFormat(i_OwnerName))
{
throw new FormatException(string.Format("Owner name format should be : {0}", k_OwnerNameFormat));
}
Vehicle vehicle = s_Factory.CreateNewVehicle(i_EnergyType, i_VehicleType, i_Model, i_LicenseNumber, i_CurrentEnergy, i_ManufacturerWheelName, i_CurrentAirPressure);
VehicleGarageInformation vehicleGarageInfo = new VehicleGarageInformation(i_OwnerName, i_OwnerPhone.Trim());
r_ListOfVehicles.Add(vehicle.LicenseNumber, vehicle);
r_ListOfVehiclesGarageInfo.Add(vehicle.LicenseNumber, vehicleGarageInfo);
isAddedSuccessfully = true;
return isAddedSuccessfully;
}
private void AddVehicleDetails(string i_LicenseNumber, out string o_Message, out string o_OwnerName, out string o_OwnerPhone,
out string o_ModelName, out eVehicleType o_VehicleType, out eEnergyType o_EnergyType, out float O_CurrentEnergy,
out string o_WheelManufacturer, out float w_WheelAirPressure)
{
o_Message = string.Format("{0} Added Successfully!", i_LicenseNumber);
o_OwnerName = this.printMessageAndGetStringInformationFromUser(string.Format("Owner name? The format: {0}", Garage.k_OwnerNameFormat));
o_OwnerPhone = this.printMessageAndGetStringInformationFromUser(string.Format("Owner phone?"));
o_ModelName = this.printMessageAndGetStringInformationFromUser("Model name?");
o_VehicleType = (eVehicleType)this.getEnumerationInformationFromUser("Vehicle Type?", typeof(eVehicleType));
o_EnergyType = (eEnergyType)this.getEnumerationInformationFromUser("Energy type?", typeof(eEnergyType));
O_CurrentEnergy = getCurrentEnergyFromUser(o_EnergyType, o_VehicleType);
o_WheelManufacturer = this.printMessageAndGetStringInformationFromUser("Wheels manufacturer name?");
w_WheelAirPressure = getAirPressureFromUser(o_EnergyType, o_VehicleType);
}
private float getCurrentEnergyFromUser(eEnergyType i_EnergyType, eVehicleType i_VehicleType)
{
float maxEnergy = r_Garage.GetMaximumAmountVehicleEnergySource(i_EnergyType, i_VehicleType);
float currentEnergy = this.printMessageAndGetFloatFormatFromUser(string.Format("Current {0} Energy? Maximum is {1}", i_EnergyType,
maxEnergy));
while (currentEnergy > maxEnergy)
{
Console.WriteLine("Your input energy is larger than {0}. Please try again.", maxEnergy);
currentEnergy = this.printMessageAndGetFloatFormatFromUser(string.Format("Current {0} Energy? Maximum is {1}", i_EnergyType,
maxEnergy));
}
return currentEnergy;
}
public float GetMaximumAmountVehicleEnergySource(eEnergyType i_EnergySource, eVehicleType i_VehicleType)
{
return VehicleFactory.GetMaximumAmountVehicleEnergySource(i_EnergySource, i_VehicleType);
}
public static string StringFromType(eVehicleType i_VehicleType)
{
string result;
switch (i_VehicleType)
{
case eVehicleType.FuelCar:
result = "Fuel Car";
break;
case eVehicleType.ElectricCar:
result = "Electric Car";
break;
case eVehicleType.FuelMotorcycle:
result = "Fuel Motorcycle";
break;
case eVehicleType.ElectricMotorcycle:
result = "Electric Motorcycle";
break;
case eVehicleType.FuelTruck:
result = "Fuel Truck";
break;
default:
throw new ArgumentException("Unknown Vehicle Type");
}
return result;
}
public void AddSpecificVehicle(Dictionary<string, object> i_Params, eVehicleType i_vehicleType, string i_LicenseNum)
{
Vehicle vehicle = r_ListOfVehicles[i_LicenseNum];
s_Factory.CreateSpecificVehicle(i_Params, i_vehicleType, vehicle);
}
private void initVehicleBuilder(eVehicleType i_VehicleType)
{
switch (i_VehicleType)
{
case eVehicleType.FuelCar:
m_VehicleBuilder = new FuelCarBuilder();
break;
case eVehicleType.ElectricCar:
m_VehicleBuilder = new ElectricCarBuilder();
break;
case eVehicleType.FuelMotorcycle:
m_VehicleBuilder = new FuelMotorcycleBuilder();
break;
case eVehicleType.ElectricMotorcycle:
m_VehicleBuilder = new ElectricMotorcycleBuilder();
break;
case eVehicleType.FuelTruck:
m_VehicleBuilder = new TruckBuilder();
break;
}
}
private void addSpecificVehicleDetails(eVehicleType i_VehicleType, string i_LicenseNum)
{
Dictionary<string, object> vehicleParams = new Dictionary<string, object>();
foreach (SpecialVehicleParam param in r_Garage.SpecialProperties(i_LicenseNum))
{
switch (Type.GetTypeCode(param.ParamType))
{
case TypeCode.Int32:
int intParameter = printInteger(param);
vehicleParams.Add(param.ParamKey, intParameter);
break;
case TypeCode.Single:
float floatParameter = this.printMessageAndGetFloatFormatFromUser(string.Format("{0}?", param.ParamName));
vehicleParams.Add(param.ParamKey, floatParameter);
break;
}
}
r_Garage.AddSpecificVehicle(vehicleParams, i_VehicleType, i_LicenseNum);
}
private float getAirPressureFromUser(eEnergyType i_EnergyType, eVehicleType i_VehicleType)
{
float maxAirPressure = r_Garage.GetMaximumAmountVehicleAirPressure(i_EnergyType, i_VehicleType);
float currentAirPressure = this.printMessageAndGetFloatFormatFromUser(string.Format("Wheels current air pressure? Maximum is {0}",
maxAirPressure));
while (currentAirPressure > maxAirPressure)
{
Console.WriteLine("Your input energy is larger than {0}. Please try again.", maxAirPressure);
currentAirPressure = this.printMessageAndGetFloatFormatFromUser(string.Format("Wheels current air pressure? Maximum is {0}",
maxAirPressure));
}
return currentAirPressure;
}
