private static List <object> readUniqueParametersList(Vehicle.eVehicleType i_vehicleType)
{
List <object> uniqueParametersList = new List <object>();
FieldInfo[] fields;
string message;
string vehicleTypeString = "Ex03.GarageLogic." + i_vehicleType + ",Ex03.GarageLogic";
Type vehicleType = Type.GetType(vehicleTypeString);
fields = vehicleType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
for (int i = 0; i < fields.Length; i++)
{
if (fields[i].FieldType.IsEnum)
{
uniqueParametersList.Add(readEnumType(fields[i].FieldType));
}
else if (fields[i].FieldType == typeof(bool))
{
message = string.Format("Enter {0} , Please answer by: y / n", fields[i].Name.Substring(2));
Console.WriteLine(message);
uniqueParametersList.Add(validateBooleanPresentor(Console.ReadLine()));
}
else
{
message = string.Format("Enter {0}", fields[i].Name.Substring(2));
Console.WriteLine(message);
uniqueParametersList.Add(Console.ReadLine());
}
}
return(uniqueParametersList);
}
public static Vehicle MakeVehicle(Vehicle.eVehicleType i_VehicleType, DetailsOfVehicle i_DetailsOfVehicle)
{
Vehicle newVehicle = null;
switch (i_VehicleType)
{
case Vehicle.eVehicleType.FuelCar:
newVehicle = new FuelCar(i_DetailsOfVehicle as DetailsOfFuelCar);
break;
case Vehicle.eVehicleType.ElectricCar:
newVehicle = new ElectricCar(i_DetailsOfVehicle as DetailsOfElectricCar);
break;
case Vehicle.eVehicleType.ElectricMotorcycle:
newVehicle = new ElectricMotorcycle(i_DetailsOfVehicle as DetailsOfElectricMotorcycle);
break;
case Vehicle.eVehicleType.FuelMotorcycle:
newVehicle = new FuelMotorcycle(i_DetailsOfVehicle as DetailsOfFuelMotorcycle);
break;
case Vehicle.eVehicleType.Truck:
newVehicle = new FuelTruck(i_DetailsOfVehicle as DetailsOfFuelTruck);
break;
}
return(newVehicle);
}
public static Car CreateNewCar(bool i_IsElectric)
{
int numberOfWheels = 4;
float maxWheelAirPressure = 30;
Vehicle.eEnergyType energyType = Vehicle.eEnergyType.Electric;
Nullable <Vehicle.eFuelType> fuelType = null;
if (!i_IsElectric)
{
fuelType = Vehicle.eFuelType.Octan98;
energyType = Vehicle.eEnergyType.Fuel;
}
float maxEnergyLevel = i_IsElectric ? 2.5F : 42F;
Vehicle.eVehicleType vehicleType = i_IsElectric ?
Vehicle.eVehicleType.ElectricCar
: Vehicle.eVehicleType.FuelCar;
return(new Car(energyType,
fuelType,
maxEnergyLevel,
maxWheelAirPressure,
numberOfWheels,
vehicleType));
}
public static Motorcycle CreateNewMotorcycle(bool i_IsElectric)
{
int numberOfWheels = 2;
float maxWheelAirPressure = 33;
Vehicle.eEnergyType energyType = Vehicle.eEnergyType.Electric;
Nullable <Vehicle.eFuelType> fuelType = null;
if (!i_IsElectric)
{
energyType = Vehicle.eEnergyType.Fuel;
fuelType = Vehicle.eFuelType.Octan95;
}
float tankSize = i_IsElectric ? 2.7F : 5.5F;
Vehicle.eVehicleType vehicleType = i_IsElectric ?
Vehicle.eVehicleType.ElectricMotorcycle
: Vehicle.eVehicleType.FuelMotorcycle;
return(new Motorcycle(energyType,
fuelType,
tankSize,
maxWheelAirPressure,
numberOfWheels,
vehicleType));
}
private Vehicle.eVehicleType getVehicleSelection(int i_Selection)
{
Console.Clear();
Vehicle.eVehicleType userChoice = Vehicle.eVehicleType.Truck;
switch (i_Selection)
{
case (int)Vehicle.eVehicleType.ElectricCar:
userChoice = Vehicle.eVehicleType.ElectricCar;
break;
case (int)Vehicle.eVehicleType.ElectricMotorcycle:
userChoice = Vehicle.eVehicleType.ElectricMotorcycle;
break;
case (int)Vehicle.eVehicleType.FuelCar:
userChoice = Vehicle.eVehicleType.FuelCar;
break;
case (int)Vehicle.eVehicleType.FuelMotorcycle:
userChoice = Vehicle.eVehicleType.FuelMotorcycle;
break;
}
return(userChoice);
}
private Wheel getWheelData(Vehicle.eVehicleType i_VehicleType)
{
Console.Write("Please enter your wheels manufactor name: ");
string manufactorName = getValidString("Manufactor name");
return(new Wheel(manufactorName));
}
private void insertNewVehicle(string i_OwnerLisenceNumber)
{
string clientName = UserInterface.ReadOwnerName();
string clientPhoneNumber = UserInterface.ReadOwnerPhoneNumber();
Vehicle.eVehicleType vehicleType = UserInterface.ReadVehicleType();
string modelName = UserInterface.ReadModelName();
float energyLeft = UserInterface.ReadEnergyLeft();
float maxEnergy = UserInterface.ReadMaxEnergy();
LinkedList <Vehicle.Wheel> wheels = UserInterface.ReadWheels(vehicleType);
object uniqueParamOne = UserInterface.ReadUniqueParamOne(vehicleType);
object oniqueParamTwo = UserInterface.ReadUniqueParamTwo(vehicleType);;
// list order : 0. vehicleType ; 1. i_lisence number ; 2. modelName ; 3. energyLeft ; 4. maxEnergy ; 5. <wheels> ; 6. unique param one. ; 7. unique param two.
List <object> parametersList = new List <object>();
parametersList.Add(vehicleType);
parametersList.Add(i_OwnerLisenceNumber);
parametersList.Add(modelName);
parametersList.Add(energyLeft);
parametersList.Add(maxEnergy);
parametersList.Add(wheels);
parametersList.Add(uniqueParamOne);
parametersList.Add(oniqueParamTwo);
Client newClient = new Client(clientName, clientPhoneNumber, parametersList);
}
private void insertNewVehicleToGarage()
{
string licenseNumber = getLicenseNumber();
bool isAlreadyInGarage = r_Garage.IsVehicleInGarage(licenseNumber);
Vehicle newVehicle;
Vehicle.eVehicleType vehicleType = new Vehicle.eVehicleType();
VehicleFolder.eVehicleStatus newStatus = VehicleFolder.eVehicleStatus.InHandling;
if (isAlreadyInGarage)
{
StringBuilder vehicleInGarage = new StringBuilder();
r_Garage.ChangeTheStatusOfCar(licenseNumber, newStatus);
vehicleInGarage.AppendFormat("The vehicle already in the garage. Its Status changed to: {0}", newStatus.ToString());
UI.PrintString(vehicleInGarage.ToString());
}
else
{
newVehicle = setNewVehicle(licenseNumber, ref vehicleType);
string ownerName = getOwnerName();
string ownerPhoneNumber = getOwnerPhoneNumber();
setSpecificVehicleParameters(newVehicle);
r_Garage.InsertNewVehicleToGarage(newVehicle, ownerName, ownerPhoneNumber);
}
}
private Vehicle.eVehicleType getVehicleTypeFronUser()
{
bool check = false;
Screen.Clear();
Vehicle.eVehicleType vehicleType = Vehicle.eVehicleType.Car;
while (!check)
{
try
{
Console.WriteLine("Select vehicle type:{0}1) Car{0}2) Truck{0}3) Motorcycle", Environment.NewLine);
bool inputValid = int.TryParse(Console.ReadLine(), out int input);
if (inputValid == false)
{
throw new FormatException();
}
if (input <= 0 || input > 3)
{
throw new ValueOutOfRangeException(0, 3);
}
if (input == 1)
{
vehicleType = Vehicle.eVehicleType.Car;
}
else if (input == 2)
{
vehicleType = Vehicle.eVehicleType.Truck;
}
else
{
vehicleType = Vehicle.eVehicleType.Motorcycle;
}
check = true;
}
catch (FormatException)
{
Screen.Clear();
Console.WriteLine("{0}", Environment.NewLine);
Console.WriteLine("->[Only numbers are acceptable,please enter number]<-");
Console.WriteLine("{0}", Environment.NewLine);
}
catch (ValueOutOfRangeException ex)
{
Screen.Clear();
Console.WriteLine("{0}", Environment.NewLine);
Console.WriteLine("{0}", ex.Message);
Console.WriteLine("{0}", Environment.NewLine);
}
}
return(vehicleType);
}
public static Vehicle BuildVehicle(string i_LicensePlate, Vehicle.eVehicleType i_VehicleType)
{
const float k_BikeMaxAirPressure = 30;
const float k_CarMaxAirPressure = 32;
const float k_TruckMaxAirPressure = 28;
const float k_GasBikeMaxTankSize = 7;
const float k_GasCarMaxTankSize = 60;
const float k_ElectricCarMaxBaterySize = 2.1f;
const float k_ElectricBikeMaxBaterySize = 1.2f;
const float k_TruckMaxTankSize = 120;
Vehicle newVehicle = null;
switch (i_VehicleType)
{
case Vehicle.eVehicleType.ElectricBike:
{
newVehicle = new Bike(i_LicensePlate, new ElectricEngine(k_ElectricBikeMaxBaterySize), k_BikeMaxAirPressure);
break;
}
case Vehicle.eVehicleType.ElectricCar:
{
newVehicle = new Car(i_LicensePlate, new ElectricEngine(k_ElectricCarMaxBaterySize), k_CarMaxAirPressure);
break;
}
case Vehicle.eVehicleType.GasBike:
{
newVehicle = new Bike(i_LicensePlate, new GasEngine(Engine.eFuelType.Octan95, k_GasBikeMaxTankSize), k_BikeMaxAirPressure);
break;
}
case Vehicle.eVehicleType.GasCar:
{
newVehicle = new Car(i_LicensePlate, new GasEngine(Engine.eFuelType.Octan96, k_GasCarMaxTankSize), k_CarMaxAirPressure);
break;
}
case Vehicle.eVehicleType.Truck:
{
newVehicle = new Truck(i_LicensePlate, new GasEngine(Engine.eFuelType.Soler, k_TruckMaxTankSize), k_TruckMaxAirPressure);
break;
}
default:
{
break;
}
}
newVehicle.FillRequests();
return(newVehicle);
}
internal Engine(eEngineType i_EngineType, float i_EnergyLeft, Vehicle.eVehicleType i_VehicleType)
{
m_EngineType = i_EngineType;
m_CurrentLeftEnergy = i_EnergyLeft;
switch (m_EngineType)
{
case eEngineType.Fuel:
switch (i_VehicleType)
{
case Vehicle.eVehicleType.Car:
m_MaxEnergyCapacity = 45;
m_EnergyType = eEnergyType.Octan98;
break;
case Vehicle.eVehicleType.Motorcycle:
m_MaxEnergyCapacity = 6;
m_EnergyType = eEnergyType.Octan96;
break;
case Vehicle.eVehicleType.Truck:
m_MaxEnergyCapacity = 115;
m_EnergyType = eEnergyType.Octan96;
break;
default:
throw new ArgumentException();
}
break;
case eEngineType.Electric:
switch (i_VehicleType)
{
case Vehicle.eVehicleType.Car:
m_MaxEnergyCapacity = 3.2f;
m_EnergyType = eEnergyType.Electricity;
break;
case Vehicle.eVehicleType.Motorcycle:
m_MaxEnergyCapacity = 1.8f;
m_EnergyType = eEnergyType.Electricity;
break;
default:
throw new ArgumentException();
}
break;
}
if (m_CurrentLeftEnergy > m_MaxEnergyCapacity)
{
throw new ArgumentException();
}
updateEnergyPercentge();
}
public void AddCarToGarage(string i_OwnerName, string i_OwnerPhone, string i_LicenseNumber, int i_VehicleTypeInt)
{
Vehicle newVehicle;
Vehicle.eVehicleType vehicleType = (Vehicle.eVehicleType)i_VehicleTypeInt;
newVehicle = Vehicle.CreateVehicle(vehicleType, i_LicenseNumber);
m_CurrentVehicleInGarage = new VehicleInGarage(i_OwnerName, i_OwnerPhone, newVehicle);
r_VehiclesInGarage.Add(i_LicenseNumber, m_CurrentVehicleInGarage);
m_CurrentVehicleInGarage.OwnerVehicle.VehicleType = vehicleType;
}
private Vehicle.eVehicleType getVehicleType()
{
Vehicle.eVehicleType userChoice = new Vehicle.eVehicleType();
string stringToPrint = "Please choose type of vehicle:";
UI.PrintString(stringToPrint);
userChoice = (Vehicle.eVehicleType)UI.GetInputAccordingToEnum(userChoice);
return(userChoice);
}
private Vehicle getOwnerVehicle()
{
Vehicle.eVehicleType vehicleType = getVehicleType();
string vehicleModel = getVehicleModel();
string licensePlate = getLicensePlate();
EnergyType energyType = getEnergyType(vehicleType);
Wheel wheel = getWheelData(vehicleType);
Vehicle ownerVehicle = VehicleInitializer.CreateNewVehicle(vehicleType, vehicleModel, licensePlate, energyType, wheel);
updateVehicleInnerData(ownerVehicle);
return(ownerVehicle);
}
private static Vehicle getVehicleFromClient(string i_LicensePlate, Garage i_Garage)
{
Vehicle.eVehicleType vehicleType = getVehicleType();
Vehicle vehicle = Vehicle.VehicleBuilder.BuildVehicle(i_LicensePlate, vehicleType);
Console.WriteLine("Please Enter Vehicle Details: ");
List <string> wheelMakers;
List <float> wheelsAirPressure;
Dictionary <Vehicle.eProperties, string> answers = getVehicleDetails(vehicle.Requests, vehicle, out wheelMakers, out wheelsAirPressure);
vehicle.UpdateProperties(answers, wheelMakers, wheelsAirPressure);
return(vehicle);
}
private EnergyType getEnergyType(Vehicle.eVehicleType i_VehicleType)
{
EnergyType energyType = null;
if (i_VehicleType == Vehicle.eVehicleType.ElectricCar || i_VehicleType == Vehicle.eVehicleType.ElectricMotorcycle)
{
energyType = new Electric();
}
else
{
energyType = new Fuel();
}
return(energyType);
}
public Client(string i_Name, string i_PhoneNumber, List <object> io_ParametersList)
{
// list order : 0. vehicleType ; 1. i_lisence number ; 2. modelName ; 3. energyLeft ; 4. maxEnergy ; 5. <wheels> ; 6. unique param one. ; 7. unique param two.
try
{
// set local fields
m_Name = i_Name;
m_PhoneNumber = i_PhoneNumber;
m_VehicleType = (Vehicle.eVehicleType)io_ParametersList[0];
m_RepairStatus = Vehicle.eRepairStatus.InProgress;
m_Vehicle = Factory.MakeVehicle(io_ParametersList);
}
catch (FormatException e)
{
throw e;
}
}
public void AddClient(string io_ClientName, string io_lientPhoneNumber, string io_ModelName,
string io_LicenseNumber, Vehicle.eVehicleType io_VehicleType, string io_WheelsManufacture, float io_WheelsAirPressure,
Engine.eEngineType io_EngineType, float io_EenergyLeft,
List <object> io_UniqueParametersList)
{
try
{
List <Wheel> wheels = setAllWheels(io_WheelsManufacture, io_WheelsAirPressure, io_VehicleType);
Client newClient = new Client(io_ClientName, io_lientPhoneNumber, io_ModelName, io_LicenseNumber,
io_VehicleType, wheels, io_EngineType, io_EenergyLeft, io_UniqueParametersList);
m_Clients.Add(io_LicenseNumber, newClient);
}
catch (Exception e)
{
throw e;
}
}
public static Truck CreateNewTruck()
{
int numberOfWheels = 12;
float maxWheelAirPressure = 32;
Vehicle.eEnergyType energyType = Vehicle.eEnergyType.Fuel;
Vehicle.eFuelType fuelType = Vehicle.eFuelType.Octan96;
float tankSize = 135F;
Vehicle.eVehicleType vehicleType = Vehicle.eVehicleType.Truck;
return(new Truck(energyType,
fuelType,
tankSize,
maxWheelAirPressure,
numberOfWheels,
vehicleType));
}
public static Vehicle createCar(Vehicle.eVehicleType i_VehicleType, string i_lisence)
{
Vehicle vehicle;
if (i_VehicleType == Vehicle.eVehicleType.Car)
{
vehicle = new Car();
}
else if (i_VehicleType == Vehicle.eVehicleType.Motorcycle)
{
vehicle = new Motorcycle();
}
else
{
vehicle = new Truck();
}
return(vehicle);
}
internal static Vehicle MakeVehicle(string io_ModelName,
string io_LicenseNumber, Vehicle.eVehicleType io_VehicleType, List <Wheel> io_Wheels,
Engine.eEngineType io_EngineType, float ioEenergyLeft,
List <object> io_UniqueParametersList)
{
Vehicle newVehicle;
try
{
switch (io_VehicleType)
{
case Vehicle.eVehicleType.Car:
newVehicle = makeCar(io_ModelName,
io_LicenseNumber, io_Wheels,
io_EngineType, ioEenergyLeft,
io_UniqueParametersList);
break;
case Vehicle.eVehicleType.Motorcycle:
newVehicle = makeMotorcycle(io_ModelName,
io_LicenseNumber, io_Wheels,
io_EngineType, ioEenergyLeft,
io_UniqueParametersList);
break;
case Vehicle.eVehicleType.Truck:
newVehicle = makeTruck(io_ModelName,
io_LicenseNumber, io_Wheels,
io_EngineType, ioEenergyLeft,
io_UniqueParametersList);
break;
default:
throw new ArgumentException();
}
return(newVehicle);
}
catch (Exception exception)
{
throw exception;
}
}
internal static Vehicle MakeVehicle(List <object> io_ParametersList)
{
// list order : 0. vehicleType ; 1. i_lisence number ; 2. modelName ; 3. energyLeft ; 4. maxEnergy ; 5. <wheels> ; 6. unique param one. ; 7. unique param two.
Vehicle newVehicle;
try
{
Vehicle.eVehicleType vehicleType = (Vehicle.eVehicleType)io_ParametersList[0];
switch (vehicleType)
{
case Vehicle.eVehicleType.ElectricCar:
newVehicle = makeElectricCar(io_ParametersList);
break;
case Vehicle.eVehicleType.ElectricMotorcycle:
newVehicle = makeElectricMotorcycle(io_ParametersList);
break;
case Vehicle.eVehicleType.FueledCar:
newVehicle = makeFueledCar(io_ParametersList);
break;
case Vehicle.eVehicleType.FueledMotorcycle:
newVehicle = makeFueledMotorcycle(io_ParametersList);
break;
case Vehicle.eVehicleType.FueledTruck:
newVehicle = makeFueledTruck(io_ParametersList);
break;
default:
throw new ArgumentException();
}
return(newVehicle);
}
catch (Exception exception)
{
throw exception;
}
}
private Vehicle setNewVehicle(string i_LicenseNumber, ref Vehicle.eVehicleType io_VehicleType)
{
string vehicleManufacturName, wheelsManufacturName;
EnergySource.eEnergySourceType energyType;
float remainingEnergy, wheelsCurrentAirPressure;
Vehicle newVehicle;
io_VehicleType = getVehicleType();
energyType = getEnergySource(io_VehicleType);
vehicleManufacturName = getVehicleManufacturName();
remainingEnergy = getRemainingEnergy();
wheelsManufacturName = getWheelsManufacturName();
wheelsCurrentAirPressure = getWheelsCurrentAirPressure();
newVehicle = VehicleCreator.CreateTheVehicle(io_VehicleType, vehicleManufacturName, i_LicenseNumber, remainingEnergy,
energyType, wheelsManufacturName, wheelsCurrentAirPressure);
return(newVehicle);
}
private EnergySource.eEnergySourceType getEnergySource(Vehicle.eVehicleType i_TypeOfVehicle)
{
bool isTruck = i_TypeOfVehicle == Vehicle.eVehicleType.Truck;
string stringToPrint;
EnergySource.eEnergySourceType energyType = new EnergySource.eEnergySourceType();
if (!isTruck)
{
stringToPrint = "Please choose the energy source:";
UI.PrintString(stringToPrint);
energyType = (EnergySource.eEnergySourceType)UI.GetInputAccordingToEnum(energyType);
}
else
{
energyType = EnergySource.eEnergySourceType.Fuel;
}
return(energyType);
}
public static Vehicle CreateVehicle(Vehicle.eVehicleType i_VehicleType, string i_ModelName, string i_LicenseNumber, float i_RemainingPowerSupply, PowerSource.ePowerSupply i_PowerSupply, string i_TiresManufacturerName)
{
switch (i_VehicleType)
{
case Vehicle.eVehicleType.Car:
m_Vehicle = CreateCar(i_ModelName, i_LicenseNumber, i_RemainingPowerSupply, i_PowerSupply, i_TiresManufacturerName);
break;
case Vehicle.eVehicleType.Motorcycle:
m_Vehicle = CreateMotorcycle(i_ModelName, i_LicenseNumber, i_RemainingPowerSupply, i_PowerSupply, i_TiresManufacturerName);
break;
case Vehicle.eVehicleType.Truck:
m_Vehicle = CreateTruck(i_ModelName, i_LicenseNumber, i_RemainingPowerSupply, i_PowerSupply,
i_TiresManufacturerName);
break;
}
return(m_Vehicle);
}
private Vehicle makeNewVehicle(string i_CarModel, string i_LicenseNumber, string i_WheelManufacturer)
{
Vehicle.eVehicleType newVehicleType = this.getVehicleTypeFronUser();
Engine.eTypeOfEngine typeOfEngine;
if (newVehicleType == Vehicle.eVehicleType.Truck)
{
typeOfEngine = Engine.eTypeOfEngine.Fuel;
}
else
{
typeOfEngine = getEngineTypeFromUser();
}
Vehicle vehicleToAdd = addCarToGarage.AddVehicle(i_CarModel, i_LicenseNumber, i_WheelManufacturer, typeOfEngine, newVehicleType);
this.getVehicleDetailsByVehicle(vehicleToAdd);
return(vehicleToAdd);
}
internal Client(string i_ClientName, string i_ClientPhoneNumber, string io_ModelName,
string io_LicenseNumber, Vehicle.eVehicleType io_VehicleType, List <Wheel> io_Wheels,
Engine.eEngineType io_EngineType, float ioEenergyLeft,
List <object> io_UniqueParametersList)
{
try
{
// set local fields
m_Name = i_ClientName;
m_PhoneNumber = i_ClientPhoneNumber;
m_VehicleType = io_VehicleType;
m_Vehicle = Factory.MakeVehicle(io_ModelName,
io_LicenseNumber, io_VehicleType, io_Wheels,
io_EngineType, ioEenergyLeft,
io_UniqueParametersList);
}
catch (FormatException e)
{
throw e;
}
}
public DetailsOfVehicle(
string i_OwnerName,
string i_OwnerPhone,
string i_Model,
string i_PlateNumber,
Energy i_EnergyType,
int i_NumberOfWheels,
string i_ManufacturerName,
float i_MaxPressure,
Vehicle.eVehicleType i_VehicleType)
{
m_OwnerName = i_OwnerName;
m_OwnerPhone = i_OwnerPhone;
r_Model = i_Model;
r_PlateNumber = i_PlateNumber;
m_EnergyType = i_EnergyType;
m_NumberOfWheels = i_NumberOfWheels;
m_VehicleType = i_VehicleType;
m_Wheels = new List <Wheel>();
setVehicleWheels(i_ManufacturerName, i_MaxPressure, i_NumberOfWheels);
}
public static Vehicle CreateNewVehicle(
Vehicle.eVehicleType i_VehicleType,
string i_Model,
string i_LicenseNumber,
EnergyType i_SourceOfEnergy,
Wheel i_Wheel)
{
Vehicle newVehicle = null;
if (i_VehicleType == Vehicle.eVehicleType.ElectricCar || i_VehicleType == Vehicle.eVehicleType.FuelCar)
{
newVehicle = new Car(i_Model, i_LicenseNumber, i_SourceOfEnergy, i_Wheel);
}
else if (i_VehicleType == Vehicle.eVehicleType.Truck)
{
newVehicle = new Truck(i_Model, i_LicenseNumber, i_SourceOfEnergy, i_Wheel);
}
else
{
newVehicle = new Motorcycle(i_Model, i_LicenseNumber, i_SourceOfEnergy, i_Wheel);
}
return(newVehicle);
}
public DetailsOfMotorcycle(
string i_OwnerName,
string i_OwnerPhone,
string i_Model,
string i_PlateNumber,
Energy i_EnergyType,
string i_ManufacturerName,
Vehicle.eVehicleType i_VehicleType,
Motorcycle.eMotorcycleLicenseType i_LicenseType,
int i_EngineVolume)
: base(
i_OwnerName,
i_OwnerPhone,
i_Model,
i_PlateNumber,
i_EnergyType,
k_MotorcycleWheelNumber,
i_ManufacturerName,
k_MotorcycleWheelMaxPressure,
i_VehicleType)
{
m_EngineVolume = i_EngineVolume;
m_LicenseType = i_LicenseType;
}
