// Purpose. Bridge design pattern lab
//
// Problem. Our Stack class needs to allow the client to specify at
// run-time what implementation strategy to employ (i.e. list vs array).
//
// Assignment.
// o Rename the current Stack class to ArrayImp
// o Create a base class called StackImp
// o StackImp is a "pure abstract base class". It should declare 4 pure
// virtual functions: push(), pop(), isEmpty(), and isFull()
// o Derive classes ArrayImp and ListImp from class StackImp
// o Create an interface (or wrapper, or handle) class called Stack
// o The class Stack should contain a pointer to the abstract base class
// StackImp.
// o To initialize the StackImp pointer, Stack needs a constructor that
// accepts one argument of type ImplementationType. In the body, you
// create an instance of the derived class requested. If the client does
// not supply an argument for the constructor, provide a default argument
// of ArrayImplementation.
// o Don't forget to write a destructor to clean-up the StackImp pointer
// o The class Stack should have a method for anything a client might want to
// do to a Stack object. Each method simply forwards the client request to
// the appropriate method in its StackImp object.
// o Un-comment the code in main() and test your results

#include <iostream.h>
enum ImplementationType { ArrayImplementation, ListImplementation };


class Stack {
public:
Stack( int = 10 );
~Stack();
void push( int val );
int pop();
int isEmpty();
int isFull();
private:
int* _array;
int _sp;
int _size;
};


class Node {
public:
Node( int val, Node* next );
int getValue();
Node* getNext();
private:
int _value;
Node* _next;
};

class ListImp {
public:
ListImp();
~ListImp();
void push( int val );
int pop();
int isEmpty();
int isFull();
private:
Node* _head;
};

void main ( void ) {
Stack stack1;
// Stack stack2( ListImplementation );

for (int i=1; i < 16; i++) {
stack1.push( i );
// stack2.push( i );
}

cout << "Array stack: ";
for (i=1; i < 18 ; i++)
cout << stack1.pop() << " ";
cout << endl;

// cout << "List stack: ";
// for (i=1; i < 18 ; i++)
// cout << stack2.pop() << " ";
// cout << endl;
}

// Array stack: 10 9 8 7 6 5 4 3 2 1 0 0 0 0 0 0 0
// List stack: 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 0


Stack::Stack( int size ) {
_array = new int[size];
_size = size;
_sp = 0; }
Stack::~Stack() { delete _array; }
void Stack::push( int val ) {
if ( ! isFull())
_array[_sp++] = val; }
int Stack::pop() {
if (isEmpty()) return 0;
else return _array[--_sp]; }
int Stack::isEmpty() { return _sp == 0 ? 1 : 0; }
int Stack::isFull() { return _sp == _size ? 1 : 0; }

Node::Node( int val, Node* next ) {
_value = val;
_next = next; }
int Node::getValue() { return _value; }
Node* Node::getNext() { return _next; }

ListImp::ListImp() { _head = NULL; }
ListImp::~ListImp() {
Node *current, *previous;
current = _head;
while (current) {
previous = current;
current = current->getNext();
delete previous; }
}
void ListImp::push( int val ) {
Node* temp = new Node( val, _head );
_head = temp; }
int ListImp::pop() {
if (isEmpty()) return 0;
Node* temp = _head;
int val = _head->getValue();
_head = _head->getNext();
delete temp;
return val; }
int ListImp::isEmpty() { return _head ? 0 : 1; }
int ListImp::isFull() { return 0; }