Title: Nozama Online Author: Oluwatimilehin Dayo-Kayode Purpose: Simulate a warehouse facility using two modes; round robin and shortest time Classes: -wareHouse class: wareHouse.h, wareHouse.cpp -Orderqueue class: Orderqueue.h Orderqueue.cpp testOrderqueue.cpp -Packer class: Packer.h Packer.cpp testPacker.cpp -Retrieval class: Rertrieval.h Retrieval.cpp testRetrieval.cpp -string2int class: string2int.h string2int.cpp -Parser class: Parser.h, Parser.cpp, testParser.cpp -main: main.cpp -Order: Order.h -README *Orderqueue class* This class contains the functions required to create a queue(A sequence in this case) and interact with the queue such as enqueueing(adding orders to the queue) and dequeueing(removing completed orders from the queue). It also contains a function used to read in a list of of orders and populates a queue with them. An expand function to expand the queue, an isEmpty function that checks whether or not a queue is empty, a numOrder and currSize variable that keeps track of the number of orders in a queue and the size of the queue respectively. This class also has a test file called testOrderqueue.cpp that tests its functions. *Warehouse Class* This class creates an instance of a queue to hold a list of orders read from a file by calling on the Orderqueue class' functions. It also has an instance of a Packer and Retrieval to send current orders to the packer and to process received orders respectively. The warehouse also has a masterclock that makes time conceptually possible and enables other classes to interact with orders in respect to their individual fetch and processing times. It has a function that sends orders to the packer class depending on the method being used; round robin vs fastest time by using two helper functions. *Packer Class* This class creates an instance of a queue that holds all currently processing orders and keeps track of the number of orders currently in the packaging queue after receiving them from the retrieval queue and monitors their processing time then dequeues them once they have been completely processed/packed. It also has a tickPacker function that keeps track of how much time has elapsed once it is run. This class also has a test file called testPacker.cpp that tests its functions. *Retrieval Class* This class gets sent orders from the warehouse and acts as a placeholder by holding all the orders in its queue until their individual fetch times have elapsed and then sends them to the packer class. *Order.h* This class creates the struct definition of Order that the whole program relies on. It is the definition of the orders that are passed around the whole program. *string2int Class* This class converts strings to integers and is used when reading information about the program such as the number of packing units that the user passes into the terminal *Parser Class* This class contains two files; Parser.h and Parser.cpp that takes a file as a parameter and initializes an initializes an instance of the Order class with the values in the file. It is used to open and read in from the file that the user passes as an argumentv in the command line. *main Class* This class creates an instance of a wareHouse using its constructor and calls wareHouses' chronoKinesis function that runs the whole program. //General Implementation// My implementationn for nozama online includes using a sequence as a queue because after reading the specs, i realized that I would have to access the queue a great number of times, so I decided on sequences as my data structure of choice due to how easy it is to access different nodes in it. My nozama online program will make use of three classes and a main function to run all the classes. My proposed classes include a warehouse class, a retrieval class, an orderqueue class and a packer class along with the other classes provided. The Orderqueue class is used to create queues in the form of sequences and all both the wareHouse and Retrieval class include an instance of an Orderqueue, while the Packer contains an array of Orderqueues that serve as its packing units. The warehouse's queue holds the orders that is read from the file specified by the user, then sends all these orders to an Orderqueue in a Retrieval queue declared in the wareHouse header file. This Orderqueue holds each order until their fetch time is elapsed. Then as each order's fetch time elapses, it sends them individually to the wareHouses' instance of the Packer class which also has a queue to save these orders in. As far as implementing RoundRobin and Shortest Time goes in order to decide what packaging unit to send the order to, I made a function in my wareHouse that took in an Order, the number of packaging units and the current time, and with the help of some helper functions, decides what unit to send the order to, and then once their individual packing time elapses, calls another helper function that prints out the order details in the format specified before dequeueing them from the queue. I then call a function that checks for the condition that any and every Orderqueue in the Packer and Retrieval instances are both empty, and then once this condition is satisfied, terminates the program. For implementing the concept of time, I have an infinite loop that serves as the master clock in my warehouse and pass the current time as parameters to functions that require them to retrieve and pack. //Compiling and Running My Program// My program has a Makefile that compiles all the files used in my program by typing the keyword 'make' in the command line. My makefile also has an executable called nozama that is used to run the program, and so running the program would be; './nozama file.txt 3 XXXXXXX'. The parameters run along with the executable are the name of the file containing the orders, the number of packing units that the client wants to run the simulation with, and the mode that the simulation should be run with.