public SystemManager()
{
this.hardwareFactory = new HardwareFactory();
this.softwareFactory = new SoftwareFactory();
this.hardwares = new Dictionary <string, Hardware>();
this.dump = new Dump();
}
public Engine()
{
this.hardwareComponents = new List <IComponentHardware>();
hardwareFactory = new HardwareFactory();
softwareFactory = new SoftwareFactory();
newMachine = new Machine();
}
protected Command(Data data, string[] input, HardwareFactory hardwareFactory, SoftwareFactory softwareFactory)
{
this.input = input;
this.data = data;
this.hardwareFactory = hardwareFactory;
this.softwareFactory = softwareFactory;
}
protected Command(Data data, string[] input, HardwareFactory hardwareFactory, SoftwareFactory softwareFactory)
{
this.input = input;
this.data = data;
this.hardwareFactory = hardwareFactory;
this.softwareFactory = softwareFactory;
}
public CommandInterpreter
(OutputWriter writer, SystemRepository systemRepository, HardwareFactory hardwareFactory, SoftwareFactory softwareFactory)
{
this.writer = writer;
this.systemRepository = systemRepository;
this.hardwareFactory = hardwareFactory;
this.softwareFactory = softwareFactory;
}
public EnhancedCommandInterpreter
(OutputWriter writer,
SystemRepository systemRepository,
DumpRepository dumpRepository,
HardwareFactory hardwareFactory,
SoftwareFactory softwareFactory)
: base(writer, systemRepository, hardwareFactory, softwareFactory)
{
this.dumpRepository = dumpRepository;
}
public void RegisterSoftware(string[] tokens)
{
var softFactory = new SoftwareFactory();
var software = softFactory.Create(tokens);
var hardwareName = tokens[1];
var hardware = this.allHardwares.FirstOrDefault(h => h.Name == hardwareName);
ExeptionTracker.IsValidHardware(hardware);
hardware.ImplementSoftware(software);
}
static void Main()
{
InputReader reader = new InputReader();
OutputWriter writer = new OutputWriter();
SoftwareFactory softwareFactory = new SoftwareFactory();
HardwareFactory hardwareFactory = new HardwareFactory();
SystemRepository systemRepository = new SystemRepository();
DumpRepository dumpRepository = new DumpRepository();
Engine engine = new Engine(reader, writer, systemRepository, dumpRepository, hardwareFactory, softwareFactory);
engine.Run();
}
private static void AddSoftware(List <HardwareComponent> hardware, List <string> input)
{
SoftwareComponent currentSoftwareComponent = SoftwareFactory.CreateSoftware(input);
if (hardware.Any(h => h.Name == currentSoftwareComponent.HardwareComponent))
{
var currenthardComponent = hardware.First(h => h.Name == currentSoftwareComponent.HardwareComponent);
if (currenthardComponent.CanTakeSoftware(currentSoftwareComponent))
{
currenthardComponent.AddSoftwareComponent(currentSoftwareComponent);
}
}
}
public Engine
(InputReader reader,
OutputWriter writer,
SystemRepository systemRepository,
DumpRepository dumpRepository,
HardwareFactory hardwareFactory,
SoftwareFactory softwareFactory)
{
this.reader = reader;
this.writer = writer;
this.systemRepository = systemRepository;
this.dumpRepository = dumpRepository;
this.hardwareFactory = hardwareFactory;
this.softwareFactory = softwareFactory;
this.interpreter =
new EnhancedCommandInterpreter
(this.writer, this.systemRepository, this.dumpRepository, this.hardwareFactory, this.softwareFactory);
}
static void Main(string[] args)
{
IReader reader = new ConsoleReader();
IWriter writer = new ConsoleWriter();
var softwares = new List <ISoftware>();
var hardwares = new List <IHardware>();
var hadrwareFactory = new HardwareFactory();
var softwareFactory = new SoftwareFactory();
IController controller = new Controller(hardwares, softwares, hadrwareFactory, softwareFactory);
ICommandInterpreter commandInterpreter = new CommandInterpreter(controller);
IEngine engine = new Engine(reader, writer, commandInterpreter);
engine.Run();
}
public Command ParseCommand(Data data, string[] input, HardwareFactory hardwareFactory, SoftwareFactory softwareFactory)
{
switch (input[0])
{
case "RegisterPowerHardware": return new RegisterPowerHardware(data,input,hardwareFactory,softwareFactory);
case "RegisterHeavyHardware": return new RegisterHeavyHardware(data, input,hardwareFactory, softwareFactory);
case "RegisterExpressSoftware": return new RegisterExpressSoftware(data, input, hardwareFactory, softwareFactory);
case "RegisterLightSoftware": return new RegisterLightSoftware(data, input,hardwareFactory,softwareFactory);
case "Analyze": return new Analyze(data, input,hardwareFactory, softwareFactory);
case "ReleaseSoftwareComponent": return new ReleaseSoftwareComponent(data, input,hardwareFactory,softwareFactory);
case "System Split": return new SystemSplit(data, input,hardwareFactory, softwareFactory);
case "Dump": return new Dump(data, input, hardwareFactory, softwareFactory);
case "Restore": return new Restore(data, input, hardwareFactory, softwareFactory);
case "Destroy": return new Destroy(data, input, hardwareFactory, softwareFactory);
case "DumpAnalyze": return new DumpAnalyze(data, input, hardwareFactory, softwareFactory);
default: throw new ArgumentException(string.Format("Incorrect Comand {0}",input[0]));
}
}
static void Main()
{
string input = Console.ReadLine();
Data data=new Data();
CommandInterpreter commandHandler=new CommandInterpreter();
HardwareFactory hardwareFactory=new HardwareFactory();
SoftwareFactory softwareFactory= new SoftwareFactory();
while (true)
{
string[] inputParameters = input.Split(new[] {'(', ')', ','}, StringSplitOptions.RemoveEmptyEntries);
Command c=commandHandler.ParseCommand(data, inputParameters, hardwareFactory, softwareFactory);
c.Execute();
if (inputParameters[0].Equals("System Split"))
{
break;
}
input = Console.ReadLine();
}
}
static void Main()
{
string input = Console.ReadLine();
Data data = new Data();
CommandInterpreter commandHandler = new CommandInterpreter();
HardwareFactory hardwareFactory = new HardwareFactory();
SoftwareFactory softwareFactory = new SoftwareFactory();
while (true)
{
string[] inputParameters = input.Split(new[] { '(', ')', ',' }, StringSplitOptions.RemoveEmptyEntries);
Command c = commandHandler.ParseCommand(data, inputParameters, hardwareFactory, softwareFactory);
c.Execute();
if (inputParameters[0].Equals("System Split"))
{
break;
}
input = Console.ReadLine();
}
}
protected RegisterSoftware(Data data, string[] input, HardwareFactory hardwareFactory, SoftwareFactory softwareFactory)
: base(data, input, hardwareFactory, softwareFactory)
{
}
public Command ParseCommand(Data data, string[] input, HardwareFactory hardwareFactory, SoftwareFactory softwareFactory)
{
switch (input[0])
{
case "RegisterPowerHardware": return(new RegisterPowerHardware(data, input, hardwareFactory, softwareFactory));
case "RegisterHeavyHardware": return(new RegisterHeavyHardware(data, input, hardwareFactory, softwareFactory));
case "RegisterExpressSoftware": return(new RegisterExpressSoftware(data, input, hardwareFactory, softwareFactory));
case "RegisterLightSoftware": return(new RegisterLightSoftware(data, input, hardwareFactory, softwareFactory));
case "Analyze": return(new Analyze(data, input, hardwareFactory, softwareFactory));
case "ReleaseSoftwareComponent": return(new ReleaseSoftwareComponent(data, input, hardwareFactory, softwareFactory));
case "System Split": return(new SystemSplit(data, input, hardwareFactory, softwareFactory));
case "Dump": return(new Dump(data, input, hardwareFactory, softwareFactory));
case "Restore": return(new Restore(data, input, hardwareFactory, softwareFactory));
case "Destroy": return(new Destroy(data, input, hardwareFactory, softwareFactory));
case "DumpAnalyze": return(new DumpAnalyze(data, input, hardwareFactory, softwareFactory));
default: throw new ArgumentException(string.Format("Incorrect Comand {0}", input[0]));
}
}
public Manager()
{
this.createSoftware = new SoftwareFactory();
this.createHardware = new HardwareFactory();
this.system = new TheSystem();
}
public Restore(Data data, string[] input, HardwareFactory hardwareFactory, SoftwareFactory softwareFactory)
: base(data, input, hardwareFactory, softwareFactory)
{
}
public Dump(Data data, string[] input, HardwareFactory hardwareFactory, SoftwareFactory softwareFactory)
: base(data, input, hardwareFactory, softwareFactory)
{
}
public ReleaseSoftwareComponent(Data data, string[] input, HardwareFactory hardwareFactory, SoftwareFactory softwareFactory)
: base(data, input, hardwareFactory, softwareFactory)
{
}
public void Execute()
{
while (true)
{
string[] commandArgs = GetCommand();
string command = commandArgs[0];
switch (command)
{
case "RegisterPowerHardware":
Hardware hardware = HardwareFactory.CreateHardware("Power", commandArgs.Skip(1).ToArray());
this.hardwares.Add(hardware);
break;
case "RegisterHeavyHardware":
hardware = HardwareFactory.CreateHardware("Heavy", commandArgs.Skip(1).ToArray());
this.hardwares.Add(hardware);
break;
case "RegisterExpressSoftware":
string hardwareComponentName = commandArgs[1];
try
{
hardware = hardwares.FirstOrDefault(h => h.Name == hardwareComponentName);
Software software = SoftwareFactory.CreateSoftware("Express", commandArgs.Skip(2).ToArray());
hardware.AddSoftwareComponent(software);
softwares.Add(software);
}
catch (Exception)
{
continue;
}
break;
case "RegisterLightSoftware":
hardwareComponentName = commandArgs[1];
try
{
hardware = hardwares.FirstOrDefault(h => h.Name == hardwareComponentName);
Software software = SoftwareFactory.CreateSoftware("Light", commandArgs.Skip(2).ToArray());
hardware.AddSoftwareComponent(software);
softwares.Add(software);
}
catch (Exception)
{
continue;
}
break;
case "ReleaseSoftwareComponent":
hardwareComponentName = commandArgs[1];
string softwareComponentName = commandArgs[2];
try
{
hardware = hardwares.FirstOrDefault(h => h.Name == hardwareComponentName);
Software software = hardware.ReleaseSoftwareComponent(softwareComponentName);
softwares.Remove(software);
}
catch (Exception)
{
continue;
}
break;
case "Dump":
hardwareComponentName = commandArgs[1];
if (!hardwares.Exists(h => h.Name == hardwareComponentName))
{
continue;
}
try
{
hardware = hardwares.FirstOrDefault(h => h.Name == hardwareComponentName);
hardwares.Remove(hardware);
dump.Add(hardware);
}
catch (Exception)
{
continue;
}
break;
case "Restore":
hardwareComponentName = commandArgs[1];
if (!dump.Exists(h => h.Name == hardwareComponentName))
{
continue;
}
try
{
hardware = dump.FirstOrDefault(h => h.Name == hardwareComponentName);
dump.Remove(hardware);
hardwares.Add(hardware);
}
catch (Exception)
{
continue;
}
break;
case "Destroy":
hardwareComponentName = commandArgs[1];
if (!hardwares.Exists(h => h.Name == hardwareComponentName))
{
continue;
}
try
{
hardware = dump.FirstOrDefault(h => h.Name == hardwareComponentName);
dump.Remove(hardware);
}
catch (Exception)
{
continue;
}
break;
case "DumpAnalyze":
StringBuilder sb = new StringBuilder();
sb.Append($"Dump Analysis{Environment.NewLine}");
int countOfPowerHardwareComponents = dump.Where(c => c.GetType().Name == "Power").Count();
int countOfHeavyHardwareComponents = dump.Where(c => c.GetType().Name == "Heavy").Count();
int countOfExpressSoftwareComponents = dump.Sum(c => c.Softwares.Where(s => s.GetType().Name == "Express").Count());
int countOfLightSoftwareComponents = dump.Sum(c => c.Softwares.Where(s => s.GetType().Name == "Light").Count());;
int totalDumpedMemory = dump.Sum(c => c.TotalOperationalMemoryInUse);
int totalDumpedCapacity = dump.Sum(c => c.TotalCapacityTaken);
sb.Append($"Power Hardware Components: {countOfPowerHardwareComponents}{Environment.NewLine}");
sb.Append($"Heavy Hardware Components: {countOfHeavyHardwareComponents}{Environment.NewLine}");
sb.Append($"Express Software Components: {countOfExpressSoftwareComponents}{Environment.NewLine}");
sb.Append($"Light Software Components: {countOfLightSoftwareComponents}{Environment.NewLine}");
sb.Append($"Total Dumped Memory: {totalDumpedMemory}{Environment.NewLine}");
sb.Append($"Total Dumped Capacity: {totalDumpedCapacity}{Environment.NewLine}");
Console.Write(sb.ToString());
break;
case "Analyze":
sb = new StringBuilder();
sb.Append($"System Analysis{Environment.NewLine}");
sb.Append($"Hardware Components: {hardwares.Count}{Environment.NewLine}");
sb.Append($"Software Components: {hardwares.Sum(s => s.Softwares.Count)}{Environment.NewLine}");
int TotalOperationalMemoryInUse = hardwares.Sum(h => h.TotalOperationalMemoryInUse);
int TotalMemory = hardwares.Sum(h => h.MaximumMemory);
sb.Append($"Total Operational Memory: {TotalOperationalMemoryInUse} / {TotalMemory}{Environment.NewLine}");
int TotalCapacityTaken = hardwares.Sum(h => h.TotalCapacityTaken);
int TotalCapacity = hardwares.Sum(h => h.MaximumCapacity);
sb.Append($"Total Capacity Taken: {TotalCapacityTaken} / {TotalCapacity}");
Console.WriteLine(sb.ToString());
break;
case "System":
Console.Write(SystemInformation());
return;
}
}
}
protected RegisterSoftware(Data data, string[] input, HardwareFactory hardwareFactory, SoftwareFactory softwareFactory)
: base(data, input, hardwareFactory, softwareFactory)
{
}
public SystemSplit(Data data, string[] input, HardwareFactory hardwareFactory, SoftwareFactory softwareFactory)
: base(data, input, hardwareFactory, softwareFactory)
{
}
public ReleaseSoftwareComponent(Data data, string[] input, HardwareFactory hardwareFactory, SoftwareFactory softwareFactory)
: base(data, input, hardwareFactory, softwareFactory)
{
}
public RegisterExpressSoftware(Data data, string[] input, HardwareFactory hardwareFactory, SoftwareFactory softwareFactory)
: base(data, input, hardwareFactory, softwareFactory)
{
}
public RegisterLightSoftware(Data data, string[] input, HardwareFactory hardwareFactory, SoftwareFactory softwareFactory)
: base(data, input, hardwareFactory, softwareFactory)
{
}
public DumpAnalyze(Data data, string[] input, HardwareFactory hardwareFactory, SoftwareFactory softwareFactory)
: base(data, input, hardwareFactory, softwareFactory)
{
}
