/*
----------------------------------------------------------------------
              MEMORIAL UNIVERSITY OF NEWFOUNDLAND
             Faculty of Engineering and Applied Science
               Engineering 3891(Advanced Programming)
Assignment #4                      Instructor: Michael Bruce-Lockhart
Date: 00.10.06                                           Due: 00.10.13
----------------------------------------------------------------------
	Interface for a circular queue manager 
*/

const  int  QSIZE = 2000;        // size of queue in bytes 
/*NOTE: you may want to change this to something like 4 or 5
when debugging. However, it will be set to 2000 when the
autograder runs its tests.
*/

enum status{UNDERFLOW,EMPTY,PENDING,FULL,OVERFLOW};

/* Queue status:
	empty:  nothing in the queue
	pending:    more than 0 and less than QSIZE items in the
			queue
	full -  queue has exactly QSIZE items in it
	overflow -queue is full AND at least one attempt has
			been made to add more items so that an error
			has occurred. Number of such items (the data
			lost) is undefined.
	underflow - queue is empty AND at least one attempt has
			been made to remove non-existent data from 
			it. 

	Note that overflow and full are both set to pending if
	a single item is removed from the queue while underflow 
	and empty both set to pending if a single item is added
	to the queue.
*/

status getStatus(void);
/* returns current status of the queue */

status putQueue(int item);
/* Puts item on the queue, updates and returns new status.
	If the queue is already full or in overflow, current
	item is lost but all items put on the queue previously
	are unaffected.
*/

int getQueue(void);
/* Returns integer item from the queue. Status is updated
	but not returned. Returns 0 if no items available */

/*           EXPLANATION
A circular queue is a first-in, first-out data structure. New entries 
are always made at the tail and old entries are removed from the head. 
Unlike a bank queue, entries are not actually moved up in the queue as 
the head is serviced. 

Rather, they are like the service number systems used in many stores, 
whereby a new customer takes the next number from the machine (the tail 
pointer) and finds any open place at the counter. The clerk, meanwhile, 
serves customers according to the next service number appearing on an 
electronic counter (the head pointer).  The numbers are changed, but the 
customers don't move.

The queue is circular because the numbers rotate around in sequence. 
Generally, the dispensers only have nos. 0 through 99 available. After 
99 is used they go back to 0.

You are to create the three routines required for the implementation 
(one of which is trivial so you really only have to write two). The 
three functions are to be implemented in a single file which should 
incorporate the following, external database: (i.e outside all functions 
in the file, declared at the beginning of the file, and hence 
visible to all functions in the file). 


int      queue[QSIZE];
int*     head;   // access pointers to the beginning 
int*     tail;	 // and end of the queue
status   current;

This code should appear after any #include statements you require but 
before your function implementations. Its effect is to make the queue, 
its current status and its two pointers visible to all three functions, 
so each can operate on the queue. Thus the application cannot directly 
manipulate the queue or its pointers but must work through the publicly 
available functions declared in the interface. This is a concept known as
DATA HIDING.

Any of these four variables can be initialised if you want. As they are
external variables they exist for the life of the program and hence are only
initialised once, when the program is loaded (just before main is called).
This is in contrast to internal variables which are created anew each time
their function is called and thus have to be initialised anew (if the ptogrammer
has called for their initialisation).

Note that none of the functions are very long. The trick is to be able 
to work out the status of the queue at all times. No other global 
variables should be used and local variables should be kept to a 
minimum.

  Note also that there is nothing to stop you creating your own service functions
in your assign4.cpp file. Since they are not declared in the h file they will
not be available/visible to the test routine but they WILL BE available to your
functions. For example, since your pointers have to run around a circle, you might
consider creating a pointer increment function to deal with that problem. 

PLEASE NOTE: YOU ARE EXPECTED TO USE POINTER, RATHER THAN ARRAY, NOTATION!
*/