private void setWheelsPressure(ref Vehicle io_NewVehicle, eVehicleModel i_ModelName)
        {
            float maxAirPressure = getMaxAirPressure(i_ModelName);

            io_NewVehicle.Wheels = new List <Wheel>();

            for (int i = 0; i < io_NewVehicle.NumOfWheels; ++i)
            {
                try
                {
                    float  currentPressure = UI.GetWheelPressure(i + 1, maxAirPressure);
                    string manufacturer    = UI.GetWheelManufacturer(i + 1);

                    io_NewVehicle.Wheels.Add(new Wheel(manufacturer, currentPressure, maxAirPressure));
                }
                catch (FormatException formatException)
                {
                    UI.PrintMessage(formatException.Message);
                    --i;
                }
                catch (ValueOutOfRangeException valueOutOfRangeException)
                {
                    UI.PrintMessage(valueOutOfRangeException.Message);
                    --i;
                }
            }
        }
        // $G$ CSS-015 (-5) Bad variable name (should be in the form of: ref io_CamelCase).
        // $G$ DSN-002 (-10) The UI should not know Car\Truck\Motorcycle
        private void setVehicleInfoByModel(eVehicleModel i_ModelName, ref Vehicle o_NewVehicle)
        {
            switch (i_ModelName)
            {
            case eVehicleModel.ElectricMotorcycle:
                setMotorcycle(o_NewVehicle as Motorcycle);
                (o_NewVehicle.EnergySource as Electric).UpdateBatteryLeftInTheHours(o_NewVehicle.PercentageRemainingEnergy);
                break;

            case eVehicleModel.RegularMotorcycle:
                setMotorcycle(o_NewVehicle as Motorcycle);
                (o_NewVehicle.EnergySource as Fuel).UpdateCurrentAmountOfFuelInLiters(o_NewVehicle.PercentageRemainingEnergy);
                break;

            case eVehicleModel.RegularCar:
                setCar(o_NewVehicle as Car);
                (o_NewVehicle.EnergySource as Fuel).UpdateCurrentAmountOfFuelInLiters(o_NewVehicle.PercentageRemainingEnergy);
                break;

            case eVehicleModel.ElectricCar:
                setCar(o_NewVehicle as Car);
                (o_NewVehicle.EnergySource as Electric).UpdateBatteryLeftInTheHours(o_NewVehicle.PercentageRemainingEnergy);
                break;

            case eVehicleModel.Truck:
                setTruck(o_NewVehicle as Truck);
                (o_NewVehicle.EnergySource as Fuel).UpdateCurrentAmountOfFuelInLiters(o_NewVehicle.PercentageRemainingEnergy);
                break;
            }
        }
        public static Vehicle CreateNewVehicle(eVehicleModel i_Model, string i_LicenseNumber)
        {
            Vehicle newVehicle = null;
            string  modelStr   = VehicleModelToText.AsText(i_Model);

            switch (i_Model)
            {
            case eVehicleModel.RegularMotorcycle:
                newVehicle = createRegularMotorcycle(modelStr, i_LicenseNumber);
                break;

            case eVehicleModel.ElectricMotorcycle:
                newVehicle = createElectricMotorcycle(modelStr, i_LicenseNumber);
                break;

            case eVehicleModel.RegularCar:
                newVehicle = createRegularCar(modelStr, i_LicenseNumber);
                break;

            case eVehicleModel.ElectricCar:
                newVehicle = createElectricCar(modelStr, i_LicenseNumber);
                break;

            case eVehicleModel.Truck:
                newVehicle = createTruck(modelStr, i_LicenseNumber);
                break;
            }

            return(newVehicle);
        }
        private void addNewCustomer(string i_LiceneseNumber)
        {
            string        ownerName        = UI.GetOwnerName();
            string        ownerPhoneNumber = UI.GetOwnerPhoneNumber();
            eVehicleModel modelName        = UI.GetModelName();
            Vehicle       newVehicle       = VehicleFactory.CreateNewVehicle(modelName, i_LiceneseNumber);

            setWheelsPressure(ref newVehicle, modelName);
            setPercentageRemainingEnergy(modelName, ref newVehicle);
            setVehicleInfoByModel(modelName, ref newVehicle);
            m_Garage.AddNewCustomer(ref newVehicle, ownerName, ownerPhoneNumber);
        }
        private void setPercentageRemainingEnergy(eVehicleModel i_ModelName, ref Vehicle o_NewVehicle)
        {
            bool isValidInput = false;

            while (!isValidInput)
            {
                try
                {
                    o_NewVehicle.PercentageRemainingEnergy = UI.GetRemainingPercentageEnergy(
                        VehicleModelToText.AsText(i_ModelName), 100, 0);
                    isValidInput = true;
                }
                catch (FormatException formatException)
                {
                    UI.PrintMessage(formatException.Message);
                }
                catch (ValueOutOfRangeException valueOutOfRangeException)
                {
                    UI.PrintMessage(valueOutOfRangeException.Message);
                }
            }
        }
示例#6
0
        public static string AsText(eVehicleModel i_eSupport)
        {
            string enumDescripton = "null";

            switch (i_eSupport)
            {
            case eVehicleModel.RegularMotorcycle:
            {
                enumDescripton = "Regular Motorcycle";
                break;
            }

            case eVehicleModel.ElectricMotorcycle:
            {
                enumDescripton = "Electric Motorcycle";
                break;
            }

            case eVehicleModel.RegularCar:
            {
                enumDescripton = "Regular Car";
                break;
            }

            case eVehicleModel.ElectricCar:
            {
                enumDescripton = "Electric Car";
                break;
            }

            case eVehicleModel.Truck:
            {
                enumDescripton = "Truck";
                break;
            }
            }

            return(enumDescripton);
        }
        private float getMaxAirPressure(eVehicleModel i_eVehicleModel)
        {
            float maxAirPressure = 0;

            switch (i_eVehicleModel)
            {
            case eVehicleModel.RegularMotorcycle:
            case eVehicleModel.ElectricMotorcycle:
                maxAirPressure = Consts.k_MotorcycleWheelPressure;
                break;

            case eVehicleModel.ElectricCar:
            case eVehicleModel.RegularCar:
                maxAirPressure = Consts.k_CarWheelPressure;
                break;

            case eVehicleModel.Truck:
                maxAirPressure = Consts.k_TruckWheelPressure;
                break;
            }

            return(maxAirPressure);
        }