private static void GasVehicleArgumentsCollection( ArgumentsCollection i_ArgumentsCollection) { i_ArgumentsCollection.AddArgument( VehicleFactory.eArgumentKeys.CurrentAmountOfGasoline, new ArgumentWrapper("Current amount of fuel in liters", null, false, typeof(float))); }
public void Enumerate_WithNestedResponseFiles_ReturnsOriginalInputWithContentsOfResponseFilesInline() { string tempFileName1 = GetTempFileName(); string tempFileName2 = GetTempFileName(); File.WriteAllLines(tempFileName1, new[] { "2", "@" + tempFileName2, "5" }); File.WriteAllLines(tempFileName2, new[] { "3", "4" }); IEnumerable <string> input = new[] { "1", "@" + tempFileName1, "6" }; IEnumerable <string> expected = new[] { "1", "2", "3", "4", "5", "6" }; string[] output = new ArgumentsCollection(input).ToArray(); CollectionAssert.AreEqual(expected, output); }
public Directive(string name) : base(name) { this.m_nodeType = NodeTypes.DIRECTIVE; this.m_arguments = new ArgumentsCollection(); this.m_text = name; }
private static void ElectricVehicleArgumentsCollection( ArgumentsCollection i_ArgumentsCollection) { i_ArgumentsCollection.AddArgument( VehicleFactory.eArgumentKeys.CurrentAmountOfEnergy, new ArgumentWrapper("Current amount of hours remaining in battery", null, false, typeof(float))); }
public Block(string name) : base(name) { this.m_nodeType = NodeTypes.BLOCK; this.m_arguments = new ArgumentsCollection(); this.m_text = name; }
public void AddVehicleToGarage(ArgumentsCollection i_Arguments, string i_VehicleTypeString, string i_OwnerName, string i_OwnerPhoneNumber) { eSupportedVehicles vehicleType = parseVehicleTypeFromString(i_VehicleTypeString); Vehicle newVehicle = VehicleFactory.BuildVehicle(vehicleType, i_Arguments); r_VehicleInventory.Add(newVehicle.LicensePlateNumber, newVehicle); AddTicket(newVehicle.LicensePlateNumber, new GarageTicket(i_OwnerName, i_OwnerPhoneNumber, newVehicle.LicensePlateNumber)); }
internal static ArgumentsUtils.ArgumentsCollection GetElectricMotorcycleArguments() { ArgumentsUtils.ArgumentsCollection argumentsCollection = new ArgumentsCollection(); vehicleArgumentsCollection(argumentsCollection); ElectricVehicleArgumentsCollection(argumentsCollection); MotorcycleArgumentsCollection(argumentsCollection); return(argumentsCollection); }
internal static ArgumentsUtils.ArgumentsCollection GetGasolineTruckArguments() { ArgumentsUtils.ArgumentsCollection argumentsCollection = new ArgumentsCollection(); vehicleArgumentsCollection(argumentsCollection); GasVehicleArgumentsCollection(argumentsCollection); TruckArgumentsCollection(argumentsCollection); return(argumentsCollection); }
private static void vehicleArgumentsCollection( ArgumentsCollection i_ArgumentsCollection) { i_ArgumentsCollection.AddArgument( eArgumentKeys.LicensePlate, new ArgumentWrapper("License plate number", null, false, typeof(string))); i_ArgumentsCollection.AddArgument( eArgumentKeys.Model, new ArgumentWrapper("Model", null, false, typeof(string))); }
private static void TicketArgumentsCollection( ArgumentsCollection i_ArgumentsCollection) { i_ArgumentsCollection.AddArgument( eArgumentKeys.OwnerName, new ArgumentWrapper("Owner's name", null, false, typeof(string))); i_ArgumentsCollection.AddArgument( eArgumentKeys.OwnerPhoneNumber, new ArgumentWrapper("Owner's phone number", null, false, typeof(string))); }
private static Car createCar(ArgumentsCollection i_Arguments, Motor i_Motor) { string licensePlate = (string)i_Arguments[eArgumentKeys.LicensePlate].Response; string model = (string)i_Arguments[eArgumentKeys.Model].Response; eNumberOfCarDoors numberOfDoors = (eNumberOfCarDoors)Enum.Parse(typeof(eNumberOfCarDoors), i_Arguments[eArgumentKeys.NumberOfDoors].Response); eCarColors carColor = (eCarColors)Enum.Parse(typeof(eCarColors), i_Arguments[eArgumentKeys.Color].Response); Wheel[] wheels = wheelsCollectionBuilder(i_Arguments, Car.k_NumberOfWheels, VehicleMaxConstantsCollection[eVehicleMaxConstantTypes.CarMaxWheelPressure]); return(new Car(i_Motor, wheels, VehicleMaxConstantsCollection[eVehicleMaxConstantTypes.CarMaxWheelPressure], licensePlate, model, carColor, numberOfDoors)); }
private static Motor getElectricMotor(ArgumentsCollection i_Arguments, float i_MaxCapacity) { float currentAmountOfBattery = float.Parse(i_Arguments[eArgumentKeys.CurrentAmountOfEnergy].Response); Battery battery = new Battery( sr_EnergyTypesDictionary[eSupportedVehicles.ElectricCar], i_MaxCapacity, currentAmountOfBattery); return(new Motor(battery, eMotorType.Electric)); }
private static Motor getGasolineMotor(ArgumentsCollection i_Arguments, float i_MaxCapacity) { float currentAmountOfGasoline = float.Parse(i_Arguments[eArgumentKeys.CurrentAmountOfGasoline].Response); GasolineTank gasolineTank = new GasolineTank( sr_EnergyTypesDictionary[eSupportedVehicles.GasolineCar], i_MaxCapacity, currentAmountOfGasoline); return(new Motor(gasolineTank, eMotorType.Gasoline)); }
private static void CarArgumentsCollection( ArgumentsCollection i_ArgumentsCollection) { wheelsArgumentsCollectionCreator(i_ArgumentsCollection, Car.k_NumberOfWheels); i_ArgumentsCollection.AddArgument( eArgumentKeys.Color, new ArgumentWrapper("Exterior color", Enum.GetNames(typeof(eCarColors)), true, typeof(string))); i_ArgumentsCollection.AddArgument( eArgumentKeys.NumberOfDoors, new ArgumentWrapper("Number of doors", Enum.GetNames(typeof(eNumberOfCarDoors)), true, typeof(string))); }
public void Enumerate_WithSimpleArgumentsInput_ReturnsOriginalInput() { IEnumerable <string> arguments = new[] { "1", "2", "3", "A", "B", "C", string.Empty }; string[] output = new ArgumentsCollection(arguments).ToArray(); CollectionAssert.AreEqual(arguments, output); }
private static void MotorcycleArgumentsCollection( ArgumentsCollection i_ArgumentsCollection) { wheelsArgumentsCollectionCreator(i_ArgumentsCollection, Motorcycle.k_NumberOfWheels); i_ArgumentsCollection.AddArgument( eArgumentKeys.LicenseType, new ArgumentWrapper("License type", Enum.GetNames(typeof(Motorcycle.eLicenseType)), true, typeof(Motorcycle.eLicenseType))); i_ArgumentsCollection.AddArgument( eArgumentKeys.EngineVolume, new ArgumentWrapper("Engine volume in cubic centimeter", null, false, typeof(float))); }
private static void TruckArgumentsCollection( ArgumentsCollection i_ArgumentsCollection) { wheelsArgumentsCollectionCreator(i_ArgumentsCollection, Truck.k_NumberOfWheels); i_ArgumentsCollection.AddArgument( eArgumentKeys.HazardousMaterials, new ArgumentWrapper("Contains hazardous materials", new[] { "True", "False" }, true, typeof(bool))); i_ArgumentsCollection.AddArgument( eArgumentKeys.HaulVolume, new ArgumentWrapper("Container volume in cubic centimeter", null, false, typeof(float))); }
private static Truck createTruck(ArgumentsCollection i_Arguments, Motor i_Motor) { string licensePlate = (string)i_Arguments[eArgumentKeys.LicensePlate].Response; string model = (string)i_Arguments[eArgumentKeys.Model].Response; bool isCarryingHazardousMaterials = bool.Parse(i_Arguments[eArgumentKeys.HazardousMaterials].Response); int haulingVolume = int.Parse(i_Arguments[eArgumentKeys.HaulVolume].Response); Wheel[] wheels = wheelsCollectionBuilder(i_Arguments, Truck.k_NumberOfWheels, VehicleMaxConstantsCollection[eVehicleMaxConstantTypes.TruckMaxWheelPressure]); return(new Truck(i_Motor, wheels, VehicleMaxConstantsCollection[eVehicleMaxConstantTypes.TruckMaxWheelPressure], licensePlate, model, isCarryingHazardousMaterials, haulingVolume)); }
private static Motorcycle createMotorcycle(ArgumentsCollection i_Arguments, Motor i_Motor) { string licensePlate = (string)i_Arguments[eArgumentKeys.LicensePlate].Response; string model = (string)i_Arguments[eArgumentKeys.Model].Response; Motorcycle.eLicenseType licenseType = (Motorcycle.eLicenseType)Enum.Parse(typeof(Motorcycle.eLicenseType), i_Arguments[eArgumentKeys.LicenseType].Response); int engineVolume = int.Parse(i_Arguments[eArgumentKeys.EngineVolume].Response); Wheel[] wheels = wheelsCollectionBuilder(i_Arguments, Motorcycle.k_NumberOfWheels, VehicleMaxConstantsCollection[eVehicleMaxConstantTypes.MotorcycleMaxWheelPressure]); return(new Motorcycle(i_Motor, wheels, VehicleMaxConstantsCollection[eVehicleMaxConstantTypes.MotorcycleMaxWheelPressure], licensePlate, model, licenseType, engineVolume)); }
public void Enumerate_WithNullElements_ReturnsOriginalInputMinusNullElements() { IEnumerable <string> input = new[] { "1", "2", null, "3", "A", null, "B", "C", string.Empty, null }; IEnumerable <string> expected = new[] { "1", "2", "3", "A", "B", "C", string.Empty }; string[] output = new ArgumentsCollection(input).ToArray(); CollectionAssert.AreEqual(expected, output); }
private static void wheelsArgumentsCollectionCreator(ArgumentsCollection i_ArgumentsCollection, int i_NumberOfWheels) { for (int i = 1; i <= i_NumberOfWheels; i++) { i_ArgumentsCollection.AddArgument( eArgumentKeys.WheelManufacturer, i, new ArgumentWrapper(string.Format("Wheel {0} manufacturerer", i), null, false, typeof(string))); i_ArgumentsCollection.AddArgument( eArgumentKeys.WheelCurrentPressure, i, new ArgumentWrapper( string.Format("Wheel {0} current air pressure", i), null, false, typeof(float))); } }
internal static Vehicle BuildVehicle( eSupportedVehicles i_SupportedVehicle, ArgumentsCollection i_ArgumentsCollection) { Vehicle vehicle; switch (i_SupportedVehicle) { case eSupportedVehicles.ElectricCar: { vehicle = GetElectricCar(i_ArgumentsCollection); break; } case eSupportedVehicles.GasolineCar: { vehicle = GetGasolineCar(i_ArgumentsCollection); break; } case eSupportedVehicles.ElectricMotorcycle: { vehicle = GetElectricMotorcycle(i_ArgumentsCollection); break; } case eSupportedVehicles.GasolineMotorcycle: { vehicle = GetGasolineMotorcycle(i_ArgumentsCollection); break; } case eSupportedVehicles.GasolineTruck: { vehicle = GetGasolineTruck(i_ArgumentsCollection); break; } default: { vehicle = null; break; } } return(vehicle); }
public void NonGenericEnumerate_WithSimpleArgumentsInput_ReturnsOriginalInput() { IEnumerable <string> arguments = new[] { "1", "2", "3", "A", "B", "C", string.Empty }; var collection = new ArgumentsCollection(arguments); var enumerable = collection as IEnumerable; var output = new List <string>(); foreach (string element in enumerable) { output.Add(element); } CollectionAssert.AreEqual(arguments, output); }
public void Enumerate_WithEmptyResponseFile_ReturnsOriginalInputMinusResponseFileElement() { string tempFileName = GetTempFileName(); File.WriteAllText(tempFileName, String.Empty); IEnumerable <string> input = new[] { "1", "@" + tempFileName, "2" }; IEnumerable <string> expected = new[] { "1", "2" }; string[] output = new ArgumentsCollection(input).ToArray(); CollectionAssert.AreEqual(expected, output); }
private static Wheel[] wheelsCollectionBuilder(ArgumentsCollection i_ArgumentsCollection, int i_NumberOfWheels, float i_MaxWheelPressure) { Wheel[] wheels = new Wheel[i_NumberOfWheels]; for (int i = 1; i <= i_NumberOfWheels; i++) { string wheelManufacturer = (string)i_ArgumentsCollection[string.Format( "{0}{1}", eArgumentKeys.WheelManufacturer.ToString(), i).ToString()].Response; float wheelWheelPressure = float.Parse(i_ArgumentsCollection[string.Format( "{0}{1}", eArgumentKeys.WheelCurrentPressure.ToString(), i).ToString()].Response); wheels[i - 1] = new Wheel(wheelManufacturer, i_MaxWheelPressure, wheelWheelPressure); } return(wheels); }
internal static Vehicle GetGasolineTruck(ArgumentsCollection i_Arguments) { return(createTruck(i_Arguments, getGasolineMotor(i_Arguments, VehicleMaxConstantsCollection[eVehicleMaxConstantTypes.TruckMaxGasolineTankCapacity]))); }
internal static Vehicle GetElectricMotorcycle(ArgumentsCollection i_Arguments) { return(createMotorcycle(i_Arguments, getElectricMotor(i_Arguments, VehicleMaxConstantsCollection[eVehicleMaxConstantTypes.MotorcycleMaxElectricCapacity]))); }
public static Arguments Parse(string[] args) { var argumentsCollection = ArgumentsCollection.Parse(args); return(new Arguments(argumentsCollection)); }
private Arguments(ArgumentsCollection argumentsCollection) { m_argumentsCollection = argumentsCollection; }
public Directive(string name, string[] arguments) : this(name) { this.m_arguments = new ArgumentsCollection(arguments); this.BuildText(); }
/* private const string TEST = @" D:\Work-Efx\Flash\FlashCoreCs\FlashCoreCs\as3code\extremefx\Main.as(38): col: 9 Warning: Duplicate variable definition. var ii:int = 123; ^ "; static readonly Regex _errorMessage = new Regex(@"(.*?)\((\d+)\)\:\W+col\:\W+(\d+)\W+(\w+):\W+(.*)", RegexOptions.Compiled | RegexOptions.CultureInvariant); */ public static void Main(string[] pArguments) { /* string[] lines = TEST.Split(new[] { '\r', '\n' }); List<Error> el = new List<Error>(); foreach (string line in lines) { if (string.IsNullOrEmpty(line)) continue; Error e = new Error(); Match m = _errorMessage.Match(line); if (m.Success) {//parse error message //capture 1: row //capture 2: col //capture 3: type (Warning/Error) //capture 4: Message e.File = m.Groups[1].Value; int i; int.TryParse(m.Groups[2].Value, out i); e.Line = i; int.TryParse(m.Groups[3].Value, out i); e.Column = i; switch (m.Groups[4].Value.ToLowerInvariant()) { case "warning": e.ErrorType = ErrorType.Warning; break; case "error": e.ErrorType = ErrorType.Error; break; default: e.ErrorType = ErrorType.Message; break; } e.Message = m.Groups[5].Value; el.Add(e); } else { if (line.Trim().Equals("^", StringComparison.Ordinal)) { el[el.Count - 2].AdditionalInfo = el[el.Count - 1].Message; el.RemoveAt(el.Count-1); continue; } e.ErrorType = ErrorType.Message; e.Message = line.Trim(); el.Add(e); } } */ ConverterFactory.AddParser(new As3NamespaceParser(), "as3"); ConverterFactory.AddParser(new JsNamespaceParser(), "js"); ArgumentsCollection commandLine = new ArgumentsCollection(pArguments); string lang = "as3"; if (!string.IsNullOrEmpty(commandLine[@"lang"])) { lang = commandLine[@"lang"]; if (!ConverterFactory.HasConverter(lang)) { Console.WriteLine("The specified language does not has a parser associated."); return; } } if (commandLine["source"] == null) { Console.WriteLine("No source was specified."); return; } string[] sourceFiles = Project.GetSourceFiles(commandLine["source"]); if (sourceFiles == null || sourceFiles.Length == 0) { Console.WriteLine("Source files were not found at the specified location."); return; } if (commandLine["output"] == null) { Console.WriteLine("No output directory was specified."); return; } bool debug = !string.IsNullOrEmpty(commandLine["debug"]); string output = commandLine["output"]; commandLine.Remove("output"); commandLine.Remove("debug"); commandLine.Remove("source"); commandLine.Remove(@"lang"); ICollection<Error> errors = Project.Parse(sourceFiles, lang, output, Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), debug, commandLine, Project.Root); foreach (Error error in errors) { Console.WriteLine(error.Message); } }
private Arguments(ArgumentsCollection argumentsCollection) { m_argumentsCollection = argumentsCollection; }