Paper 2

class StackY
{
          private:
                      int maxSize;
                      int *stackArray;
                      int top;
           public:
                       StackY(int s);
                       ~StackY();
                       void push(int j);
                       int pop();
                       int peek();
                       bool isEmpty();
                       bool isFull();
}

StackY::StackY(int s)
{
          maxSize=s;
          stackArray = new int[maxSize];
          top=-1;
}

void StackY::push(int j)
{
           if(isFull())
                cout<<"Stack is full cannot insert";
            else
                 stackArray[++top]=j;
}

int StackY::pop()
{
          if (isEmpty())
          {
                cout<<"The Stack is empty";
                return -999;
           }
            else
                  return stackArray[top--];
}

int StackY::peek()
{
          if(top==-1)
          {
                 cout<<"The stack is empty";
                 return stackArray[top];
           }
            else
                  return stackArray[top];
}

bool StackY::isEmpty()
{
           if( top==-1) return 1; else return 0;
}

bool StackY::isFull
{
       
            if (top == maxSize) return 1; else return 0;
}

int StackY::peek()
{
          if (top==-1)
          {
                cout<<"The stack is empty";
                return -999;
           }
           else
                 return stackArray[top];
}

Paper Discussion

class Print{

          private:
                    int maxsize;
                    int *pIDArray;
                    int front;
                    int rear;                    int nItems;
           public:
                     Print(int s);
                    ~Print();
                    void insert(int printJobID);
                     int remove();
                     int peekFront();

                     int isEmpty();
                     int isFull();
                     int size();}

Print::Print(int s)
{
          maxSize=s;
          pIDArray=new int[maxSize];
          front=0;
          rear=-1;
          nItems=0;
}

bool Print::isEmpty()
{
           return (nItems==0);
}

bool Print::isFull
{
            return (rear==maxSize-1);
}

int Print::size()
{
              return nItems;
}

void Print::insert(int printJobID)
{        if(isFull())
                 cout<<"The queue is full";
           else
             {
                pIDArray[++rear]=printJobID;
                nItems++;
             }
}

int Print::remove()
{
             if(isEmpty())
             {
                 cout<<"Print Queue is empty";
                 return -999;
              }
              else{
                       nItems--;
                       return pIDArray[front++];
              }
}

int Print::peekFront()
{
                if(isEmpty())
                {
                   cout<<"Queue is empty";
                   return -999;
                 }
                 else
                       return pIDArray[front];
}