Functional Normal Stack template. Example of an instance. First README.md file

Author: Azzaare

README.md

@@ -1 +1,32 @@
 # CompressedStacks.cpp
+```cpp
+// Class for test instance
+// T is the type of the context and D is the type of the input data. Please change it on 1st and 3rd lines.
+class Instance: public Problem<T,D>{
+public:
+  Instance(std::string filePath, int size):Problem<T,D>(filePath, size){}
+private:
+  // Functions to implement according to the problem and input
+  int mReadInput(){
+    std::cout << "Implement mReadInput for your instance" << std::endl;
+    return 0;
+  }
+  void mInitStack(){
+    std::cout << "Implement mInitStack for your instance" << std::endl;
+  }
+  bool mPopCondition(int elt){
+    std::cout << "Implement mPopCondition for your instance" << std::endl;
+    return false;
+  }
+  void mPopAction(Data<D> elt){
+    std::cout << "Implement mPopAction for your instance" << std::endl;
+  }
+  bool mPushCondition(int elt){
+    std::cout << "Implement mPushCondition for your instance" << std::endl;
+    return true;
+  }
+  void mPushAction(Data<D> elt){
+    std::cout << "Implement mPushAction for your instance" << std::endl;
+  }
+};
+```

include/compressedStack.hpp

@@ -19,6 +19,7 @@ class CompressedStack: public Stack<D>
   Data<D> top(int k);
   void push(Data<D> data);
   Data<D> pop();
+  bool isempty();
 
   // IO
   std::string toString();
@@ -86,6 +87,11 @@ void CompressedStack<T,D>::println()
 }
 
 /** Pushes, pops and accesses **/
+template <class T, class D>
+bool CompressedStack<T,D>::isempty(){
+  return true;
+}
+
 template <class T, class D>
 void CompressedStack<T,D>::push(Data<D> data)
 {

include/data.hpp

@@ -55,7 +55,7 @@ template <class D>
 std::string Data<D>::toString()
 {
   std::string str;
-  str = std::to_string(mIndex);
+  str = std::to_string(mIndex) + "<-" + std::to_string(mData);
   return str;
 }
 template <class D>

include/normalStack.hpp

@@ -15,6 +15,7 @@ class NormalStack: public Stack<D>
   Data<D> pop();
   void push(Data<D> data);
   Data<D> top(int k);
+  bool isempty();
 
   // IO
   std::string toString();
@@ -35,6 +36,12 @@ NormalStack<D>::NormalStack(int size)
 }
 
 /** Stack internal methods **/
+template <class D>
+  bool NormalStack<D>::isempty()
+  {
+    return mDatas.empty();
+  }
+
 template <class D>
   Data<D> NormalStack<D>::pop()
   {
@@ -44,9 +51,12 @@ template <class D>
   }
 
 template <class D>
-  void NormalStack<D>::push(Data<D> data)
+  void NormalStack<D>::push(Data<D> elt)
   {
-    mDatas.push_back(data);
+    std::cout << "Ultra Push! : data = " << (elt.getData()) << std::endl;
+    mDatas.push_back(elt);
+    std::cout << "Size of the stack : " << (mDatas.size()) << std::endl;
+    println();
   }
 
 template <class D>

include/problem.hpp

@@ -5,57 +5,58 @@
 #include "stack.hpp"
 #include "compressedStack.hpp"
 #include "normalStack.hpp"
-#include <stdbool.h>
+//#include <stdbool.h>
 #include <fstream>
+#include <vector>
 #include <string>
 
 template <class T, class D>
 class Problem
 {
-  /** Typedefs for handling pointer-to-function **/
-  typedef void (Problem::*ProblemVoidFn)();
-  typedef D (Problem::*ProblemDataFn)();
-  typedef bool (Problem::*ProblemBoolFn)();
-
 public:
   // Problem<T,D>(std::string fileName);
   Problem<T,D>(std::string fileName, int size);
   Problem<T,D>(std::string fileName, int size, int space);
 
   // Running the stack
   void run();
+  void push(Data<D>);
+  Data<D> pop();
+  Data<D> top(int k);
+  bool emptystack();
 
   // Setters
-  void setReadInput(D (*functionPointer)());
-  void setInitStack(void (*functionPointer)());
-  void setPopCondition(ProblemBoolFn functionPointer);
-  void setPopAction(void (*functionPointer)());
-  void setPushCondition(bool (*functionPointer)());
-  void setPushAction(void (*functionPointer)());
-
   void setOutput(std::string fileName);
+  void setContext(T context);
+
+  //Getters
+  T getContext();
 
   // IO
   std::string toString();
   void print();
   void println();
 
+protected:
+  std::vector<std::string> readLine();
+  int mIndex;
+
 private:
   // Input/Ouput
-  std::ifstream* mInput;
+  std::ifstream mInput;
   std::ofstream* mOutput; // output file is optional
 
   // Stack Functions: defined by user
-  D    (*mReadInput)();
-  void (*mInitStack)();
-  bool (*mPopCondition)();
-  void (*mPopAction)();
-  bool (*mPushCondition)();
-  void (*mPushAction)();
+  virtual D readInput(std::vector<std::string> line) = 0;
+  virtual void initStack() = 0;
+  virtual bool popCondition(D data) = 0;
+  virtual void popAction(Data<D> elt) {};
+  virtual bool pushCondition(D data) = 0;
+  //virtual void pushAction() = 0;
+  virtual void pushAction(Data<D> elt) {};
 
   // Problem internal during run
   T* mContext;
-  int mIndex;
 
   // Stack: Normal or Compressed
   Stack<D>* mStack;
@@ -65,40 +66,21 @@ class Problem
 template <class T, class D>
 Problem<T,D>::Problem(std::string fileName, int size)
 {
-  std::ifstream ifstr;
-  ifstr.open(fileName, std::ifstream::in);
-  mInput = &ifstr;
+  mInput.open(fileName, std::ifstream::in);
   mOutput = nullptr;
 
-  mInitStack = nullptr;
-  mReadInput = nullptr;
-  mPopCondition = nullptr;
-  mPopAction = nullptr;
-  mPushCondition = nullptr;
-  mPushAction = nullptr;
-
   mContext = nullptr;
   mIndex = 0;
 
-
   mStack = new NormalStack<T> (size);
 }
 
 template <class T, class D>
 Problem<T,D>::Problem(std::string fileName, int size, int space)
 {
-  std::ifstream ifstr;
-  ifstr.open(fileName, std::ifstream::in);
-  mInput = &ifstr;
+  mInput.open(fileName, std::ifstream::in);
   mOutput = nullptr;
 
-  mInitStack = nullptr;
-  mReadInput = nullptr;
-  mPopCondition = nullptr;
-  mPopAction = nullptr;
-  mPushCondition = nullptr;
-  mPushAction = nullptr;
-
   mContext = nullptr;
   mIndex = 0;
 
@@ -128,51 +110,95 @@ void Problem<T,D>::println()
   std::cout << std::endl;
 }
 
+template <class T, class D>
+std::vector<std::string> Problem<T,D>::readLine()
+{
+  std::string str;
+  std::vector<std::string> line;
+  size_t pos=std::string::npos;
+  getline(mInput,str);
+  std::cout << "Debug 4 : " << str << std::endl;
+  while (true){
+    pos=str.find_first_of(",");
+    line.push_back(str.substr(0,pos));
+    std::cout << "Debug 4.2 : " << str << " and pos = " << pos << std::endl;
+    str.erase(0,pos+1);
+    std::cout << "Debug 4.1 : " << str << " and pos = " << pos << std::endl;
+    if (pos=std::string::npos){
+      line.push_back(str.substr(0,pos));
+      str.erase(0,pos);
+      break;
+    }
+  }
+  return line;
+}
+
+
 /** Running the stack **/
 template <class T, class D>
 void Problem<T,D>::run() {
-  while (true) {
-    D elt = mInput();
-    while (true && mPopConditon(elt)) {
-      (*mStack).pop();
+  initStack();
+  while ((mInput.good())) {
+    std::cout << "Debug 1" << std::endl;
+    std::vector<std::string> line = readLine();
+    if ( (line.front()== "-1") || (line.front()=="") ) {
+      break;
     }
-    if (mPushCondition()) {
-      (*mStack).push(elt);
+    std::cout << "Debug 2 : size = " << line.size() << std::endl;
+    std::cout << "Context = " << (line.back()) << std::endl;
+    D data = readInput(line);
+    mIndex++; // Might have to move
+    while ( (emptystack()) && (popCondition(data)) ) {
+      Data<D> elt = pop();
+      popAction(elt);
+    }
+    if (pushCondition(data)) {
+      Data<D> elt (mIndex,data);
+      pushAction(elt);
+      push(elt);
+      println();
     }
   }
 }
 
-/** Setters **/
-template <class T, class D>
-void Problem<T,D>::setReadInput(D (*functionPointer)()){
-  mReadInput = functionPointer;
-}
-template <class T, class D>
-void Problem<T,D>::setInitStack(void (*functionPointer)()){
-  mInitStack = functionPointer;
-}
+/** Push, pop, and top **/
 template <class T, class D>
-void Problem<T,D>::setPopAction(void (*functionPointer)()){
-  mPopAction = functionPointer;
+void Problem<T,D>::push(Data<D> elt){
+  (*mStack).push(elt);
 }
 template <class T, class D>
-void Problem<T,D>::setPopCondition(ProblemBoolFn functionPointer){
-  mPopConditon = functionPointer;
+Data<D> Problem<T,D>::pop(){
+  return (*mStack).pop();
 }
 template <class T, class D>
-void Problem<T,D>::setPushAction(void (*functionPointer)()){
-  mPushAction = functionPointer;
+Data<D> Problem<T,D>::top(int k){
+  return (*mStack).top(k);
 }
 template <class T, class D>
-void Problem<T,D>::setPushCondition(bool (*functionPointer)()){
-  mPushConditon = functionPointer;
+bool Problem<T,D>::emptystack(){
+  return (*mStack).isempty();
 }
 
+/** Setters **/
 template <class T, class D>
 void Problem<T,D>::setOutput(std::string fileName){
   std::ofstream ofstr;
   ofstr.open(fileName, std::ofstream::out);
   mOutput = &ofstr;
 }
 
+template <class T, class D>
+void Problem<T,D>::setContext(T context){
+  std::cout << "setContext, T = " << context << std::endl;
+  mContext = &context;
+  std::cout << "setContext, *mContext = " << (*mContext) << std::endl;
+  std::cout << "setContext, *mContext = " << getContext() << std::endl;
+}
+
+/** Getters **/
+template <class T, class D>
+T Problem<T,D>::getContext(){
+  return *mContext;
+}
+
 #endif /* PROBLEM */

include/stack.hpp

@@ -12,6 +12,7 @@ class Stack
   virtual Data<D> pop() = 0;
   virtual void push(Data<D> data) = 0;
   virtual Data<D> top(int k) = 0;
+  virtual bool isempty() = 0;
 
   // IO
   virtual std::string toString() = 0;