private static void AddCommando(string[] tokens)
{
try
{
Commando commando = new Commando(tokens[1], tokens[2],
tokens[3], decimal.Parse(tokens[4]), tokens[5]);
for (int i = 6; i < tokens.Length; i += 2)
{
try
{
Mission mission = new Mission(tokens[i], tokens[i + 1]);
commando.AddMission(mission);
}
catch (ArgumentException ex)
{
Console.WriteLine(ex.Message);
}
}
soldiers.Add(commando);
}
catch (ArgumentException ex)
{
Console.WriteLine(ex.Message);
}
}
private static ICommando AddCommando(string[] cmdArgs, int id, string firstName, string lastName, decimal salary, string corps)
{
ICommando commando = new Commando(id, firstName, lastName, salary, corps);
var missinArgs = cmdArgs
.Skip(6)
.ToArray();
for (int i = 0; i < missinArgs.Length; i += 2)
{
try
{
string missionCodeName = missinArgs[i];
string missionState = missinArgs[i + 1];
IMisson misson = new Mission(missionCodeName, missionState);
commando.AddMission(misson);
}
catch (InvalidStateException ise)
{
continue;
}
}
return(commando);
}
private void AddCommando(string[] arr)
{
try
{
Commando comando = null;
if (arr.Length > 5)
{
comando = new Commando(
int.Parse(arr[0]),
arr[1],
arr[2],
decimal.Parse(arr[3]),
arr[4],
MakeMissionArray(arr.Skip(5).ToArray()));
}
else
{
comando = new Commando(
int.Parse(arr[0]),
arr[1],
arr[2],
decimal.Parse(arr[3]),
arr[4]);
}
solgers.Add(comando);
}
catch (Exception e)
{
}
}
static void CreateCommando(string[] tokens)
{
List <IMission> missions = new List <IMission>();
for (int i = 6; i < tokens.Length; i += 2)
{
try
{
missions.Add(new Mission(tokens[i], tokens[i + 1]));
}
catch (Exception) { }
}
try
{
Commando cmd = new Commando(tokens[1],
tokens[2],
tokens[3],
double.Parse(tokens[4]),
tokens[5],
missions);
Print(cmd);
}
catch (Exception) { }
}
public static Commando Create(string[] parts)
{
Commando current = new Commando(parts[1], parts[2], parts[3], decimal.Parse(parts[4]), parts[5]);
current.AddMissions(parts);
return(current);
}
private static Commando CreateCommando(
string id,
string firstName,
string lastName,
decimal salary,
string corps,
List <string> commandParts)
{
var commando = new Commando(id, firstName, lastName, salary, corps);
for (int i = 6; i < commandParts.Count - 1; i += 2)
{
try
{
var missionName = commandParts[i];
var missionState = commandParts[i + 1];
commando.AddMission(new Mission(missionName, missionState));
}
catch (ArgumentException)
{
continue;
}
}
return(commando);
}
private static void FillList(List <Soldier> soldiers, string[] parts)
{
switch (parts[0])
{
case "Private":
soldiers.Add(Private.Create(parts));
break;
case "LieutenantGeneral":
soldiers.Add(LieutenantGeneral.Create(parts, soldiers));
break;
case "Engineer":
soldiers.Add(Engineer.Create(parts));
break;
case "Commando":
soldiers.Add(Commando.Create(parts));
break;
case "Spy":
soldiers.Add(Spy.Create(parts));
break;
default:
break;
}
}
private static void AddSoldier(List <Soldier> army, string inputLine)
{
var splitedInput = inputLine.Split();
var soldierType = splitedInput[0];
var id = splitedInput[1];
var firstName = splitedInput[2];
var lastName = splitedInput[3];
bool isPrivate = soldierType.Equals("Private", StringComparison.OrdinalIgnoreCase);
bool isLeutenantGeneral = soldierType.Equals("LeutenantGeneral", StringComparison.OrdinalIgnoreCase);
bool isEngineer = soldierType.Equals("Engineer", StringComparison.OrdinalIgnoreCase);
bool isCommando = soldierType.Equals("Commando", StringComparison.OrdinalIgnoreCase);
bool isSpy = soldierType.Equals("Spy", StringComparison.OrdinalIgnoreCase);
if (isPrivate)
{
var salary = double.Parse(splitedInput[4]);
var inputPrivate = new Private(firstName, lastName, id, salary);
army.Add(inputPrivate);
}
else if (isLeutenantGeneral)
{
var salary = double.Parse(splitedInput[4]);
List <ISoldier> privates = ExtractPrivates(splitedInput, army);
var inputLeutenantGeneral = new LeutenantGeneral(firstName, lastName, id, salary, privates);
army.Add(inputLeutenantGeneral);
}
else if (isEngineer)
{
var salary = double.Parse(splitedInput[4]);
var corps = splitedInput[5];
List <IRepair> repairs = ExtractRepairs(splitedInput);
var inputEngineer = new Engineer(firstName, lastName, id, salary, corps, repairs);
army.Add(inputEngineer);
}
else if (isCommando)
{
var salary = double.Parse(splitedInput[4]);
var corps = splitedInput[5];
List <IMission> missions = ExtractMissions(splitedInput);
var inputCommando = new Commando(firstName, lastName, id, salary, corps, missions);
army.Add(inputCommando);
}
else if (isSpy)
{
var code = int.Parse(splitedInput[4]);
var inputSpy = new Spy(firstName, lastName, id, code);
army.Add(inputSpy);
}
}
static void Main(string[] args)
{
//Private 1 Pesho Peshev 22.22
//Commando 13 Stamat Stamov 13.1 Airforces
//Private 222 Toncho Tonchev 80.08
//LieutenantGeneral 3 Joro Jorev 100 222 1
//End
ISoldier soldier = new Private(1, "Pesho", "Peshev", 22.22M);
ISoldier soldier1 = new Commando(13, "Stamat", "Stamov", 13.1M, Enums.SoldierCorps);
}
private static void GetMissionsForCommando(Commando commando, string[] soldierArgs)
{
for (int index = 6; index < soldierArgs.Length; index += 2)
{
if (IsValidMissionState(soldierArgs[index + 1]))
{
Mission mission = new Mission(soldierArgs[index], soldierArgs[index + 1]);
commando.Missions.Add(mission);
}
}
}
static void Main(string[] args)
{
List <Soldier> army = new List <Soldier>();
string input;
while ((input = Console.ReadLine()) != "End")
{
string[] soldierArgs = input.Split();
string division = soldierArgs[0];
switch (division)
{
case "Private":
Private privateSoldier =
new Private(soldierArgs[1], soldierArgs[2], soldierArgs[3], decimal.Parse(soldierArgs[4]));
army.Add(privateSoldier);
break;
case "LeutenantGeneral":
LeutenantGeneral leutenantGeneral
= new LeutenantGeneral(soldierArgs[1], soldierArgs[2], soldierArgs[3], decimal.Parse(soldierArgs[4]));
army.Add(leutenantGeneral);
GetPrivatesForLeutenantGeneral(leutenantGeneral, army, soldierArgs);
break;
case "Engineer":
if (IsValidCorps(soldierArgs[5]))
{
Engineer engineer
= new Engineer(soldierArgs[1], soldierArgs[2], soldierArgs[3], decimal.Parse(soldierArgs[4]), soldierArgs[5]);
army.Add(engineer);
GetRepairForEngineer(engineer, soldierArgs);
}
break;
case "Commando":
if (IsValidCorps(soldierArgs[5]))
{
Commando commando
= new Commando(soldierArgs[1], soldierArgs[2], soldierArgs[3], decimal.Parse(soldierArgs[4]), soldierArgs[5]);
army.Add(commando);
GetMissionsForCommando(commando, soldierArgs);
}
break;
case "Spy":
Spy spy = new Spy(soldierArgs[1], soldierArgs[2], soldierArgs[3], int.Parse(soldierArgs[4]));
army.Add(spy);
break;
default: break;
}
}
army.ForEach(soldier => Console.WriteLine(soldier));
}
private Commando CreateCommando(string[] soldierParams)
{
//Commando <id> <firstName> <lastName> <salary> <corps> <mission1CodeName> <mission1state> … <missionNCodeName> <missionNstate>"
string id = soldierParams[0];
string firstName = soldierParams[1];
string lastName = soldierParams[2];
decimal salary = decimal.Parse(soldierParams[3]);
string corpsAsString = soldierParams[4];
CorpsEnum corps;
if (corpsAsString == "Airforces")
{
corps = CorpsEnum.Airforces;
}
else if (corpsAsString == "Marines")
{
corps = CorpsEnum.Marines;
}
else
{
throw new InvalidCastException(INVALID_CORPS_MSG);
}
Commando commando = new Commando(id, firstName, lastName, salary, corps);
for (int i = 5; i < soldierParams.Length; i += 2)
{
string missionName = soldierParams[i];
string missionStateAsString = soldierParams[i + 1];
MissionStateEnum missionState;
if (missionStateAsString == "inProgress")
{
missionState = MissionStateEnum.inProgress;
}
else if (missionStateAsString == "Finished")
{
missionState = MissionStateEnum.Finished;
}
else
{
missionState = MissionStateEnum.Invalid;
}
if (missionState == MissionStateEnum.inProgress || missionState == MissionStateEnum.Finished)
{
commando.AddMission(missionName, missionState);
}
}
return(commando);
}
public void Run()
{
string soldierInput = this.reader.ReadLine();
while (soldierInput.ToLower() != "end")
{
string[] soldierArgs = soldierInput.Split(' ').ToArray();
string soldierType = soldierArgs[0];
string[] soldierParams = soldierArgs.Skip(1).ToArray();
try
{
if (soldierType == "Private")
{
Private newPrivate = CreatePrivate(soldierParams);
soldiers.Add(newPrivate);
}
else if (soldierType == "LieutenantGeneral")
{
LieutenantGeneral lieutenantGeneral = CreateLieutenantGeneral(soldierParams);
soldiers.Add(lieutenantGeneral);
}
else if (soldierType == "Engineer")
{
Engineer engineer = CreateEngineer(soldierParams);
soldiers.Add(engineer);
}
else if (soldierType == "Commando")
{
Commando commando = CreateCommando(soldierParams);
soldiers.Add(commando);
}
else if (soldierType == "Spy")
{
Spy spy = CreateSpy(soldierParams);
soldiers.Add(spy);
}
}
catch (InvalidCastException)
{
}
soldierInput = this.reader.ReadLine();
}
foreach (Soldier soldier in soldiers)
{
this.writer.WriteLine(soldier.ToString());
}
}
private static void GetMissions(string[] tokens, Commando commando)
{
for (int i = 6; i < tokens.Length; i += 2)
{
try
{
Mission mission = new Mission(tokens[i], tokens[i + 1]);
commando.Missions.Add(mission);
}
catch (ArgumentException)
{
continue;
}
}
}
private static void SaveCommando(string[] inputParts)
{
try
{
string corp = inputParts[5];
List <IMission> missions = SaveMissions(inputParts);
ICommando commando = new Commando(int.Parse(inputParts[1]), inputParts[2], inputParts[3], double.Parse(inputParts[4]), corp, missions);
soldiers.Add(commando);
}
catch (Exception ex)
{
// Log exception
return;
}
}
private void CommandoCreator(string[] inputArr)
{
string id = inputArr[1];
string firstName = inputArr[2];
string lastName = inputArr[3];
decimal salary = decimal.Parse(inputArr[4]);
string corps = inputArr[5];
var commando = new Commando(id, firstName, lastName, corps, salary);
for (int i = 6; i < inputArr.Length; i += 2)
{
commando.AddMissions(inputArr[i], inputArr[i + 1]);
}
soldiersList.Add(commando);
}
static void Main(string[] args)
{
string command;
var allSoldiers = new List <Soldier>();
while ((command = Console.ReadLine()) != "End")
{
var cmdArgs = command.Split();
var soldierType = cmdArgs[0];
switch (soldierType)
{
case "Private":
var privateS = new Private(cmdArgs[1], cmdArgs[2], cmdArgs[3], decimal.Parse(cmdArgs[4]));
allSoldiers.Add(privateS);
break;
case "LieutenantGeneral":
var lieutenantGeneral = new LieutenantGeneral(cmdArgs[1], cmdArgs[2], cmdArgs[3], decimal.Parse(cmdArgs[4]));
lieutenantGeneral.GetPrivates(cmdArgs, allSoldiers);
allSoldiers.Add(lieutenantGeneral);
break;
case "Engineer":
var engineer = new Engineer();
engineer.ReadEngineer(cmdArgs, allSoldiers);
break;
case "Commando":
var commando = new Commando();
commando.ReadCommando(cmdArgs, allSoldiers);
break;
case "Spy":
var spy = new Spy(cmdArgs[1], cmdArgs[2], cmdArgs[3], int.Parse(cmdArgs[4]));
allSoldiers.Add(spy);
break;
default:
break;
}
}
Console.WriteLine(String.Join(Environment.NewLine, allSoldiers));
}
private static void CreateCommando(string[] tokens, int id, string firstName, string lastName, decimal salary, string corp)
{
if (IsValidCorp(corp))
{
List <IMission> missions = new List <IMission>();
for (int i = 6; i < tokens.Length; i += 2)
{
string missionName = tokens[i];
string missionState = tokens[i + 1];
if (IsValidMission(missionState))
{
Mission mission = new Mission(missionName, missionState);
missions.Add(mission);
}
}
Commando commando = new Commando(id, firstName, lastName, salary, corp, missions);
Console.WriteLine(commando.ToString());
}
}
private static void AddCommandoToList(List <Soldier> soldiers, string[] soldierData)
{
GetIdNameAndSalary(soldierData, out int id, out string firstName, out string lastName, out double salary);
string corps = soldierData[5];
var missions = new List <Mission>();
for (int i = 6; i < soldierData.Length; i += 2)
{
string codeName = soldierData[i];
string state = soldierData[i + 1];
if (!IsValidMission(state))
{
continue;
}
var mission = new Mission(codeName, state);
missions.Add(mission);
}
var commando = new Commando(id, firstName, lastName, salary, corps, missions);
soldiers.Add(commando);
}
private static Commando CreateCommando(string[] inputArgs, int id, string firstName, string lastName)
{
if (VerifyCorps(inputArgs, out Corps corps))
{
var salary = decimal.Parse(inputArgs[4]);
var missionsArgs = inputArgs.Skip(6).ToArray();
Commando commando = new Commando(id, firstName, lastName, salary, corps);
for (int i = 0; i < missionsArgs.Length; i += 2)
{
var codeName = missionsArgs[i];
var state = missionsArgs[i + 1];
if (state == "inProgress" || state == "Finished")
{
Mission mission = new Mission(codeName, state);
commando.Missions.Add(mission);
}
}
return(commando);
}
return(null);
}
public static void AddCommando(List <Soldier> soldiers, string[] commandArray)
{
try
{
Commando commando = new Commando(commandArray[1], commandArray[2], commandArray[3], decimal.Parse(commandArray[4]), commandArray[5]);
for (int i = 6; i < commandArray.Length; i += 2)
{
try
{
Mission mission = new Mission(commandArray[i], commandArray[i + 1]);
commando.Missions.Add(mission);
}
catch (ArgumentException)
{
}
}
soldiers.Add(commando);
}
catch (ArgumentException)
{
}
}
private static void AddCommando(string[] tokens)
{
try
{
Commando commando = new Commando(tokens[1], tokens[2], tokens[3], double.Parse(tokens[4]), tokens[5]);
for (int i = 6; i < tokens.Length; i += 2)
{
try
{
Mission mission = new Mission(tokens[i], tokens[i + 1]);
commando.AddMission(mission);
}
catch (ArgumentException)
{
}
}
soldiers.Add(commando);
}
catch (ArgumentException)
{
}
}
static void Main(string[] args)
{
List <ISoldier> list = new List <ISoldier>();
List <Private> privates = new List <Private>();
string[] input = Console.ReadLine().Split();
while (input[0] != "End")
{
string soldier = input[0];
string id = input[1];
string firstName = input[2];
string lastName = input[3];
switch (soldier)
{
case "Private":
decimal salary = decimal.Parse(input[4]);
Private privat = new Private(id, firstName, lastName, salary);
privates.Add(privat);
list.Add(privat);
break;
case "LieutenantGeneral":
decimal salaryLieut = decimal.Parse(input[4]);
LieutenantGeneral lieutenantGeneral = new LieutenantGeneral(id, firstName, lastName, salaryLieut);
string[] privatesIds = input.Skip(5).ToArray();
for (int i = 0; i < privatesIds.Length; i++)
{
foreach (var privateSoldier in privates)
{
if (privateSoldier.Id == privatesIds[i])
{
lieutenantGeneral.AddPrivate(privateSoldier);
}
}
}
list.Add(lieutenantGeneral);
break;
case "Engineer":
string corps = input[5];
if (corps == "Airforces" || corps == "Marines")
{
decimal salaryEngi = decimal.Parse(input[4]);
Engineer engineer = new Engineer(id, firstName, lastName, salaryEngi, corps);
string[] repairs = input.Skip(6).ToArray();
for (int i = 0; i < repairs.Length; i += 2)
{
string partName = repairs[i];
int workedHours = int.Parse(repairs[i + 1]);
Repair repair = new Repair(partName, workedHours);
engineer.AddRepair(repair);
}
list.Add(engineer);
}
break;
case "Commando":
string corpsComm = input[5];
if (corpsComm == "Airforces" || corpsComm == "Marines")
{
decimal salaryComm = decimal.Parse(input[4]);
Commando commando = new Commando(id, firstName, lastName, salaryComm, corpsComm);
string[] missions = input.Skip(6).ToArray();
for (int i = 0; i < missions.Length; i += 2)
{
string codeName = missions[i];
string state = missions[i + 1];
if (state == "inProgress" || state == "Finished")
{
Mission mission = new Mission(codeName, state);
commando.Missions.Add(mission);
}
}
list.Add(commando);
}
break;
case "Spy":
int codeNumber = int.Parse(input[4]);
Spy spy = new Spy(id, firstName, lastName, codeNumber);
list.Add(spy);
break;
}
input = Console.ReadLine().Split();
}
foreach (var soldier in list)
{
Console.WriteLine(soldier);
}
}
static void Main(string[] args)
{
List <Private> privates = new List <Private>();
while (true)
{
try
{
string[] soldierArgs = Console.ReadLine().Split();
string type = soldierArgs[0];
if (type == "End")
{
break;
}
string id = soldierArgs[1];
string firstName = soldierArgs[2];
string lastName = soldierArgs[3];
if (type == "Spy")
{
int codeNumber = int.Parse(soldierArgs[4]);
var spy = new Spy(id, firstName, lastName, codeNumber);
Console.WriteLine(spy);
}
else
{
decimal salary = decimal.Parse(soldierArgs[4]);
if (type == "Private")
{
var @private = new Private(id, firstName, lastName, salary);
privates.Add(@private);
Console.WriteLine(@private);
}
else if (type == "LieutenantGeneral")
{
var privatesGeneral = new List <Private>();
for (int i = 5; i < soldierArgs.Length; i++)
{
var currentPrivate = privates.FirstOrDefault(x => x.Id == soldierArgs[i]);
privatesGeneral.Add(currentPrivate);
}
var leutenant = new LieutenantGeneral(id, firstName, lastName, salary, privatesGeneral);
Console.WriteLine(leutenant);
}
else if (type == "Engineer")
{
var repairs = new List <Repair>();
string corps = soldierArgs[5];
for (int i = 6; i < soldierArgs.Length; i += 2)
{
string name = soldierArgs[i];
int hours = int.Parse(soldierArgs[i + 1]);
var repair = new Repair(name, hours);
repairs.Add(repair);
}
var engineer = new Engineer(id, firstName, lastName, salary, corps, repairs);
Console.WriteLine(engineer);
}
else if (type == "Commando")
{
var missions = new List <Mission>();
string corps = soldierArgs[5];
for (int i = 6; i < soldierArgs.Length; i += 2)
{
try
{
string name = soldierArgs[i];
string state = soldierArgs[i + 1];
var mission = new Mission(name, state);
missions.Add(mission);
}
catch (Exception)
{
}
}
var commando = new Commando(id, firstName, lastName, salary, corps, missions);
Console.WriteLine(commando);
}
}
}
catch (Exception)
{
}
}
}
public static void Main()
{
List <Soldier> soldiers = new List <Soldier>();
string userInput = Console.ReadLine();
while (userInput != "End")
{
string[] soldierInfo = userInput.Split(" ");
string soldierType = soldierInfo[0];
int id = int.Parse(soldierInfo[1]);
string firstName = soldierInfo[2];
string lastName = soldierInfo[3];
decimal salary;
bool isSalary = decimal.TryParse(soldierInfo[4], out salary);
Soldier newSoldier;
switch (soldierType)
{
case "Private":
newSoldier = new Private(id, firstName, lastName, salary);
soldiers.Add(newSoldier);
break;
case "LieutenantGeneral":
int[] privatesToAddIds = soldierInfo.Skip(5).Select(int.Parse).ToArray();
List <Private> privates = GetPrivates(privatesToAddIds, soldiers);
newSoldier = new LieutenantGeneral(id, firstName, lastName, salary, privates);
soldiers.Add(newSoldier);
break;
case "Spy":
int codeNumber = int.Parse(soldierInfo[4]);
Spy newSpy = new Spy(id, firstName, lastName, codeNumber);
soldiers.Add(newSpy);
break;
case "Engineer":
string corps = soldierInfo[5];
List <Repair> repairs = GetRepairs(soldierInfo);
try
{
Engineer newEngineer = new Engineer(id, firstName, lastName, salary, corps, repairs);
soldiers.Add(newEngineer);
}
catch
{
userInput = Console.ReadLine();
continue;
}
break;
case "Commando":
string commandoCorps = soldierInfo[5];
List <Mission> missions = GetMissions(soldierInfo);
Commando newCommando = new Commando(id, firstName, lastName, salary, commandoCorps, missions);
soldiers.Add(newCommando);
break;
}
userInput = Console.ReadLine();
}
Console.WriteLine($"{string.Join(Environment.NewLine, soldiers)}");
}
static void Main(string[] args)
{
string input = Console.ReadLine();
while (input != "End")
{
string[] splitted = input.Split();
string soldierType = splitted[0];
int id = int.Parse(splitted[1]);
string firstName = splitted[2];
string lastName = splitted[3];
decimal salary = decimal.Parse(splitted[4]);
ISoldier soldier = null;
try
{
switch (soldierType)
{
case "Private":
soldier = new Private(id, firstName, lastName, salary);
break;
case "Spy":
soldier = new Spy(id, firstName, lastName, int.Parse(splitted[4]));
break;
case "LieutenantGeneral":
LieutenantGeneral lieutenant = new LieutenantGeneral(id, firstName, lastName, salary);
for (int i = 5; i < splitted.Length; i++)
{
int privateId = int.Parse(splitted[i]);
ISoldier currentPrivate = soldiers
.FirstOrDefault(s => s.Id == privateId);
lieutenant.AddPrivate(currentPrivate);
}
soldier = lieutenant;
break;
case "Engineer":
string engineerCorps = splitted[5];
Engineer engineer = new Engineer(id, firstName, lastName, salary, engineerCorps);
for (int i = 6; i < splitted.Length; i += 2)
{
string repairPart = splitted[i];
int repairHours = int.Parse(splitted[i + 1]);
IRepair repair = new Repair(repairPart, repairHours);
engineer.AddRepair(repair);
}
soldier = engineer;
break;
case "Commando":
string commandoCorps = splitted[5];
Commando commando = new Commando(id, firstName, lastName, salary, commandoCorps);
for (int i = 6; i < splitted.Length; i += 2)
{
string missionCodeName = splitted[i];
string missionState = splitted[i + 1];
try
{
IMission mission = new Mission(missionCodeName, missionState);
commando.AddMission(mission);
}
catch (ArgumentException) { }
}
soldier = commando;
break;
default:
throw new ArgumentException("Invalid soldier type!");
}
soldiers.Add(soldier);
}
catch (ArgumentException) { }
input = Console.ReadLine();
}
foreach (var soldier in soldiers)
{
Console.WriteLine(soldier);
}
}
public void Run()
{
while (true)
{
string input = Console.ReadLine();
if (input == "End")
{
break;
}
string[] tokens = input.Split();
string type = tokens[0];
if (type == "Private")
{
string id = tokens[1];
string firstName = tokens[2];
string lastName = tokens[3];
double salary = double.Parse(tokens[4]);
Private priva = new Private(id, firstName, lastName, salary);
privates.Add(priva);
Console.WriteLine(priva);
}
else if (type == "Spy")
{
Spy spy = new Spy(tokens[1], tokens[2], tokens[3],int.Parse(tokens[4]));
Console.WriteLine(spy);
}
else if (type == "LieutenantGeneral")
{
LeutenantGeneral lg = new LeutenantGeneral(tokens[1], tokens[2],
tokens[3], double.Parse(tokens[4]));
if (tokens.Length > 5)
{
for (int i = 5; i < tokens.Length; i++)
{
foreach (var item in privates)
{
if (item.Id == tokens[i])
{
lg.Privates.Add(item);
}
}
}
}
Console.WriteLine(lg);
}
else if (type == "Engineer")
{
Engineer engineer = new Engineer(tokens[1], tokens[2],tokens[3], double.Parse(tokens[4]), tokens[5]);
if (tokens.Length > 6)
{
for (int i = 6; i < tokens.Length; i += 2)
{
string part = tokens[i];
int hours = int.Parse(tokens[i + 1]);
Repair repair = new Repair(part, hours);
engineer.Repairs.Add(repair);
}
}
Console.WriteLine(engineer);
}
else if (type == "Commando")
{
Commando commando = new Commando(tokens[1], tokens[2],
tokens[3], double.Parse(tokens[4]), tokens[5]);
if (tokens.Length > 6)
{
for (int i = 6; i < tokens.Length; i += 2)
{
string codeName = tokens[i];
string state = tokens[i + 1];
Mission mission = new Mission(codeName, state);
commando.Missions.Add(mission);
}
}
Console.WriteLine(commando);
}
}
}
public void Run()
{
string line = Console.ReadLine();
while (line != "End")
{
string[] args = line.Split(" ", StringSplitOptions.RemoveEmptyEntries);
string type = args[0];
try
{
switch (type)
{
case "Private":
Private privateSoldier = this.privateFactory.MakePrivateSoldier(args);
this.soldiers.Add(privateSoldier);
break;
case "LieutenantGeneral":
LieutenantGeneral lieutenantGeneral =
this.lieutenantGeneralFactory.MakeLieutenantGeneral(args);
for (int i = 5; i < args.Length; i++)
{
Private currentPrivate =
(Private)this.soldiers.FirstOrDefault(p => p.Id == int.Parse(args[i]));
lieutenantGeneral.AddPrivate(currentPrivate);
}
this.soldiers.Add(lieutenantGeneral);
break;
case "Engineer":
Engineer engineer = this.engineerFactory.MakeEngineer(args);
for (int i = 6; i < args.Length; i += 2)
{
string name = args[i];
int hours = int.Parse(args[i + 1]);
Repair repair = this.repairFactory.MakeRepair(name, hours);
engineer.AddRepair(repair);
}
this.soldiers.Add(engineer);
break;
case "Commando":
Commando commando = this.commandoFactory.MakeCommando(args);
for (int i = 6; i < args.Length; i += 2)
{
string name = args[i];
string state = args[i + 1];
Mission mission = this.missionFactory.MakeMission(name, state);
commando.AddMission(mission);
}
this.soldiers.Add(commando);
break;
case "Spy":
Spy spy = this.spyFactory.MakeSpy(args);
this.soldiers.Add(spy);
break;
default:
break;
}
}
catch (Exception)
{
}
line = Console.ReadLine();
}
foreach (var soldier in this.soldiers)
{
Console.WriteLine(soldier.ToString());
}
}
public static void Main(string[] args)
{
Dictionary <string, ISoldier> soldiersById = new Dictionary <string, ISoldier>();
while (true)
{
string line = Console.ReadLine();
if (line == "End")
{
break;
}
string[] parts = line.Split();
string type = parts[0];
string id = parts[1];
string firstName = parts[2];
string lastName = parts[3];
if (type == nameof(Private))
{
decimal salary = decimal.Parse(parts[4]);
soldiersById[id] = new Private(id, firstName, lastName, salary);
}
else if (type == nameof(LieutenantGeneral))
{
decimal salary = decimal.Parse(parts[4]);
ILieutenantGeneral lieutenantGeneral = new LieutenantGeneral(id, firstName, lastName, salary);
for (int i = 5; i < parts.Length; i++)
{
string privateId = parts[i];
if (!soldiersById.ContainsKey(privateId))
{
continue;
}
lieutenantGeneral.AddPrivate((IPrivate)soldiersById[privateId]);
}
soldiersById[id] = lieutenantGeneral;
}
else if (type == nameof(Engineer))
{
decimal salary = decimal.Parse(parts[4]);
bool isCorpsValid = Enum.TryParse(parts[5], out Corps corps);
if (!isCorpsValid)
{
continue;
}
IEngineer engineer = new Engineer(id, firstName, lastName, salary, corps);
for (int i = 6; i < parts.Length; i += 2)
{
string part = parts[i];
int hoursWorked = int.Parse(parts[i + 1]);
IRepair repair = new Repair(part, hoursWorked);
engineer.AddRepair(repair);
}
soldiersById[id] = engineer;
}
else if (type == nameof(Commando))
{
decimal salary = decimal.Parse(parts[4]);
bool isCorpsValid = Enum.TryParse(parts[5], out Corps corps);
if (!isCorpsValid)
{
continue;
}
ICommando commando = new Commando(id, firstName, lastName, salary, corps);
for (int i = 6; i < parts.Length; i += 2)
{
string codeName = parts[i];
string state = parts[i + 1];
bool isMissionValid = Enum.TryParse(state, out MissionState missionState);
if (!isMissionValid)
{
continue;
}
IMission mission = new Mission(codeName, missionState);
commando.AddMission(mission);
}
soldiersById[id] = commando;
}
else if (type == nameof(Spy))
{
int codeNumber = int.Parse(parts[4]);
ISpy spy = new Spy(id, firstName, lastName, codeNumber);
soldiersById[id] = spy;
}
}
foreach (var soldier in soldiersById.Values)
{
Console.WriteLine(soldier);
}
}
static void Main()
{
var privates = new Dictionary <string, Private>();
string input;
while ((input = Console.ReadLine()) != "End")
{
var cmdArgs = input.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var soldierType = cmdArgs[0];
string id;
string firstName;
string lastName;
decimal salary;
Corps corps;
switch (soldierType)
{
case "Private":
id = cmdArgs[1];
firstName = cmdArgs[2];
lastName = cmdArgs[3];
salary = decimal.Parse(cmdArgs[4]);
var privateSoldier = new Private(firstName, lastName, id, salary);
privates.Add(id, privateSoldier);
Console.WriteLine(privateSoldier);
break;
case "LieutenantGeneral":
id = cmdArgs[1];
firstName = cmdArgs[2];
lastName = cmdArgs[3];
salary = decimal.Parse(cmdArgs[4]);
var leutenantGeneral = new LieutenantGeneral(firstName, lastName, id, salary);
if (cmdArgs.Length >= 5)
{
for (var i = 5; i < cmdArgs.Length; i++)
{
string privateId = cmdArgs[i];
privateSoldier = privates[privateId];
leutenantGeneral.Privates.Add(privateSoldier);
}
}
Console.WriteLine(leutenantGeneral);
break;
case "Engineer":
id = cmdArgs[1];
firstName = cmdArgs[2];
lastName = cmdArgs[3];
salary = decimal.Parse(cmdArgs[4]);
if (Enum.TryParse(cmdArgs[5], out corps))
{
var engineer = new Engineer(firstName, lastName, id);
if (cmdArgs.Length >= 6)
{
for (var i = 6; i < cmdArgs.Length; i += 2)
{
var repairPartName = cmdArgs[i];
var repairHours = int.Parse(cmdArgs[i + 1]);
var repair = new Repair(repairPartName, repairHours);
engineer.Repairs.Add(repair);
}
}
Console.WriteLine(engineer);
}
break;
case "Commando":
id = cmdArgs[1];
firstName = cmdArgs[2];
lastName = cmdArgs[3];
salary = decimal.Parse(cmdArgs[4]);
if (Enum.TryParse(cmdArgs[5], out corps))
{
Commando commando = new Commando(firstName, lastName, id, salary, corps);
if (cmdArgs.Length > 6)
{
for (var i = 6; i < cmdArgs.Length; i += 2)
{
if (Enum.TryParse(cmdArgs[i + 1], out MissionState missionState))
{
var missionName = cmdArgs[i];
var mission = new Mission(missionName, missionState);
commando.Missions.Add(mission);
}
}
Console.WriteLine(commando.ToString());
}
}
break;
case "Spy":
id = cmdArgs[1];
firstName = cmdArgs[2];
lastName = cmdArgs[3];
var codeNumber = int.Parse(cmdArgs[4]);
var spy = new Spy(id, firstName, lastName, codeNumber);
Console.WriteLine(spy);
break;
default:
throw new ArgumentException("Invalid Type of Soldier!");
}
}
}
