#include <fstream>
#include <string>
#include <sstream>
#include <stdlib.h>
#include "queue.h"
 
using namespace std;
 
int main() 
{ 
 
   stringstream ss;
   string line; // name of my identifier used to read in data
   string word; // individual characters
   queueType<string> u; // declares queue u
   queueType<string> r; // declare queue r
   queueType<string> s; // declare queue s
   int counter = 0; // declares counter
 
 
   ifstream inData("input.txt"); // declaration of inData
   ofstream outData("output.txt"); // declaration of outData
 
 
   u.initializeQueue();
   r.initializeQueue();
   s.initializeQueue();
 
while ( getline( inData, line ) ) // reads words in file using getline to capture all spaces
{ /*something to break up line into individual character*/
 
ss << line;
 
while ( ss >> word )/*there are still characters*/
{
    u.addQueue(word);
    s.addQueue(word);     /*adds characters of word into queues u and s*/
}
 
while (!u.isEmptyQueue()) /*u is not empty*/
{
    r.addQueue(u.front());
    u.deleteQueue();
               /*adds to the front of u into r and then delete from u*/
}
 
bool isPalin=true;
 
while (!s.isEmptyQueue())/*s is not empty*/
{
      s.deleteQueue();
      u.addQueue(word);
 
  if(!(u.front() == r.front()))    /*compares front elements, does something if the two not equal, delete elements*/
      {
      u.deleteQueue();
      r.deleteQueue();
      isPalin=false;
      break;
      }
}
 
if (isPalin)
{
outData<<word<<" is a Palindrome"<<endl;
}
else
outData<<word<<" is NOT a Palindrome"<<endl;
 
ss.clear();
 
}
    inData.close(); // closes inData
    outData.close(); // closes outData
 
    system("PAUSE");
    return 0;
}

#ifndef H_queueType
#define H_queueType
 
#include <iostream>
#include <cassert>
 
using namespace std;
 
template<class Type>
class queueType // public queueADT<Type>
{
      public:
             const queueType<Type>& operator=(const queueType<Type>&);
             bool isEmptyQueue() const;
             bool isFullQueue() const;
             void initializeQueue();
             Type front() const;
             Type back() const;
             void addQueue(const Type& queueElement);
             void deleteQueue();
             queueType(int queueSize = 100);
             queueType(const queueType<Type>& otherQueue);
             ~queueType();
             void printQueue();
             bool operator== (const queueType<Type>&);
             bool operator!= (const queueType<Type>&);
 
      private:
              int maxQueueSize;
              int count;
              int queueFront;
              int queueRear;
              Type *list;
              bool isEqual(const queueType<Type>&);
};
 
template<class Type>
bool queueType<Type>::isEmptyQueue() const
{
     return (count == 0);
}
 
template<class Type>
bool queueType<Type>::isFullQueue() const
{
     return (count == maxQueueSize);
}
 
template<class Type>
void queueType<Type>::initializeQueue()
{
     queueFront = 0;
     queueRear = maxQueueSize - 1;
     count = 0;
}
 
template<class Type>
Type queueType<Type>::front() const
{
     assert(!isEmptyQueue());
     return list[queueFront];
}
 
template<class Type>
Type queueType<Type>::back() const
{
     assert(!isEmptyQueue());
     return list[queueRear];
}
 
template<class Type>
void queueType<Type>::addQueue(const Type& newElement)
{
     if (!isFullQueue())
     {
       queueRear = (queueRear + 1) % maxQueueSize;
 
       count++;
       list[queueRear] = newElement;
     }
 
     else
       cout<< "Cannot add to a full queue."<<endl;
}
 
template<class Type>
void queueType<Type>::deleteQueue()
{
     if (!isEmptyQueue())
     {
       count--;
       queueFront = (queueFront + 1) % maxQueueSize;
     }
 
     else
     cout <<"Cannot remove from an empty queue"<<endl;
 
}
 
template<class Type>
queueType<Type>::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;
 
     queueFront = 0;
     queueRear = maxQueueSize - 1;
     count = 0;
     list = new Type[maxQueueSize];
}
 
template<class Type>
queueType<Type>::~queueType()
{
   delete [] list;
}
 
 
template<class Type>
bool queueType<Type>::isEqual(const queueType<Type>& otherQueue) 
{
bool bRet = false;
 
if (otherQueue.maxQueueSize == maxQueueSize && otherQueue.queueFront == queueFront)
{
bRet = true;
for (int j = 0; j < queueFront; ++j) 
{
if (otherQueue.list[j] != list[j]) 
{
// cout << "!=( " << j << ") " << otherStack.list[j] << "!=" << list[j];
bRet = false;
break;
}
}
}
return bRet;
}
 
template<class Type>
bool queueType<Type>::operator==(const queueType<Type>& otherQueue) 
{
return isEqual(otherQueue);
}
 
template<class Type>
bool queueType<Type>::operator!=(const queueType<Type>& otherQueue) 
{
return !isEqual(otherQueue);
}
 
 
template<class Type>
void queueType<Type>::printQueue()
{
 
for (int x = queueFront-1; x >= 0; --x)    
{        
cout << list[x] << '\n';    
}  
 
 
}
 
 
 
#endif