Write the definitions of the functions setWaitingTime, getArrivalTime, getTransactionTime, and getCustomerNumber of the class customerType defined in the section Application of Queues: Simulation.

Write the definitions of the functions getRemainingTransactionTime, setCurrentCustomer, getCurrentCustomerNumber, getCurrentCustomerArrivalTime, getCurrentCustomerWaitingTime, and getCurrentCustomerTransactionTime of the class serverType defined in the section Application of Queues: Simulation.

Write the definition of the function runSimulation to complete the design of the computer simulation program (see the section Application of Queues: Simulation). Test run your program for a variety of data. Moreover, use a random number generator to decide whether a customer arrived at a given time unit.

Use the files attached to this assignment as your starting point. Run the simulation for 100 time units. There is one server. The average transaction time is 5 time units. The average arrival time difference between customers is 4. The output you should get is shown below.

Turn in all your header files, implementation file, and test program.

ATTATCHED DOCS

//Header file: stackADT.h #ifndef H_queueADT #define H_queueADT template  class queueADT { public: virtual bool isEmptyQueue() const = 0; //Function to determine whether the queue is empty. //Postcondition: Returns true if the queue is empty, // otherwise returns false. virtual bool isFullQueue() const = 0; //Function to determine whether the queue is full. //Postcondition: Returns true if the queue is full, // otherwise returns false. virtual void initializeQueue() = 0; //Function to initialize the queue to an empty state. //Postcondition: The queue is empty. virtual Type front() const = 0; //Function to return the first element of the queue. //Precondition: The queue exists and is not empty. //Postcondition: If the queue is empty, the program // terminates; otherwise, the first // element of the queue is returned. virtual Type back() const = 0; //Function to return the last element of the queue. //Precondition: The queue exists and is not empty. //Postcondition: If the queue is empty, the program // terminates; otherwise, the last // element of the queue is returned. virtual void addQueue(const Type& queueElement) = 0; //Function to add queueElement to the queue. //Precondition: The queue exists and is not full. //Postcondition: The queue is changed and queueElement // is added to the queue. virtual void deleteQueue() = 0; //Function to remove the first element of the queue. //Precondition: The queue exists and is not empty. //Postcondition: The queue is changed and the first // element is removed from the queue. }; #endif 

ATTATCHED DOCS 2********************************************************************************

//Header file QueueAsArray #ifndef H_QueueAsArray #define H_QueueAsArray #include  #include  #include "queueADT.h" using namespace std; template  class queueType: public queueADT { public: const queueType& operator=(const queueType&); //Overload the assignment operator. bool isEmptyQueue() const; //Function to determine whether the queue is empty. //Postcondition: Returns true if the queue is empty, // otherwise returns false. bool isFullQueue() const; //Function to determine whether the queue is full. //Postcondition: Returns true if the queue is full, // otherwise returns false. void initializeQueue(); //Function to initialize the queue to an empty state. //Postcondition: The queue is empty. Type front() const; //Function to return the first element of the queue. //Precondition: The queue exists and is not empty. //Postcondition: If the queue is empty, the program // terminates; otherwise, the first // element of the queue is returned. Type back() const; //Function to return the last element of the queue. //Precondition: The queue exists and is not empty. //Postcondition: If the queue is empty, the program // terminates; otherwise, the last // element of the queue is returned. void addQueue(const Type& queueElement); //Function to add queueElement to the queue. //Precondition: The queue exists and is not full. //Postcondition: The queue is changed and queueElement // is added to the queue. void deleteQueue(); //Function to remove the first element of the queue. //Precondition: The queue exists and is not empty. //Postcondition: The queue is changed and the first // element is removed from the queue. queueType(int queueSize = 100); //Constructor queueType(const queueType& otherQueue); //Copy constructor ~queueType(); //Destructor private: int maxQueueSize; //variable to store the maximum queue size int count; //variable to store the number of //elements in the queue int queueFront; //variable to point to the first //element of the queue int queueRear; //variable to point to the last //element of the queue Type *list; //pointer to the array that holds //the queue elements }; template  bool queueType::isEmptyQueue() const { return (count == 0); } //end isEmptyQueue template  bool queueType::isFullQueue() const { return (count == maxQueueSize); } //end isFullQueue template  void queueType::initializeQueue() { queueFront = 0; queueRear = maxQueueSize - 1; count = 0; } //end initializeQueue template  Type queueType::front() const { assert(!isEmptyQueue()); return list[queueFront]; } //end front template  Type queueType::back() const { assert(!isEmptyQueue()); return list[queueRear]; } //end back template  void queueType::addQueue(const Type& newElement) { if (!isFullQueue()) { queueRear = (queueRear + 1) % maxQueueSize; //use mod //operator to advance queueRear //because the array is circular count++; list[queueRear] = newElement; } else cout << "Cannot add to a full queue." << endl; } //end addQueue template  void queueType::deleteQueue() { if (!isEmptyQueue()) { count--; queueFront = (queueFront + 1) % maxQueueSize; //use the //mod operator to advance queueFront //because the array is circular } else cout << "Cannot remove from an empty queue." << endl; } //end deleteQueue //Constructor template  queueType::queueType(int queueSize) { if (queueSize <= 0) { cout << "Size of the array to hold the queue must " << "be positive." << endl; cout << "Creating an array of size 100." << endl; maxQueueSize = 100; } else maxQueueSize = queueSize; //set maxQueueSize to //queueSize queueFront = 0; //initialize queueFront queueRear = maxQueueSize - 1; //initialize queueRear count = 0; list = new Type[maxQueueSize]; //create the array to //hold the queue elements } //end constructor //Destructor template  queueType::~queueType() { delete [] list; } //end destructor template  const queueType& queueType::operator= (const queueType& otherQueue) { cout << "Write the definition of the function " << "to overload the assignment operator." << endl; } //end assignment operator template  queueType::queueType(const queueType& otherQueue) { cout << "Write the definition of the copy constructor." << endl; } //end copy constructor #endif 

ATTATCHED DOCS 3*************************************************************************

 #include  #include  #include "queueAsArray.h" using namespace std; //**************** customerType **************** class customerType { public: customerType(int cN = 0, int arrvTime = 0, int wTime = 0, int tTime = 0); //Constructor to initialize the instance variables //according to the parameters //If no value is specified in the object declaration, //the default values are assigned. //Postcondition: customerNumber = cN; // arrivalTime = arrvTime; // waitingTime = wTime; // transactionTime = tTime void setCustomerInfo(int customerN = 0, int inTime = 0, int wTime = 0, int tTime = 0); //Function to initialize the instance variables. //Instance variables are set according to the parameters. //Postcondition: customerNumber = customerN; // arrivalTime = arrvTime; // waitingTime = wTime; // transactionTime = tTime; int getWaitingTime() const; //Function to return the waiting time of a customer. //Postcondition: The value of waitingTime is returned. void setWaitingTime(int time); //Function to set the waiting time of a customer. //Postcondition: waitingTime = time; void incrementWaitingTime(); //Function to increment the waiting time by one time unit. //Postcondition: waitingTime++; int getArrivalTime() const; //Function to return the arrival time of a customer. //Postcondition: The value of arrivalTime is returned. int getTransactionTime() const; //Function to return the transaction time of a customer. //Postcondition: The value of transactionTime is returned. int getCustomerNumber() const; //Function to return the customer number. //Postcondition: The value of customerNumber is returned. private: int customerNumber; int arrivalTime; int waitingTime; int transactionTime; }; //************* serverType **************** class serverType { public: serverType(); //Default constructor //Sets the values of the instance variables to their default //values. //Postcondition: currentCustomer is initialized by its // default constructor; status = "free"; and // the transaction time is initialized to 0. bool isFree() const; //Function to determine if the server is free. //Postcondition: Returns true if the server is free, // otherwise returns false. void setBusy(); //Function to set the status of the server to busy. //Postcondition: status = "busy"; void setFree(); //Function to set the status of the server to "free". //Postcondition: status = "free"; void setTransactionTime(int t); //Function to set the transaction time according to the //parameter t. //Postcondition: transactionTime = t; void setTransactionTime(); //Function to set the transaction time according to //the transaction time of the current customer. //Postcondition: // transactionTime = currentCustomer.transactionTime; int getRemainingTransactionTime() const; //Function to return the remaining transaction time. //Postcondition: The value of transactionTime is returned. void decreaseTransactionTime(); //Function to decrease the transactionTime by 1 unit. //Postcondition: transactionTime--; void setCurrentCustomer(customerType cCustomer); //Function to set the info of the current customer //according to the parameter cCustomer. //Postcondition: currentCustomer = cCustomer; int getCurrentCustomerNumber() const; //Function to return the customer number of the current //customer. //Postcondition: The value of customerNumber of the // current customer is returned. int getCurrentCustomerArrivalTime() const; //Function to return the arrival time of the current //customer. //Postcondition: The value of arrivalTime of the current // customer is returned. int getCurrentCustomerWaitingTime() const; //Function to return the current waiting time of the //current customer. //Postcondition: The value of transactionTime is // returned. int getCurrentCustomerTransactionTime() const; //Function to return the transaction time of the //current customer. //Postcondition: The value of transactionTime of the // current customer is returned. private: customerType currentCustomer; string status; int transactionTime; }; //************* serverListType **************** class serverListType { public: serverListType(int num = 1); //Constructor to initialize a list of servers //Postcondition: numOfServers = num // A list of servers, specified by num, // is created and each server is // initialized to "free". ~serverListType(); //Destructor //Postcondition: The list of servers is destroyed. int getFreeServerID() const; //Function to search the list of servers. //Postcondition: If a free server is found, returns // its ID; otherwise, returns -1. int getNumberOfBusyServers() const; //Function to return the number of busy servers. //Postcondition: The number of busy servers is returned. void setServerBusy(int serverID, customerType cCustomer, int tTime); //Function to set a server as busy. //Postcondition: The server specified by serverID is set // to "busy", to serve the customer // specified by cCustomer, and the // transaction time is set according to the // parameter tTime. void setServerBusy(int serverID, customerType cCustomer); //Function to set a server as busy. //Postcondition: The server specified by serverID is set // to "busy", to serve the customer // specified by cCustomer. void updateServers(ostream& outFile); //Function to update the status of a server. //Postcondition: The transaction time of each busy // server is decremented by one unit. If // the transaction time of a busy server // is reduced to zero, the server is set // to "free". Moreover, if the actual // parameter corresponding to outFile is // cout, a message indicating which customer // has been served is printed on the screen, // together with the customer's departing // time. Otherwise, the output is sent to // a file specified by the user. private: int numOfServers; serverType *servers; }; //**************** waitQueue ************* class waitingCustomerQueueType: public queueType { public: waitingCustomerQueueType(int size = 100); //Constructor //Postcondition: The queue is initialized according to // the parameter size. The value of size // is passed to the constructor of queueType. void updateWaitingQueue(); //Function to increment the waiting time of each //customer in the queue by one time unit. }; 

ATTATCHED DOCS 4********************************************************************************

 #include  #include  #include  #include "Simulation.h" #include "queueAsArray.h" using namespace std; //*************** customerType ************ void customerType::setCustomerInfo(int customerN, int arrvTime, int wTime, int tTime) { customerNumber = customerN; arrivalTime = arrvTime; waitingTime = wTime; transactionTime = tTime; } customerType::customerType(int customerN, int arrvTime, int wTime, int tTime) { setCustomerInfo(customerN, arrvTime, wTime, tTime); } int customerType::getWaitingTime() const { return waitingTime; } void customerType::incrementWaitingTime() { waitingTime++; } void customerType::setWaitingTime(int time) { cout << "See Programming Exercise 17 at the end of this chapter." << endl; } int customerType::getArrivalTime() const { cout << "Programming Project" << endl; return 0; } int customerType::getTransactionTime() const { cout << "Programming Project" << endl; return 0; } int customerType::getCustomerNumber() const { cout << "Programming Project" << endl; return 0; } //**************** serverType ********** serverType::serverType() { status = "free"; transactionTime = 0; } bool serverType::isFree() const { return (status == "free"); } void serverType::setBusy() { status = "busy"; } void serverType::setFree() { status = "free"; } void serverType::setTransactionTime(int t) { transactionTime = t; } void serverType::setTransactionTime() { int time; time = currentCustomer.getTransactionTime(); transactionTime = time; } void serverType::decreaseTransactionTime() { transactionTime--; } int serverType::getRemainingTransactionTime() const { cout << "Programming Project" << endl; return 0; } void serverType::setCurrentCustomer(customerType cCustomer) { cout << "Programming Project" << endl; } int serverType::getCurrentCustomerNumber() const { cout << "Programming Project" << endl; return 0; } int serverType::getCurrentCustomerArrivalTime() const { cout << "Programming Project" << endl; return 0; } int serverType::getCurrentCustomerWaitingTime() const { cout << "Programming Project" << endl; return 0; } int serverType::getCurrentCustomerTransactionTime() const { cout << "Programming Project" << endl; return 0; } //************** serverListType *********** serverListType::serverListType(int num) { numOfServers = num; servers = new serverType[num]; } serverListType::~serverListType() { delete [] servers; } int serverListType::getFreeServerID() const { int serverID = -1; int i; for (i = 0; i < numOfServers; i++) if (servers[i].isFree()) { serverID = i; break; } return serverID; } int serverListType::getNumberOfBusyServers() const { int busyServers = 0; int i; for (i = 0; i < numOfServers; i++) if (!servers[i].isFree()) busyServers++; return busyServers; } void serverListType::setServerBusy(int serverID, customerType cCustomer, int tTime) { servers[serverID].setBusy(); servers[serverID].setTransactionTime(tTime); servers[serverID].setCurrentCustomer(cCustomer); } void serverListType::setServerBusy(int serverID, customerType cCustomer) { int time; time = cCustomer.getTransactionTime(); servers[serverID].setBusy(); servers[serverID].setTransactionTime(time); servers[serverID].setCurrentCustomer(cCustomer); } void serverListType::updateServers(ostream& outFile) { int i; for (i = 0; i < numOfServers; i++) if (!servers[i].isFree()) { servers[i].decreaseTransactionTime(); if (servers[i].getRemainingTransactionTime() == 0) { outFile << "From server number " << (i + 1) << " customer number " << servers[i].getCurrentCustomerNumber() << " departed at time unit " << servers[i]. getCurrentCustomerArrivalTime() + servers[i]. getCurrentCustomerWaitingTime() + servers[i]. getCurrentCustomerTransactionTime() << endl; servers[i].setFree(); } } } //*************** waitQueue ************ waitingCustomerQueueType::waitingCustomerQueueType(int size) :queueType(size) { } void waitingCustomerQueueType::updateWaitingQueue() { customerType cust; cust.setWaitingTime(-1); int wTime = 0; addQueue(cust); while (wTime != -1) { cust = front(); deleteQueue(); wTime = cust.getWaitingTime(); if (wTime == -1) break; cust.incrementWaitingTime(); addQueue(cust); } } 

ATTATCHED DOCS 5************************************************************************************

 #include  #include  #include  #include "simulation.h" #include "queueAsArray.h" using namespace std; void setSimulationParameters(int& sTime, int& numOfServers, int& transTime, int& tBetweenCArrival); void runSimulation(); int main() { runSimulation(); return 0; } void setSimulationParameters(int& sTime, int& numOfServers, int& transTime, int& tBetweenCArrival) { cout << "Enter the simulation time: "; cin >> sTime; cout << endl; cout << "Enter the number of servers: "; cin >> numOfServers; cout << endl; cout << "Enter the transaction time: "; cin >> transTime; cout << endl; cout << "Enter the time between customer arrivals: "; cin >> tBetweenCArrival; cout << endl; } void runSimulation() { cout << "Write the definition of the function runSimulation." << endl; }