Moved the code to sources/

Author: Azzaare

sources/compressedStack.cpp

@@ -0,0 +1,24 @@
+/**** Compressed Stack: implementations ****/
+#include "compressedStack.hpp"
+
+/** Constructors **/
+template <class T, class D>
+Component<T,D>::Component(int space, int depth)
+{
+  mSign = nullptr;
+
+  Levels<T> partial = initLevels<T>(space, depth);
+  mPartial = partial;
+
+  Explicit<D> xplicit;
+  xplicit.resize(space);
+  mExplicit = xplicit;
+}
+
+template <class T, class D>
+CompressedStack<T,D>::CompressedStack(int size, int space)
+{
+  mSize = size;
+  mSpace = space;
+  mDepth = 0;
+}

sources/compressedStack.hpp

@@ -0,0 +1,41 @@
+/**** Compressed Stack: declarations ****/
+#include "sign.hpp"
+#include "stack.hpp"
+
+/* Component of a Compressed Stack */
+template <class T, class D>
+class Component
+{
+public:
+  Component<T,D>(int space, int depth);
+
+  // Setters
+  void setSignature(Signature<T> sign);
+
+private:
+  Levels<T> mPartial;
+  Explicit<D> mExplicit;
+  Signature<T>* mSign;
+};
+
+
+/* Compressed Stack itself */
+template <class T, class D>
+class CompressedStack:Stack<D>
+{
+public:
+  CompressedStack<T,D>(int size, int space);
+private:
+  // Structure constraints
+  int mSize;  // (Expected) size of the input in #elements
+  int mSpace; // Maximum space order of the compressed stack
+  int mDepth; // Depth (#levels of compression) based on size and space
+
+  // Position of previous input (before reading)
+  int mPosition;
+
+  // First, Second, and Compressed components
+  Component<T,D> mFirst;
+  Component<T,D> mSecond;
+  Block<T> mCompressed;
+};

sources/data.cpp

@@ -0,0 +1,14 @@
+/** Data class : implementation **/
+#include "data.hpp"
+
+/** Getters **/
+template <class D>
+int Data<D>::getIndex()
+{
+  return mIndex;
+}
+template <class D>
+D Data<D>::getData()
+{
+  return mData;
+}

sources/data.hpp

@@ -0,0 +1,19 @@
+/** Data class : declaration **/
+#include <vector>
+#include <stack>
+
+template <class D>
+class Data
+{
+public:
+  // Getters
+  int getIndex();
+  D getData();
+
+private:
+  int mIndex;
+  D mData;
+};
+
+template<class D>
+using Explicit = std::stack<Data<D>,std::vector<Data<D>>>;

sources/main.cpp

@@ -0,0 +1,3 @@
+// Main file of the compressed stack library
+
+#include "sign.hpp"

sources/normalStack.cpp

@@ -0,0 +1,21 @@
+/**** Normal Stack: definition ****/
+#include "normalStack.hpp"
+
+template <class D>
+  Data<D> NormalStack<D>::pop()
+  {
+    return mDatas.pop();
+  }
+
+template <class D>
+  void NormalStack<D>::push(Data<D> data)
+  {
+    mDatas.push(data);
+  }
+
+template <class D>
+  Data<D>* NormalStack<D>::top(int k)
+  {
+    int index = mDdatas.size() - k;
+    return &(data[index]);
+  }

sources/normalStack.hpp

@@ -0,0 +1,14 @@
+/**** Normal Stack: declaration ****/
+#include "stack.hpp"
+
+template <class D>
+class NormalStack:Stack<D>
+{
+public:
+  Data<D> pop();
+  void push(Data<D> newdata);
+  Data<D>* top(int k);
+
+private:
+  Explicit<D> mDatas; // vector of Data
+};

sources/problem.cpp

@@ -0,0 +1,12 @@
+/**** Problem : implementation ****/
+#include "problem.hpp"
+
+
+/** Constructors **/
+template <class T, class D>
+Problem<T,D>::Problem(std::string fileName)
+{
+  std::ifstream ifstr;
+  ifstr.open(fileName, std::ifstream::in);
+  mInput = ifstr;
+}

sources/problem.hpp

@@ -0,0 +1,36 @@
+/**** Problem : declaration ****/
+#include "stack.hpp"
+#include <stdbool.h>
+#include <fstream>
+#include <string>
+
+template <class T, class D>
+class Problem
+{
+public:
+  Problem<T,D>(std::string fileName);
+
+  // Functions of the problem
+  //void init();
+  //D read();
+
+private:
+  // Input/Ouput
+  std::ifstream mInput;
+  std::ofstream* mOutput; // output file is optional
+
+  // Stack Functions: defined by user
+  void (*mInitStack)();
+  D    (*mReadInput)();
+  bool (*mPopCondition)();
+  void (*mPopAction)();
+  bool (*mPushCondition)();
+  void (*mPushAction)();
+
+  // Problem internal during run
+  T* mContext;
+  int mIndex;
+
+  // Stack: Normal or Compressed
+  Stack<D> mStack;
+};

sources/sign.cpp

@@ -0,0 +1,65 @@
+/*** Signature : implementation ***/
+#include "sign.hpp"
+
+/** Constructors **/
+// Signature
+template <class T>
+Signature<T>::Signature(int index, int position, T context)
+{
+  mFirst = index;
+  mLast = index;
+  mPosition = position;
+  mContext = context;
+}
+
+/** Setters **/
+template <class T>
+void Signature<T>::setLast(int index)
+{
+  mLast = index;
+}
+
+/** Getters **/
+template <class T>
+int Signature<T>::getFirst()
+{
+  return mFirst;
+}
+template <class T>
+int Signature<T>::getLast()
+{
+  return mLast;
+}
+template <class T>
+int Signature<T>::getPosition()
+{
+  return mPosition;
+}
+template <class T>
+T Signature<T>::getContext()
+{
+  return mContext;
+}
+
+/** New Block and Levels **/
+template<class T>
+Block<T> initBlock(int space)
+{
+  Block<T> block;
+  block.resize(space);
+  return block;
+}
+
+template<class T>
+Levels<T> initLevels(int space, int depth)
+{
+  Levels<T> levels;
+  for (int lvl = 1; lvl < depth; lvl++)
+   {
+    Block<T> block = initBlock<T>(space);
+    levels.push(block);
+   }
+   levels.resize(depth-1);
+
+   return levels;
+}