// Purpose.  Adapter design pattern lab
// 
// Problem.  Simulated here is a "stack machine", or a non-OO
// implementation of a Stack class.  We would like to reuse this "legacy"
// asset as the basis for a new Queue class, but there is an "impedance
// mismatch" between the old and the new.
// 
// Assignment.
// o The class Queue should contain an "instance" of component Stack.
// o Queue needs a ctor, dtor, enque, deque, and isEmpty methods.  Each of
//   these methods will provide an adaptation from the Queue interface to the
//   Stack implementation.
// o If you map Queue's enque() to Stack's push(), then the pseudocode below
//   will give you insight into implementing Queue's deque() method.

#include <iostream.h>

struct StackStruct {
   int*  array;
   int   sp;
   int   size;
};
typedef StackStruct Stack;

static void initialize( Stack* s, int size ) {
   s->array = new int[size];
   s->size = size;
   s->sp = 0; }
static void cleanUp( Stack* s ) {
   delete s->array; }
static int isEmpty( Stack* s ) {
   return s->sp == 0 ? 1 : 0; }
static int isFull( Stack* s ) {
   return s->sp == s->size ? 1 : 0; }
static void push( Stack* s, int item ) {
   if ( ! isFull(s)) s->array[s->sp++] = item; }
static int pop( Stack* s ) {
   if (isEmpty(s)) return 0;
   else            return s->array[--s->sp]; }

class Queue {
   deque pseudocode:
      initialize a local temporary instance of Stack
      loop
         pop() the permanent stack and push() the temporary stack
      pop() the temporary stack and remember this value
      loop
         pop() the temporary stack and push() the permanent stack
      cleanUp the temporary stack
      return the remembered value
   int isFull()  { return ::isFull( &_stack );  }
};

void main( void ) {
   Queue  queue(15);

   for (int i=0; i < 25; i++) queue.enque( i );
   while ( ! queue.isEmpty())
      cout << queue.deque() << " ";
   cout << endl;
}

// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14