Update README for v1.0 and wiki creation

Author: Azzaare

README.md

@@ -2,115 +2,74 @@
 
 The CompressedStacks.cpp module/library implements the compressed stack structure. This data structure behaves like a usual stack with the usual push and pop operations, but has the additional advantage that it uses less memory. Intuitively, when large blocks of information are pushed into the stack it *compresses* the bottom part (only stores partial information). This information is recomputed whenever it is needed afterwards. See the paper of [Barba *et al.*](https://arxiv.org/abs/1208.3663) for more details on this structure.
 
+Please consult the [wiki](https://github.com/Azzaare/CompressedStacks.cpp.wiki.git) of this project for further details such as : speed and memory consumption tests, more details about installation, examples, and more.
 
-<!-- TODO: Write down a better description -->
-
-## Category of algorithms
+## Description of Stack Algorithms
 <p>
-This compressed stack structure works correctly as a normal stack for any problems that read input from a file (**Is this true?**)). However, the running time is optimal when the input would be read sequentially with a classical stack structure. For this reason, the only function implemented in the Problem template to solve it (to do a run) is the one presented below in a simplified version.
+This compressed stack structure works correctly as a normal stack for any algorithm that read input from a file in a deterministic way. However, the running time is optimal when the input would be read sequentially with a classical stack structure. For this reason, the only function implemented in the StackAlgo template to solve it (to do a run) is the one presented below in a simplified version.
 </p>
 
 ```cpp
-template <class T, class D> void Problem<T, D>::run() {
+template <class T, class D> void StackAlgo<T, D>::run() {
   initStack();
   while (notEndOfFile()) {
     D data = readInput(line);
-    while (notEmptystack() && popCondition(data)) {
-      elt = pop();
-      popAction(elt);
+    while (notEmptystack()) {
+      if (popCondition(data)) {
+        prePop(data);
+        elt = pop();
+        postPop(elt,data);
+      } else {
+        noPop(data);
+      }
     }
     if (pushCondition(data)) {
-      pushAction(data);
+      prePush(data);
       push(data);
+      postPush(data);
+    } else {
+      noPush(data);
     }
   }
+  reportStack();
 }
 ```
+## Use case
+<p>Concrete examples such as a basic test run and the convex hull problem can be found in the [wiki](https://github.com/Azzaare/CompressedStacks.cpp.wiki.git).</p>
 
-## Characterization of a problem
-<p>In the following examples, implementations of the Problem interface are given.</p>
-
-### General example : ```Instance<T,D>```
+### Abstract example : ```Instance<T,D,I>```
+<p>An instance of a Stack Algorithm is described by a set of templates parameters T, D, and I and a set of methods used in the run function above. Some of those methods might be left empty.</p>
 
 ```cpp
-#include <string>
-#include <vector>
-#include <memory>
+// T is the type of the context, D is the type of the input data and I is the type of your integer indexes.
 
-// T is the type of the context and D is the type of the input data.
-class Instance: public Problem<T,D>{
+class Instance: public StackAlgo<T,D,I>{
 public:
-  Instance(std::string filePath) : Problem<T, D>(filePath) {}
+  Instance(std::string filePath) : StackAlgo<T, D, I>(filePath) {}
 private:
-  // Functions to implement according to the problem and input
-  D readInput(std::vector<std::string> line){
-    std::cout << "Implement readInput for your instance" << std::endl;
-    return 0;
-  }
-  std::shared_ptr<T> initStack(){
-    std::cout << "Implement initStack for your instance" << std::endl;
-    std::shared_ptr<T> context(nullptr);
-    return context;
-  }
-  bool popCondition(D data){
-    std::cout << "Implement mPopCondition for your instance" << std::endl;
-    return false;
-  }
-  void popAction(Data<T, D> elt){
-    std::cout << "Implement mPopAction for your instance" << std::endl;
-  }
-  bool pushCondition(D data){
-    std::cout << "Implement mPushCondition for your instance" << std::endl;
-    return true;
-  }
-  void pushAction(Data<T, D> elt){
-    std::cout << "Implement mPushAction for your instance" << std::endl;
-  }
-};
-```
+  // Functions to implement according to the problem and input structure
+  D readInput(std::vector<std::string> line);
+  std::shared_ptr<T> initStack();
 
-### Example with ```T = int``` and ```D = int``` : ```Instance<int,int>```
-The context is initialized at 0. The data (in cvs format) is read as a pair of string such that the first string is the data  and the second is used to update the context. While the context is more than 0, the stack is poped and the context decreased by 1. If the data is more than 0 then it is pushed.
-```cpp
-class Instance : public Problem<int, int> {
-public:
-  Instance(std::string filePath) : Problem<int, int>(filePath) {}
+  bool popCondition(D data);
+  void prePop(D data);
+  void postPop(D data, Data<T, D, I> elt);
+  void noPop(D data);
 
-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(0));
-    return context;
-  }
-  bool popCondition(int data) {
-    if ((getContext() > 0)) {
-      return true;
-    }
-    return false;
-  }
-  void popAction(Data<int, int> elt) {
-    std::cout << elt.toString() << " <<<< Pop!" << std::endl;
-    setContext(getContext() - 1);
-  }
-  bool pushCondition(int data) {
-    if (data > 0) {
-      return true;
-    }
-    return false;
-  }
-  void pushAction(Data<int, int> elt) {
-    std::cout << "Push >>>> " << elt.toString() << std::endl;
-  }
+  bool pushCondition(D data);
+  void prePush(Data<T, D, I> elt);
+  void postPush(Data<T, D, I> elt);
+  void noPush(D data);
+
+  void reportStack();
 };
 ```
 
+
+
+
 ## How to run your problem
-Suppose the class Instance implement the interface Problem<T,D> (as in some examples above). You can run an instance of your problem described in the input located at <i>filepath</i>. The last command just print an output in th console of your compressed stack after the run.
+Suppose the class Instance implements the interface ```StackAlgo<T, D, I>```. You can run an instance of your problem described in the input located at <i>filepath</i>. The last command just print an output in the console of your compressed stack after the run.
 
 ```cpp
 Instance stack(filePath);