Added comparison class and function.

Author: Azzaare

include/compare.hpp

@@ -0,0 +1,92 @@
+#ifndef COMPARE
+#define COMPARE
+
+/*==============================================================================
+  Includes
+==============================================================================*/
+#include "problem.hpp"
+#include "data.hpp"
+
+/*==============================================================================
+  Class      : abstract, template (T context, D datas)
+  Extensions :
+  Aliases    :
+  Friends   ->
+            <- Problem
+==============================================================================*/
+template <class T, class D>
+class CompareStacks: public Problem<T,D>{
+public:
+  // Members functions
+  CompareStacks<T,D>(std::string fileName, int size, int space, int buffer);
+
+  // Compare the stacks
+  void runCompare(int buffer = 0);
+
+private:
+
+    // Stack Functions: defined by user
+  virtual D readInput(std::vector<std::string> line) = 0;
+  virtual std::shared_ptr<T> initStack() = 0;
+  virtual bool popCondition(D data) = 0;
+  virtual void popAction(Data<T,D> elt) {};
+  virtual bool pushCondition(D data) = 0;
+  virtual void pushAction(Data<T,D> elt) {};
+
+  // Stack: Normal Stack for comparison
+  std::shared_ptr<NormalStack<T,D>> mNormalStack;
+};
+
+/*==============================================================================
+  Constructors :
+==============================================================================*/
+
+template <class T, class D>
+CompareStacks<T,D>::CompareStacks(std::string fileName, int size, int space, int buffer)
+: Problem<T,D>(fileName, size, space, buffer)
+, mNormalStack(new NormalStack<T,D> (size)){
+}
+
+/*==============================================================================
+  Stack Functions: run, push, pop, top
+==============================================================================*/
+template <class T, class D>
+void CompareStacks<T,D>::runCompare(int buffer){
+  Problem<T,D>::initStackIntern();
+  while ((Problem<T,D>::mInput.good())) {
+    for (int i = 1; i <= buffer; i++) {
+      bool bIndex = Problem<T,D>::top(i).mIndex == mNormalStack->top(i).mIndex;
+      bool bData = Problem<T,D>::top(i).mData == mNormalStack->top(i).mData;
+      if (!bIndex || !bData) {
+        throw "The top $(i)st elements are different";
+      }
+    }
+    std::vector<std::string> line = Problem<T,D>::readLine();
+    if ( (line.front()== "-1") || (line.front()=="") ) {
+      break;
+    }
+    D data = readInput(line);
+    Problem<T,D>::mIndex++; // Might have to move
+    if (Problem<T,D>::emptystack() != mNormalStack->isempty()) {
+      throw "One stack is empty and not the other";
+    }
+    while ( !(Problem<T,D>::emptystack()) && (popCondition(data)) ) {
+      Data<T,D> elt = Problem<T,D>::pop();
+      Data<T,D> eltNormal = mNormalStack->pop();
+      bool bIndex = elt.mIndex == eltNormal.mIndex;
+      bool bData = elt.mData == eltNormal.mData;
+      if (!bIndex || bData) {
+        throw "The two elements popped are different";
+      }
+      popAction(elt);
+    }
+    if (pushCondition(data)) {
+      Data<T,D> elt (Problem<T,D>::mIndex,data);
+      pushAction(elt);
+      Problem<T,D>::push(elt);
+      mNormalStack->push(elt);
+    }
+  }
+}
+
+#endif /* COMPARE */

include/data.hpp

@@ -19,11 +19,13 @@
 template <class T, class D> class Component; // Required for the friendship
 template <class T, class D> class CompressedStack; // Required for the friendship
 template <class T, class D> class Problem; // Required for the friendship
+template <class T, class D> class CompareStacks; // Required for the friendship
 template <class T, class D>
 class Data{
   friend class Component<T,D>;
   friend class CompressedStack<T,D>;
   friend class Problem<T,D>;
+  friend class CompareStacks<T,D>;
 
 public:
   // IO

include/normalStack.hpp

@@ -15,9 +15,11 @@
             <-
 ==============================================================================*/
 template <class T, class D> class Problem; // Required for the friendship
+template <class T, class D> class CompareStacks; // Required for the friendship
 template <class T, class D>
 class NormalStack: public Stack<T,D>{
   friend class Problem<T,D>;
+  friend class CompareStacks<T,D>;
 
 public:
   // Constructors
@@ -31,7 +33,9 @@ class NormalStack: public Stack<T,D>{
 
   // Stack common methods
   Data<T,D> pop(Problem<T,D> &problem);
+  Data<T,D> pop();
   void push(const Data<T,D> &data, std::streampos position);
+  void push(const Data<T,D> &data);
   Data<T,D> top(int k);
   bool isempty();
 
@@ -72,11 +76,21 @@ Data<T,D> NormalStack<T,D>::pop(Problem<T,D> &problem){
   mDatas.pop_back();
   return data;
 }
+template <class T, class D>
+Data<T,D> NormalStack<T,D>::pop(){
+  Data<T,D> data = mDatas.back();
+  mDatas.pop_back();
+  return data;
+}
 
 template <class T, class D>
 void NormalStack<T,D>::push(const Data<T,D> &elt, std::streampos position){
   mDatas.push_back(elt);
 }
+template <class T, class D>
+void NormalStack<T,D>::push(const Data<T,D> &elt){
+  mDatas.push_back(elt);
+}
 
 template <class T, class D>
 Data<T,D> NormalStack<T,D>::top(int k){

include/problem.hpp

@@ -20,9 +20,11 @@
             <- NormalStack, CompressedStack, Data
 ==============================================================================*/
 template <class T, class D> class CompressedStack; // Required for the friendship
+template <class T, class D> class CompareStacks; // Required for the friendship
 template <class T, class D>
 class Problem{
   friend class CompressedStack<T,D>;
+  friend class CompareStacks<T,D>;
 
 public:
   // Members functions

src/main.cpp

@@ -4,6 +4,7 @@
   Includes
 ==============================================================================*/
 #include "../include/problem.hpp"
+#include "../include/compare.hpp"
 #include "../include/createTestInput.hpp"
 #include <string>
 #include <vector>
@@ -49,6 +50,45 @@ class Instance: public Problem<int,int>{
   }
 };
 
+/*==============================================================================
+  Instantiation of a comparison
+==============================================================================*/
+class Comparison: public CompareStacks<int,int>{
+public:
+  Comparison(std::string filePath, int size, int space, int buffer):CompareStacks<int,int>(filePath, size, space, buffer){}
+private:
+  // Functions to run the stack
+  int readInput(std::vector<std::string> line){
+    int value = std::stoi(line[0]);
+    setContext(std::stoi(line[1]));
+    return value;
+
+  }
+  std::shared_ptr<int> initStack(){
+    std::shared_ptr<int> context (new int (10));
+    std::vector<std::string> line = readLine(); // Temporary measure to get rid of the first line
+    return context;
+  }
+  bool popCondition(int data){
+    if (getContext() > 0) {
+      return true;
+    }
+    return false;
+  }
+  void popAction(Data<int,int> elt){
+    setContext(getContext() - 1);
+  }
+  bool pushCondition(int data){
+    if (data > 0) {
+      return true;
+    }
+    return false;
+  }
+  void pushAction(Data<int,int> elt){
+    std::cout << "Implement mPushAction for your instance" << std::endl;
+  }
+};
+
 /*==============================================================================
   Test functions
 ==============================================================================*/
@@ -69,12 +109,20 @@ void testProblem()
   testCS.println();
 }
 
+void testCompare(){
+  std::string filePath = "../instances/pushOnlyInput.csv";
+
+  Comparison comp(filePath, 1000, 3, 0);
+  comp.runCompare();
+}
 /*==============================================================================
   Main function
 ==============================================================================*/
 // Main //int main(int argc, char const *argv[]) {
 int main() {
-  testProblem();
+//  testProblem();
+
+  testCompare();
 
 // Intances generation, please comment when not in use
 /*  createTestInput ct=createTestInput();