public GasCar(float i_MaxFuelCapacity, FuelTank.eFuelType i_FuelType, Car.eCarColorOptions i_CarColor,
Car.eNumberOfDoors i_NumberOfDoors, string i_VehicleNumber, string i_VehicleModel, int i_NumberOfWheels, string i_WheelManufacturerName, float i_MaxAllowedAirPressure)
: base(i_CarColor, i_NumberOfDoors, i_VehicleNumber, i_VehicleModel, i_NumberOfWheels, i_WheelManufacturerName, i_MaxAllowedAirPressure)
{
this.m_FuelTank = new FuelTank(i_MaxFuelCapacity, i_FuelType);
this.m_EngineType = Vehicle.eVehicleEngineType.GasEngine;
}
private static Car createACar(string i_Module,
string i_VehicleLicense, float i_CurrentPowerInPowerSource, List <string> i_Wheels,
Dictionary <string, string> i_VehicleDetails, e_TypeOfPowerSource i_PowerSource)
{
PowerSource powerSource;
if (i_PowerSource.Equals(e_TypeOfPowerSource.Battery))
{
powerSource = new Battery(2.5f, i_CurrentPowerInPowerSource);
}
else
{
powerSource = new FuelTank(42f, i_CurrentPowerInPowerSource, PowerSource.eFuel.Octan98);
}
string colorValue;
i_VehicleDetails.TryGetValue("color", out colorValue);
string numberOfDoorsValue;
i_VehicleDetails.TryGetValue("numberOfDoors", out numberOfDoorsValue);
Car.eColor color = (Car.eColor)(Enum.Parse(typeof(Car.eColor), colorValue));
Car.eNumberOfDoors numberOfDoors = (Car.eNumberOfDoors)(Enum.Parse(typeof(Car.eNumberOfDoors), numberOfDoorsValue));
List <Wheel> wheels = generateWheels(4, 30, i_Wheels[0], i_Wheels[1]);
return(new Car(i_Module, i_VehicleLicense, color, numberOfDoors, wheels, powerSource));
}
public ElectricCar(float i_MaxBatteryTime, Car.eCarColorOptions i_CarColor,
Car.eNumberOfDoors i_NumberOfDoors, string i_VehicleNumber, string i_VehicleModel, int i_NumberOfWheels, string i_WheelManufacturerName, float i_MaxAllowedAirPressure)
: base(i_CarColor, i_NumberOfDoors, i_VehicleNumber, i_VehicleModel, i_NumberOfWheels, i_WheelManufacturerName, i_MaxAllowedAirPressure)
{
this.m_Battery = new VehicleBattery(i_MaxBatteryTime);
this.m_EngineType = eVehicleEngineType.ElectricEngine;
}
private static Vehicle createCar(Engine.eEngineType i_Engine, List <string> i_VehicleParametersStrings, eVehicleType i_VehicleType)
{
string modelName;
string licenseNumber;
float energyPercentageLeft;
string tireManufactureName;
float tireCurrentAirPressure;
Car.eCarColors carColor = (Car.eCarColors)Enum.Parse(typeof(Car.eCarColors), i_VehicleParametersStrings[(int)eExtraParametersInputOrder.CarColor]);
Car.eNumberOfDoors numberOfDoors = (Car.eNumberOfDoors)Enum.Parse(typeof(Car.eNumberOfDoors), i_VehicleParametersStrings[(int)eExtraParametersInputOrder.CarNumOfDoors]);
getVehicleParameters(
i_VehicleParametersStrings,
out modelName,
out licenseNumber,
out energyPercentageLeft,
out tireManufactureName,
out tireCurrentAirPressure);
Engine engine = i_Engine == Engine.eEngineType.FuelEngine
? (Engine)createFuelEngine(Car.k_FuelType, Car.k_MaxTankCapacity)
: createElectricEngine(Car.k_MaxBatteryTime);
Car car = new Car(i_VehicleType, modelName, licenseNumber, new Tire[Car.k_NumberOfTires], engine, energyPercentageLeft, tireManufactureName, tireCurrentAirPressure, carColor, numberOfDoors);
return(car);
}
public static Vehicle GenerateNewVehicle(eVehicleToGenerate i_VehicleToGenerate, List <string> i_NewVehicleData)
{
Vehicle newVehicle = null;
Motorcycle.eMotorcycleLicenseType motorcycleLicenseType = 0;
Car.eCarColorOptions carColor = 0;
Car.eNumberOfDoors carNumberOfDoors = 0;
if (i_VehicleToGenerate == eVehicleToGenerate.ElectricCar || i_VehicleToGenerate == eVehicleToGenerate.GasCar)
{
carColor = (Car.eCarColorOptions)System.Enum.Parse(typeof(GasCar.eCarColorOptions), i_NewVehicleData[k_PlaceHolderForCarColor]);
carNumberOfDoors = (Car.eNumberOfDoors)System.Enum.Parse(typeof(Car.eNumberOfDoors), i_NewVehicleData[k_PlaceHolderForCarDoorsNumber]);
}
if (i_VehicleToGenerate == eVehicleToGenerate.ElectricMotorcycle || i_VehicleToGenerate == eVehicleToGenerate.GasMotorcycle)
{
motorcycleLicenseType = (Motorcycle.eMotorcycleLicenseType)System.Enum.Parse(typeof(Motorcycle.eMotorcycleLicenseType), i_NewVehicleData[k_PlaceHolderForMotorcycleLicenseType]);
}
switch (i_VehicleToGenerate)
{
case eVehicleToGenerate.GasTruck:
Truck.eTruckCargo containsDangerousCargo = (Truck.eTruckCargo)System.Enum.Parse(typeof(Truck.eTruckCargo), i_NewVehicleData[k_PlaceHolderForTruckContainsDangerousCargo]);
newVehicle = new GasTruck(k_GasTruckMaxFuelTankCapacity, containsDangerousCargo, k_GasTruckFuelType, float.Parse(i_NewVehicleData[k_PlaceHolderForTruckVolumeCapacity]),
float.Parse(i_NewVehicleData[k_PlaceHolderForTruckMaxAllowedCargoWeight]), i_NewVehicleData[k_PlaceHolderForVehicleNumber], i_NewVehicleData[k_PlaceHolderForVehicleModel],
k_TruckNumberOfWheels, i_NewVehicleData[k_PlaceHolderForWheelManufacturer], k_TruckMaxAirPressure);
break;
case eVehicleToGenerate.GasMotorcycle:
newVehicle = new GasMotorcycle(k_GasMotorcycleMaxFuelTankCapacity, k_GasMotorcycleFuelType, motorcycleLicenseType,
int.Parse(i_NewVehicleData[k_PlaceHolderForMotorcycleEngineCapacity]), i_NewVehicleData[k_PlaceHolderForVehicleNumber],
i_NewVehicleData[k_PlaceHolderForVehicleModel], k_MotorcycleNumberOfWheels, i_NewVehicleData[k_PlaceHolderForWheelManufacturer],
k_MotorcycleMaxAirPressure);
break;
case eVehicleToGenerate.ElectricMotorcycle:
newVehicle = new ElectricMotorcycle(k_ElectricMotorcycleMaxBatteryTimeInHours, motorcycleLicenseType, int.Parse(i_NewVehicleData[k_PlaceHolderForMotorcycleEngineCapacity]),
i_NewVehicleData[k_PlaceHolderForVehicleNumber], i_NewVehicleData[k_PlaceHolderForVehicleModel], k_MotorcycleNumberOfWheels, i_NewVehicleData[k_PlaceHolderForWheelManufacturer],
k_MotorcycleMaxAirPressure);
break;
case eVehicleToGenerate.GasCar:
newVehicle = new GasCar(k_GasCarMaxFuelTankCapacity, k_GasCarFuelType, carColor, carNumberOfDoors, i_NewVehicleData[k_PlaceHolderForVehicleNumber],
i_NewVehicleData[k_PlaceHolderForVehicleModel], k_CarNumberOfWheels,
i_NewVehicleData[k_PlaceHolderForWheelManufacturer], k_CarMaxAirPressure);
break;
case eVehicleToGenerate.ElectricCar:
newVehicle = new ElectricCar(k_ElectricCarMaxBatteryTimeInHours, carColor, carNumberOfDoors, i_NewVehicleData[k_PlaceHolderForVehicleNumber],
i_NewVehicleData[k_PlaceHolderForVehicleModel], k_CarNumberOfWheels,
i_NewVehicleData[k_PlaceHolderForWheelManufacturer], k_CarMaxAirPressure);
break;
default:
break;
}
return(newVehicle);
}
private void insertQuantityOfDoorsForCar(Car i_NewCar)
{
int userChoice;
Car.eNumberOfDoors amountOfDoorsOptions = new Car.eNumberOfDoors();
string PartOfOptionsHeaderMsg = string.Format("amount of doors");
userChoice = m_InputUI.MakeArrayOfStringFromEnum(PartOfOptionsHeaderMsg, amountOfDoorsOptions);
i_NewCar.NumberOfDoors = (Car.eNumberOfDoors)userChoice;
}
private static Car getCar(Dictionary <string, ArgumentConsumer> i_CarArguments, Engine i_Engine)
{
Car.eCarColor color = EnumUtils.GetStringAsEnum <Car.eCarColor>(i_CarArguments[Keys.Color].ValueFromUser);
Car.eNumberOfDoors numberOfDoors = EnumUtils.GetStringAsEnum <Car.eNumberOfDoors>(i_CarArguments[Keys.NumberOfDoors].ValueFromUser);
string licenseNumber = i_CarArguments[Keys.LicenseNumber].ValueFromUser;
Collection <Tire> tires = makeTiresCollection(i_CarArguments, Car.GetNumberOfTires);
Car newCar = new Car(licenseNumber, tires, i_Engine, color, numberOfDoors);
return(newCar);
}
private static void getInputParamtersForCar(
Dictionary <string, object> i_VehicleCharaterstic,
out Car.eNumberOfDoors o_NumberOfDoors,
out Car.ePossibleCarColors o_CarColor,
out string o_ModelName,
out string o_LicenceNumber,
out float o_PercentOfEnergyLeft)
{
o_NumberOfDoors = getNumberOfDoorsValueFromDict(i_VehicleCharaterstic, k_NumberOfDoorsInCarKey);
o_CarColor = getCarColorValueFromDict(i_VehicleCharaterstic, k_CarColorKey);
getVehicleParameters(i_VehicleCharaterstic, out o_ModelName, out o_LicenceNumber, out o_PercentOfEnergyLeft);
}
private static Car.eNumberOfDoors getNumberOfDoorsValueFromDict(Dictionary <string, object> i_VehicleCharaterstic, string i_Key)
{
bool didGetWork;
object numberOfDoorsInObjectForm;
didGetWork = i_VehicleCharaterstic.TryGetValue(i_Key, out numberOfDoorsInObjectForm);
if (!didGetWork)
{
throw new FormatException(string.Format("Wrong Dictionary Format, no {0} field", i_Key));
}
Car.eNumberOfDoors numberOfDoors = (Car.eNumberOfDoors)numberOfDoorsInObjectForm;
return(numberOfDoors);
}
public DetailsOfElectricCar(
string i_OwnerName,
string i_OwnerPhone,
string i_Model,
string i_PlateNumber,
string i_ManufacturerName,
Car.eCarColor i_CarColor,
Car.eNumberOfDoors i_NumberOFDoors)
: base(
i_OwnerName,
i_OwnerPhone,
i_Model,
i_PlateNumber,
new ElectricBattery(k_MaxChargeTime, k_MaxChargeTime),
i_ManufacturerName,
k_VehicleType,
i_CarColor,
i_NumberOFDoors)
{
}
public DetailsOfFuelCar(
string i_OwnerName,
string i_OwnerPhone,
string i_Model,
string i_PlateNumber,
string i_ManufacturerName,
Car.eCarColor i_CarColor,
Car.eNumberOfDoors i_NumberOFDoors)
: base(
i_OwnerName,
i_OwnerPhone,
i_Model,
i_PlateNumber,
new FuelTank(k_FuelTankCapacity, k_FuelTankCapacity, k_FuelType),
i_ManufacturerName,
k_VehicleType,
i_CarColor,
i_NumberOFDoors)
{
}
public DetailsOfCar(
string i_OwnerName,
string i_OwnerPhone,
string i_Model,
string i_PlateNumber,
Energy i_EnergyType,
string i_ManufacturerName,
Vehicle.eVehicleType i_VehicleType,
Car.eCarColor i_CarColor,
Car.eNumberOfDoors i_NumberOFDoors)
: base(
i_OwnerName,
i_OwnerPhone,
i_Model,
i_PlateNumber,
i_EnergyType,
k_CarWheelNumber,
i_ManufacturerName,
k_CarWheelMaxPressure,
i_VehicleType)
{
m_CarColor = i_CarColor;
m_NumberOfDoors = i_NumberOFDoors;
}
private void addNewVehicleToGarage()
{
string licensePlate = m_UserInputs.getLicensePlate();
float maxAirPressure = 0;
float maxBatteryTime = 0;
FuelVehicle.eFuelType fuelType;
Vehicle.eTireAmount tireAmount;
if (m_Garage.m_AllVehiclesInTheGarage.ContainsKey(licensePlate))
{
m_Garage.changeVehicleStatus(licensePlate, Client.eVehicleStatus.Repairing);
m_UserInputs.vehicleAlreadyInGarageMessage();
}
else
{
string vehicleModel = m_UserInputs.getValidString("Please enter vehicle model name:");
string ownerName = m_UserInputs.getValidString("Please enter Owner Name");
string ownerPhone = m_UserInputs.getOwnerPhone();
float percentOfRemainingEnergy = 0;
Client newClient = null;
CreateVehicle.eVehicleType vehicleType = (CreateVehicle.eVehicleType)m_UserInputs.getVehicleType();
string tiresManufacturer = m_UserInputs.getValidString("Please enter the tires manufacturer:");
float currentTireAirPressure;
List <Tire> listOfTires;
Vehicle vehicleForProperty;
if (vehicleType == CreateVehicle.eVehicleType.ElectricCar || vehicleType == CreateVehicle.eVehicleType.FuelCar)
{
maxAirPressure = (float)Tire.eMaxAirPressure.Car;
currentTireAirPressure = m_UserInputs.getTiresPressure(maxAirPressure);
tireAmount = Vehicle.eTireAmount.Car;
listOfTires = CreateVehicle.createListOfTires(tireAmount, tiresManufacturer, currentTireAirPressure, maxAirPressure);
Car.eColor carColor = m_UserInputs.getCarColor();
Car.eNumberOfDoors numberOfDoors = m_UserInputs.getNumberOfDoors();
Car car = CreateVehicle.createCar(carColor, numberOfDoors);
if (vehicleType == CreateVehicle.eVehicleType.ElectricCar)
{
float remainingBatteryTime = m_UserInputs.getRemainingBatteryTime(ElectricCar.k_MaxBatteryTime);
percentOfRemainingEnergy = Vehicle.getPercentOfEnergy(remainingBatteryTime, ElectricCar.k_MaxBatteryTime);
ElectricCar electricCar = CreateVehicle.createElectricCar(car, remainingBatteryTime, maxBatteryTime, vehicleModel, licensePlate, percentOfRemainingEnergy, listOfTires);
newClient = CreateVehicle.createClient(ownerName, ownerPhone, Client.eVehicleStatus.Repairing, electricCar);
}
else
{
fuelType = FuelVehicle.eFuelType.Octan98;
float currentAmountOfFuel = m_UserInputs.getCurrentAmountOfFuel(FuelCar.k_MaxAmountOfFuel);
percentOfRemainingEnergy = Vehicle.getPercentOfEnergy(currentAmountOfFuel, FuelCar.k_MaxAmountOfFuel);
FuelCar fuelCar = CreateVehicle.createFuelCar(car, fuelType, currentAmountOfFuel, vehicleModel, licensePlate, percentOfRemainingEnergy, listOfTires);
newClient = CreateVehicle.createClient(ownerName, ownerPhone, Client.eVehicleStatus.Repairing, fuelCar);
}
vehicleForProperty = newClient.m_Vehicle;
Car.setProperties(vehicleForProperty, carColor, numberOfDoors);
}
else if (vehicleType == CreateVehicle.eVehicleType.ElectricMotorcycle || vehicleType == CreateVehicle.eVehicleType.FuelMotorcycle)
{
maxAirPressure = (float)Tire.eMaxAirPressure.Motorcycle;
currentTireAirPressure = m_UserInputs.getTiresPressure(maxAirPressure);
tireAmount = Vehicle.eTireAmount.Motorcycle;
listOfTires = CreateVehicle.createListOfTires(tireAmount, tiresManufacturer, currentTireAirPressure, maxAirPressure);
Motorcycle.eTypeOfLicense typeOfLicense = m_UserInputs.getTypeOfLicense();
int engineCapacity = m_UserInputs.getValidInt("Please enter engine capacity:", 0, int.MaxValue);
Motorcycle motorCycle = CreateVehicle.createMotorcycle(typeOfLicense, engineCapacity);
if (vehicleType == CreateVehicle.eVehicleType.ElectricMotorcycle)
{
float remainingBatteryTime = m_UserInputs.getRemainingBatteryTime(ElectricMotorcycle.k_MaxBatteryTime);
percentOfRemainingEnergy = Vehicle.getPercentOfEnergy(remainingBatteryTime, ElectricMotorcycle.k_MaxBatteryTime);
ElectricMotorcycle electricMotorcycle = CreateVehicle.createElectricMotorcycle(motorCycle, remainingBatteryTime, vehicleModel, licensePlate, percentOfRemainingEnergy, listOfTires);
newClient = CreateVehicle.createClient(ownerName, ownerPhone, Client.eVehicleStatus.Repairing, electricMotorcycle);
}
else
{
fuelType = FuelVehicle.eFuelType.Octan95;
float currentAmountOfFuel = m_UserInputs.getCurrentAmountOfFuel(FuelMotorcycle.k_MaxAmountOfFuel);
percentOfRemainingEnergy = Vehicle.getPercentOfEnergy(currentAmountOfFuel, FuelMotorcycle.k_MaxAmountOfFuel);
FuelMotorcycle fuelMotorcycle = CreateVehicle.createFuelMotorcycle(motorCycle, fuelType, currentAmountOfFuel, vehicleModel, licensePlate, percentOfRemainingEnergy, listOfTires);
newClient = CreateVehicle.createClient(ownerName, ownerPhone, Client.eVehicleStatus.Repairing, fuelMotorcycle);
}
vehicleForProperty = newClient.m_Vehicle;
Motorcycle.setProperties(vehicleForProperty, typeOfLicense, engineCapacity);
}
else if (vehicleType == CreateVehicle.eVehicleType.Truck)
{
maxAirPressure = (float)Tire.eMaxAirPressure.Truck;
currentTireAirPressure = m_UserInputs.getTiresPressure(maxAirPressure);
tireAmount = Vehicle.eTireAmount.Truck;
listOfTires = CreateVehicle.createListOfTires(tireAmount, tiresManufacturer, currentTireAirPressure, maxAirPressure);
fuelType = FuelVehicle.eFuelType.Soler;
bool carrierDangerousMaterials = m_UserInputs.getIfCarrierDangerousMaterials();
float maximumCarryingWeight = m_UserInputs.getValidFloat("Please enter maximum carry weight:", 0, int.MaxValue);
Truck truck = CreateVehicle.createTruck(carrierDangerousMaterials, maximumCarryingWeight);
float currentAmountOfFuel = m_UserInputs.getCurrentAmountOfFuel(FuelTruck.k_MaxAmountOfFuel);
percentOfRemainingEnergy = Vehicle.getPercentOfEnergy(currentAmountOfFuel, FuelTruck.k_MaxAmountOfFuel);
FuelTruck fuelTruck = CreateVehicle.createFuelTruck(truck, fuelType, currentAmountOfFuel, vehicleModel, licensePlate, percentOfRemainingEnergy, listOfTires);
newClient = CreateVehicle.createClient(ownerName, ownerPhone, Client.eVehicleStatus.Repairing, fuelTruck);
vehicleForProperty = newClient.m_Vehicle;
Truck.setProperties(vehicleForProperty, carrierDangerousMaterials, maximumCarryingWeight);
}
m_Garage.addVehicle(newClient);
m_UserInputs.suceededToAddMessage();
}
System.Console.ReadLine();
}
private void validateAndInsertToParametersDict(Dictionary <string, object> parametersForFactory, Dictionary <string, string> parametersFromUser, string key)
{
if (key.Equals(VeichleFactory.k_CarColorKey))
{
try
{
Car.ePossibleCarColors newValueToEnterToDict = (Car.ePossibleCarColors)Enum.Parse(typeof(Car.ePossibleCarColors), parametersFromUser[key]);
parametersForFactory.Add(key, newValueToEnterToDict);
}
catch (OverflowException)
{
throw new FormatException("Wrong Car Color - possible values are Yellow, White, Black or Blue");
}
}
else if (key.Equals(VeichleFactory.k_CurrentEnergyLevelKey) ||
key.Equals(VeichleFactory.k_MaxCargoWeightForTruckKey) ||
key.Equals(VeichleFactory.k_PercentOfEnergyLeftKey))
{
float newValueToEnterToDict;
bool didParseWork = float.TryParse(parametersFromUser[key], out newValueToEnterToDict);
parametersForFactory.Add(key, newValueToEnterToDict);
if (!didParseWork)
{
throw new ArgumentException(string.Format("Wrong {0} Type! Must be a Decimal Number!", key));
}
}
else if (key.Equals(VeichleFactory.k_CurrentPressureInWheelsKey))
{
List <float> newValueToEnterToDict = new List <float>();
string[] parametersFromUserDivided = parametersFromUser[key].Split(k_SplitAccordingToThisDelimiter);
foreach (string airPressure in parametersFromUserDivided)
{
float tempAirPressurePlaceHolder;
bool didParseWork = float.TryParse(airPressure, out tempAirPressurePlaceHolder);
if (!didParseWork)
{
throw new ArgumentException(string.Format("Wrong {0} Type! Must be a Decimal Number!", key));
}
newValueToEnterToDict.Add(tempAirPressurePlaceHolder);
}
parametersForFactory.Add(key, newValueToEnterToDict);
}
else if (key.Equals(VeichleFactory.k_EngineVolumeKey))
{
int newValueToEnterToDict;
bool didParseWork = int.TryParse(parametersFromUser[key], out newValueToEnterToDict);
parametersForFactory.Add(key, newValueToEnterToDict);
if (!didParseWork)
{
throw new ArgumentException(string.Format("Wrong {0} Type! Must be an Integer Number!", key));
}
}
else if (key.Equals(VeichleFactory.k_HasDangerousCargoKey))
{
bool newValueToEnterToDict;
bool didParseWork = bool.TryParse(parametersFromUser[key], out newValueToEnterToDict);
parametersForFactory.Add(key, newValueToEnterToDict);
if (!didParseWork)
{
throw new ArgumentException(string.Format("Wrong {0} Type! Must be a true/false value", key));
}
}
else if (key.Equals(VeichleFactory.k_NumberOfDoorsInCarKey))
{
try
{
Car.eNumberOfDoors newValueToEnterToDict = (Car.eNumberOfDoors)Enum.Parse(typeof(Car.eNumberOfDoors), parametersFromUser[key]);
parametersForFactory.Add(key, newValueToEnterToDict);
}
catch (OverflowException)
{
throw new FormatException("Wrong Number Of Doors - possible values are 2 3 4 or 5");
}
}
else if (key.Equals(VeichleFactory.k_TypeOfLicenceKey))
{
try
{
Bike.eTypeOfLicence newValueToEnterToDict = (Bike.eTypeOfLicence)Enum.Parse(typeof(Bike.eTypeOfLicence), parametersFromUser[key]);
parametersForFactory.Add(key, newValueToEnterToDict);
}
catch (OverflowException)
{
throw new FormatException("Wrong Licence Type - possible values are A AB A2 or B1");
}
}
else if (key.Equals(VeichleFactory.k_WheelMakerKey))
{
List <string> newValueToEnterToDict = new List <string>();
string[] parametersFromUserDivided = parametersFromUser[key].Split(k_SplitAccordingToThisDelimiter);
newValueToEnterToDict.AddRange(parametersFromUserDivided);
parametersForFactory.Add(key, newValueToEnterToDict);
}
else
{
string newValueToEnterToDict = parametersFromUser[key];
parametersForFactory.Add(key, newValueToEnterToDict);
}
}
public Car.eNumberOfDoors getNumberOfDoors()
{
Car.eNumberOfDoors numberOfDoors = (Car.eNumberOfDoors)getValidInt(DOORS_AMOUNT, 1, 4);
return(numberOfDoors);
}
public static Car createCar(Car.eColor i_Color, Car.eNumberOfDoors i_NumberOfDoors)
{
Car newCar = new Car(i_Color, i_NumberOfDoors);
return(newCar);
}
public static Vehicle GasCarMaker(Owner i_Owner, string i_Model, string i_LicenceNumber, GasTank i_GasTank, Wheel[] i_Wheels, Car.eColor i_Color, Car.eNumberOfDoors i_NumberOfDoors)
{
return(new GasCar(i_Owner, i_Model, i_LicenceNumber, i_GasTank, i_Wheels, i_Color, i_NumberOfDoors));
}
public static Vehicle ElectronicCarMaker(Owner i_Owner, string i_Model, string i_LicenceNumber, ElectronicTank i_ElectronicTank, Wheel[] i_Wheels, Car.eColor i_Color, Car.eNumberOfDoors i_NumberOfDoors)
{
return(new ElectronicCar(i_Owner, i_Model, i_LicenceNumber, i_ElectronicTank, i_Wheels, i_Color, i_NumberOfDoors));
}
