public static void Main(string[] args)
{
StorageMaster storageMaster = new StorageMaster();
Engine engine = new Engine(storageMaster);
engine.Run();
}
public static void Main()
{
StorageMaster sm = new StorageMaster();
Engine engine = new Engine(sm);
engine.Run();
}
public Engine(IReader reader, IWriter writer)
{
this.reader = reader;
this.writer = writer;
storageMaster = new StorageMaster();
isRunning = true;
}
static void Main()
{
StorageMaster storageMaster = new StorageMaster();
Engine engine = new Engine(storageMaster);
engine.Run();
}
static void Main(string[] args)
{
IReader reader = new ConsoleReader();
IWriter writer = new ConsoleWriter();
var master = new StorageMaster(reader, writer);
master.Run();
}
static void Main()
{
var storageMaster = new StorageMaster();
var inputLine = Console.ReadLine();
while (!inputLine.Equals("END"))
{
var command = inputLine.Split().First();
var args = inputLine.Split().Skip(1).ToArray();
try
{
var output = string.Empty;
switch (command)
{
case "AddProduct":
output = storageMaster.AddProduct(args[0], double.Parse(args[1]));
break;
case "RegisterStorage":
output = storageMaster.RegisterStorage(args[0], args[1]);
break;
case "SelectVehicle":
output = storageMaster.SelectVehicle(args[0], int.Parse(args[1]));
break;
case "LoadVehicle":
output = storageMaster.LoadVehicle(args);
break;
case "SendVehicleTo":
output = storageMaster.SendVehicleTo(args[0], int.Parse(args[1]), args[2]);
break;
case "UnloadVehicle":
output = storageMaster.UnloadVehicle(args[0], int.Parse(args[1]));
break;
case "GetStorageStatus":
output = storageMaster.GetStorageStatus(args[0]);
break;
}
Console.WriteLine(output);
}
catch (Exception ex)
{
Console.WriteLine("Error: " + ex.Message);
}
inputLine = Console.ReadLine();
}
Console.WriteLine(storageMaster.GetSummary());
}
public static void Main(string[] args)
{
var master = new StorageMaster();
var input = Console.ReadLine();
while (input != "END")
{
var tokens = input
.Split(" ", StringSplitOptions.RemoveEmptyEntries);
var type = tokens[0];
try
{
switch (type)
{
case "AddProduct":
Console.WriteLine(master.AddProduct(tokens[1], double.Parse(tokens[2])));
break;
case "RegisterStorage":
Console.WriteLine(master.RegisterStorage(tokens[1], tokens[2]));
break;
case "SelectVehicle":
Console.WriteLine(master.SelectVehicle(tokens[1], int.Parse(tokens[2])));
break;
case "LoadVehicle":
Console.WriteLine(master.LoadVehicle(tokens.Skip(1)));
break;
case "SendVehicleTo":
Console.WriteLine(master.SendVehicleTo(tokens[1], int.Parse(tokens[2]), tokens[3]));
break;
case "UnloadVehicle":
Console.WriteLine(master.UnloadVehicle(tokens[1], int.Parse(tokens[2])));
break;
case "GetStorageStatus":
Console.WriteLine(master.GetStorageStatus(tokens[1]));
break;
}
}
catch (InvalidOperationException ioe)
{
Console.WriteLine("Error: " + ioe.Message);
}
input = Console.ReadLine();
}
Console.WriteLine(master.GetSummary());
}
public static void Main(string[] args)
{
var input = Console.ReadLine();
var storageMaster = new StorageMaster();
var output = "";
while (input != "END")
{
var line = input.Split();
var cmd = line[0];
try
{
if (cmd == "AddProduct")
{
output = storageMaster.AddProduct(line[1], double.Parse(line[2]));
}
if (cmd == "RegisterStorage")
{
output = storageMaster.RegisterStorage(line[1], line[2]);
}
if (cmd == "SelectVehicle")
{
output = storageMaster.SelectVehicle(line[1], int.Parse(line[2]));
}
if (cmd == "LoadVehicle")
{
output = storageMaster.LoadVehicle(line.Skip(1));
}
if (cmd == "SendVehicleTo")
{
output = storageMaster.SendVehicleTo(line[1], int.Parse(line[2]), line[3]);
}
if (cmd == "UnloadVehicle")
{
output = storageMaster.UnloadVehicle(line[1], int.Parse(line[2]));
}
if (cmd == "GetStorageStatus")
{
output = storageMaster.GetStorageStatus(line[1]);
}
}
catch (InvalidOperationException ex)
{
output = "Error: " + ex.Message;
}
Console.WriteLine(output);
input = Console.ReadLine();
}
output = storageMaster.GetSummary();
Console.WriteLine(output);
}
public static void Main(string[] args)
{
var storageMaster = new StorageMaster();
string line;
while ((line = Console.ReadLine()) != "END")
{
var tokens = line.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries).ToList();
var command = tokens[0];
var result = string.Empty;
tokens = tokens.Skip(1).ToList();
try
{
switch (command)
{
case "AddProduct":
result = storageMaster.AddProduct(tokens[0], double.Parse(tokens[1]));
break;
case "RegisterStorage":
result = storageMaster.RegisterStorage(tokens[0], tokens[1]);
break;
case "SelectVehicle":
result = storageMaster.SelectVehicle(tokens[0], int.Parse(tokens[1]));
break;
case "LoadVehicle":
result = storageMaster.LoadVehicle(tokens);
break;
case "SendVehicleTo":
result = storageMaster.SendVehicleTo(tokens[0], int.Parse(tokens[1]), tokens[2]);
break;
case "UnloadVehicle":
result = storageMaster.UnloadVehicle(tokens[0], int.Parse(tokens[1]));
break;
case "GetStorageStatus":
result = storageMaster.GetStorageStatus(tokens[0]);
break;
}
Console.WriteLine(result);
}
catch (InvalidOperationException err)
{
Console.WriteLine("Error: " + err.Message);
}
}
Console.WriteLine(storageMaster.GetSummary());
}
public static void Main()
{
var productFactory = new ProductFactory();
var storageFactory = new StorageFactory();
var storageMaster = new StorageMaster(productFactory, storageFactory);
var consoleDataReader = new ConsoleDataReader();
var consoleDataWriter = new ConsoleDataWriter();
var engine = new Engine(storageMaster, consoleDataReader, consoleDataWriter);
engine.Run();
}
static void Main(string[] args)
{
StorageMaster storageMaster = new StorageMaster();
string command;
while ((command = Console.ReadLine()) != "END")
{
string[] splittedCommand = command.Split();
try
{
switch (splittedCommand[0])
{
case "AddProduct":
Console.WriteLine(storageMaster.AddProduct(splittedCommand[1], double.Parse(splittedCommand[2])));
break;
case "RegisterStorage":
Console.WriteLine(storageMaster.RegisterStorage(splittedCommand[1], splittedCommand[2]));
break;
case "SelectVehicle":
Console.WriteLine(storageMaster.SelectVehicle(splittedCommand[1], int.Parse(splittedCommand[2])));
break;
case "LoadVehicle":
Console.WriteLine(storageMaster.LoadVehicle(splittedCommand.Skip(1)));
break;
case "SendVehicleTo":
Console.WriteLine
(storageMaster
.SendVehicleTo(splittedCommand[1], int.Parse(splittedCommand[2]), splittedCommand[3])
);
break;
case "UnloadVehicle":
Console.WriteLine(storageMaster.UnloadVehicle(splittedCommand[1], int.Parse(splittedCommand[2])));
break;
case "GetStorageStatus":
Console.WriteLine(storageMaster.GetStorageStatus(splittedCommand[1]));
break;
}
}
catch (InvalidOperationException ex)
{
Console.WriteLine("Error: " + ex.Message);
}
}
Console.WriteLine(storageMaster.GetSummary());
}
public static void Main()
{
StorageMaster sm = new StorageMaster();
while (true)
{
string[] command = Console.ReadLine().Split();
try
{
if (command[0] == "END")
{
Console.WriteLine(sm.GetSummary());
break;
}
else if (command[0] == "AddProduct")
{
Console.WriteLine(sm.AddProduct(command[1], double.Parse(command[2])));
}
else if (command[0] == "RegisterStorage")
{
Console.WriteLine(sm.RegisterStorage(command[1], command[2]));
}
else if (command[0] == "SelectVehicle")
{
Console.WriteLine(sm.SelectVehicle(command[1], int.Parse(command[2])));
}
else if (command[0] == "LoadVehicle")
{
Console.WriteLine(sm.LoadVehicle(command.Skip(1)));
}
else if (command[0] == "SendVehicleTo")
{
Console.WriteLine(sm.SendVehicleTo(command[1], int.Parse(command[2]), command[3]));
}
else if (command[0] == "UnloadVehicle")
{
Console.WriteLine(sm.UnloadVehicle(command[1], int.Parse(command[2])));
}
else if (command[0] == "GetStorageStatus")
{
Console.WriteLine(sm.GetStorageStatus(command[1]));
}
}
catch (InvalidOperationException ioe)
{
Console.WriteLine($"Error: {ioe.Message}");
}
}
}
private static void ProcessCommand(string inputLine, StorageMaster storageMaster)
{
var tokens = inputLine.Split();
var command = tokens[0];
switch (command)
{
case "AddProduct":
var type = tokens[1];
var price = double.Parse(tokens[2]);
Console.WriteLine(storageMaster.AddProduct(type, price));
break;
case "RegisterStorage":
type = tokens[1];
var name = tokens[2];
Console.WriteLine(storageMaster.RegisterStorage(type, name));
break;
case "SelectVehicle":
var storageName = tokens[1];
var garageSlot = int.Parse(tokens[2]);
Console.WriteLine(storageMaster.SelectVehicle(storageName, garageSlot));
break;
case "LoadVehicle":
var args = tokens.Skip(1).ToArray();
Console.WriteLine(storageMaster.LoadVehicle(args));
break;
case "SendVehicleTo":
var sourceName = tokens[1];
var sourceGarageSlot = int.Parse(tokens[2]);
var destinationName = tokens[3];
Console.WriteLine(storageMaster.SendVehicleTo(sourceName, sourceGarageSlot, destinationName));
break;
case "UnloadVehicle":
storageName = tokens[1];
garageSlot = int.Parse(tokens[2]);
Console.WriteLine(storageMaster.UnloadVehicle(storageName, garageSlot));
break;
case "GetStorageStatus":
storageName = tokens[1];
Console.WriteLine(storageMaster.GetStorageStatus(storageName));
break;
}
}
public void Run()
{
var storageMaster = new StorageMaster();
var inputLine = string.Empty;
while ((inputLine = Console.ReadLine()) != "END")
{
try
{
ProcessCommand(inputLine, storageMaster);
}
catch (InvalidOperationException e)
{
Console.WriteLine($"Error: {e.Message}");
}
}
Console.WriteLine(storageMaster.GetSummary());
}
public Engine(StorageMaster storage)
{
this.storage = storage;
}
public Engine(StorageMaster storageMaster)
{
this.storageMaster = storageMaster;
}
public Engine()
{
storageMaster = new StorageMaster();
}
static void Main(string[] args)
{
var storageMaster = new StorageMaster();
while (true)
{
var input = Console.ReadLine().Split(' ');
switch (input[0])
{
case "AddProduct":
string productType = input[1];
double productPrice = double.Parse(input[2]);
try
{
string result = storageMaster.AddProduct(productType, productPrice);
Console.WriteLine(result);
}
catch (Exception e)
{
PrintException(e.Message);
}
break;
case "RegisterStorage":
string storageType = input[1];
string storageName = input[2];
try
{
string result = storageMaster.RegisterStorage(storageType, storageName);
Console.WriteLine(result);
}
catch (Exception e)
{
PrintException(e.Message);
}
break;
case "SelectVehicle":
string storageToSearch = input[1];
int slot = int.Parse(input[2]);
try
{
string result = storageMaster.SelectVehicle(storageToSearch, slot);
Console.WriteLine(result);
}
catch (Exception e)
{
PrintException(e.Message);
}
break;
case "LoadVehicle":
var productsToLoad = input.Skip(1);
try
{
string result = storageMaster.LoadVehicle(productsToLoad);
Console.WriteLine(result);
}
catch (Exception e)
{
PrintException(e.Message);
}
break;
case "SendVehicleTo":
string source = input[1];
int garageSlot = int.Parse(input[2]);
string destination = input[3];
try
{
string result = storageMaster.SendVehicleTo(source, garageSlot, destination);
Console.WriteLine(result);
}
catch (Exception e)
{
PrintException(e.Message);
}
break;
case "UnloadVehicle":
string storageNameForUnloading = input[1];
int garageSlotToUnload = int.Parse(input[2]);
try
{
string result = storageMaster.UnloadVehicle(storageNameForUnloading, garageSlotToUnload);
Console.WriteLine(result);
}
catch (Exception e)
{
PrintException(e.Message);
}
break;
case "GetStorageStatus":
string statusTarget = input[1];
try
{
string result = storageMaster.GetStorageStatus(statusTarget);
Console.WriteLine(result);
}
catch (Exception e)
{
PrintException(e.Message);
}
break;
case "END":
try
{
string result = storageMaster.GetSummary();
Console.WriteLine(result);
Environment.Exit(0);
}
catch (Exception e)
{
PrintException(e.Message);
Environment.Exit(0);
}
break;
}
}
}
public Engine()
{
this.storageMaster = new StorageMaster();
}
static void Main(string[] args)
{
StorageMaster sm = new StorageMaster();
string input;
while ((input = Console.ReadLine()) != "END")
{
try
{
string[] tokens = input.Split();
switch (tokens[0])
{
case "AddProduct":
{
Console.WriteLine(sm.AddProduct(tokens[1], double.Parse(tokens[2])));
break;
}
case "RegisterStorage":
{
Console.WriteLine(sm.RegisterStorage(tokens[1], tokens[2]));
break;
}
case "SelectVehicle":
{
Console.WriteLine(sm.SelectVehicle(tokens[1], int.Parse(tokens[2])));
break;
}
case "LoadVehicle":
{
List <string> products = new List <string>();
for (int i = 1; i < tokens.Length; i++)
{
products.Add(tokens[i]);
}
Console.WriteLine(sm.LoadVehicle(products));
break;
}
case "SendVehicleTo":
{
Console.WriteLine(sm.SendVehicleTo(tokens[1], int.Parse(tokens[2]), tokens[3]));
break;
}
case "UnloadVehicle":
{
Console.WriteLine(sm.UnloadVehicle(tokens[1], int.Parse(tokens[2])));
break;
}
case "GetStorageStatus":
{
Console.WriteLine(sm.GetStorageStatus(tokens[1]));
break;
}
}
}
catch (InvalidOperationException ie)
{
Console.WriteLine($"Error: {ie.Message}");
}
}
Console.WriteLine(sm.GetSummary());
}
static void Main(string[] args)
{
var input = string.Empty;
var storageMaster = new StorageMaster();
while (input != "END")
{
input = Console.ReadLine();
var inputParams = input.Split();
var command = inputParams[0];
try
{
switch (command)
{
case "AddProduct":
var productType = inputParams[1];
var productPrice = double.Parse(inputParams[2]);
Console.WriteLine(storageMaster.AddProduct(productType, productPrice));
break;
case "RegisterStorage":
var storageType = inputParams[1];
var storageName = inputParams[2];
Console.WriteLine(storageMaster.RegisterStorage(storageType, storageName));
break;
case "SelectVehicle":
var storageN = inputParams[1];
var garageSlot = int.Parse(inputParams[2]);
Console.WriteLine(storageMaster.SelectVehicle(storageN, garageSlot));
break;
case "LoadVehicle":
var products = inputParams.Skip(1);
Console.WriteLine(storageMaster.LoadVehicle(products));
break;
case "SendVehicleTo":
var sourceName = inputParams[1];
var sourceGarageSlot = int.Parse(inputParams[2]);
var destinationName = inputParams[3];
Console.WriteLine(storageMaster.SendVehicleTo(sourceName, sourceGarageSlot, destinationName));
break;
case "UnloadVehicle":
var storageNameUnl = inputParams[1];
var gs = int.Parse(inputParams[2]);
Console.WriteLine(storageMaster.UnloadVehicle(storageNameUnl, gs));
break;
case "GetStorageStatus":
var storageStatusName = inputParams[1];
Console.WriteLine(storageMaster.GetStorageStatus(storageStatusName));
break;
case "GetSummary":
Console.WriteLine(storageMaster.GetSummary());
break;
}
}
catch (InvalidOperationException e)
{
Console.WriteLine($"Error: {e.Message}");
}
}
Console.WriteLine(storageMaster.GetSummary());
}
static void Main(string[] args)
{
var c = new StorageMaster();
while (true)
{
string[] input = Console.ReadLine().Split();
if (input[0] == "Q" || input[0] == "q" || input[0] == "exit")
{
break;
}
if (input[0] == "RegisterStorage")
{
try
{
string s = c.RegisterStorage(input[1], input[2]);
Console.WriteLine(s);
}
catch (InvalidOperationException e)
{
Console.WriteLine(e.Message);
}
}
else if (input[0] == "AddProduct")
{
try
{
string s = c.AddProduct(input[1], double.Parse(input[2]));
Console.WriteLine(s);
}
catch (InvalidOperationException e)
{
Console.WriteLine(e.Message);
}
}
else if (input[0] == "SelectVehicle")
{
try
{
string s = c.SelectVehicle(input[1], int.Parse(input[2]));
Console.WriteLine(s);
}
catch (InvalidOperationException e)
{
Console.WriteLine(e.Message);
}
}
else if (input[0] == "LoadVehicle")
{
try
{
var products = input.ToList();
products.RemoveAt(0);
string s = c.LoadVehicle(products);
Console.WriteLine(s);
}
catch (InvalidOperationException e)
{
Console.WriteLine(e.Message);
}
}
else if (input[0] == "SendVehicleTo")
{
try
{
string s = c.SendVehicleTo(input[1], int.Parse(input[2]), input[3]);
Console.WriteLine(s);
}
catch (InvalidOperationException e)
{
Console.WriteLine(e.Message);
}
}
else if (input[0] == "UnloadVehicle")
{
try
{
string s = c.UnloadVehicle(input[1], int.Parse(input[2]));
Console.WriteLine(s);
}
catch (InvalidOperationException e)
{
Console.WriteLine(e.Message);
}
}
else if (input[0] == "GetSummary")
{
try
{
string s = c.GetSummary();
Console.WriteLine(s);
}
catch (InvalidOperationException e)
{
Console.WriteLine(e.Message);
}
}
}
}
static void Main(string[] args)
{
StorageMaster storageMaster = new StorageMaster();
string inputLine;
StringBuilder sb = new StringBuilder();
while ((inputLine = Console.ReadLine()) != END)
{
List <string> collection = inputLine.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();
string command = collection[0];
collection.RemoveAt(0);
try
{
switch (command)
{
case ADD_PRODUCT:
sb.AppendLine(storageMaster.AddProduct(collection[0], double.Parse(collection[1])).Trim());
break;
case REGISTERS_TORAGE:
sb.AppendLine(storageMaster.RegisterStorage(collection[0], collection[1]).Trim());
break;
case SELECT_VEHICLE:
sb.AppendLine(storageMaster.SelectVehicle(collection[0], int.Parse(collection[1])).Trim());
break;
case LOAD_VEHICLE:
sb.AppendLine(storageMaster.LoadVehicle(collection).Trim());
break;
case SEND_VEHICLE_TO:
sb.AppendLine(storageMaster.SendVehicleTo(collection[0], int.Parse(collection[1]), collection[2]).Trim());
break;
case UNLOAD_VEHICLE:
sb.AppendLine(storageMaster.UnloadVehicle(collection[0], int.Parse(collection[1])).Trim());
break;
case GET_STORAGE_STATUS:
sb.AppendLine(storageMaster.GetStorageStatus(collection[0]).Trim());
break;
default:
throw new EntryPointNotFoundException(Messages.InvalidInputCommand);
}
}
catch (InvalidOperationException m)
{
sb.AppendLine(string.Format(Messages.Error, m.Message).Trim());
}
}
sb.AppendLine(storageMaster.GetSummary());
Console.WriteLine(sb.ToString().TrimEnd());
}
