Basic structure of the comrpessed stack

Author: Azzaare

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;
+}

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;
+};

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;
+}

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>>>;

exampleyago.h

@@ -0,0 +1,57 @@
+//
+// Created by yago on 16/04/19.
+//
+
+#ifndef ONEDTRAJECTORIES_ONEDTIMEPOINT_H
+#define ONEDTRAJECTORIES_ONEDTIMEPOINT_H
+
+
+#include "RunningTime.h"
+
+class oneDTimePoint {
+
+double position;
+RunningTime t;
+
+public:
+
+    oneDTimePoint(); //Default constructor
+    oneDTimePoint(double pos, RunningTime tprima)//parameter Constructor
+    {
+        position=pos;
+        t=tprima;
+    }
+    oneDTimePoint(double pos, int h,int m,int s) //parameter Constructor 2
+    {
+        position=pos;
+        t=RunningTime(h,m,s);
+    }
+
+    oneDTimePoint(const oneDTimePoint &pt); //Copy constructor
+
+    // accessor methods
+    double getPos()const{return position;};
+    RunningTime getTime()const{return t;};
+
+
+    void operator=(oneDTimePoint tprima) //assignment
+    {
+        position=tprima.getPos();
+        t=tprima.getTime();
+    }
+
+    void write(std::ostream& os)
+    {
+        os << "running at km point: (" << position << ") at time " << t;
+    }
+    friend std::ostream& operator<<(std::ostream& os, oneDTimePoint tp ) 
+    {
+        tp.write(os);
+        return os;
+    }
+
+
+};
+
+
+#endif //ONEDTRAJECTORIES_ONEDTIMEPOINT_H

main.cpp

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

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]);
+  }

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
+};

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;
+}

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;
+};