printing method

Author: Azzaare

CMakeLists.txt

@@ -0,0 +1,29 @@
+# Recent version of CMake required
+cmake_minimum_required(VERSION 3.1.0 FATAL_ERROR)
+
+# Project Name
+project(smartstack)
+
+include(CheckCXXCompilerFlag)
+CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
+CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
+if(COMPILER_SUPPORTS_CXX11)
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+elseif(COMPILER_SUPPORTS_CXX0X)
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
+else()
+        message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")
+endif()
+
+#Bring the headers into the project
+include_directories(${PROJECT_SOURCE_DIR}/include)
+
+#Bring the sources
+file(GLOB SOURCES "src/*.cpp")
+
+# Test directories
+get_property(inc_dirs DIRECTORY PROPERTY INCLUDE_DIRECTORIES)
+message("inc_dirs = ${inc_dirs}")
+
+# Executable
+add_executable(smartstack ${SOURCES})

build/smartstack

@@ -0,0 +1,124 @@
+#ifndef COMPRESSEDSTACK
+#define COMPRESSEDSTACK
+
+/**** Compressed Stack: declarations ****/
+#include "sign.hpp"
+#include "stack.hpp"
+#include <string>
+
+/* 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);
+  void setLastSign(int index);
+
+  // IO
+  std::string toString();
+  void print();
+  void println();
+
+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);
+
+  // IO
+  std::string toString();
+
+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;
+};
+
+/** 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 = initExplicit<D>();
+  xplicit.resize(space);
+  mExplicit = xplicit;
+}
+
+template <class T, class D>
+CompressedStack<T,D>::CompressedStack(int size, int space)
+{
+  mSize = size;
+  mSpace = space;
+  mDepth = 0;
+}
+
+/** IO **/
+template <class T>
+std::string toString(Levels<T> levels)
+{
+  std::string str;
+  str = "";
+  int index = 0;
+  for (typename Levels<T>::iterator it = levels.begin() ; it != levels.end(); ++it)
+  {
+    index++;
+    str += "\t\t\tLevel" + std::to_string(index) + "->\n";
+    str += "\t\t\t\t" + toString(*it) + "\n";
+  }
+  return str;
+}
+
+template <class T, class D>
+std::string Component<T,D>::toString()
+{
+  std::string str;
+  str = toString(mPartial);
+  str += "\t\t\tExplicit->\n";
+  str += toString(mExplicit);
+  str += "\t\t\tSignature->\n";
+  str += (&mSign).toString() + "\n";
+  return str;
+}
+
+template <class T, class D>
+std::string CompressedStack<T,D>::toString()
+{
+  std::string str;
+  str = "\tCompressed Stack with " + std::to_string(mSize) + " elements, ";
+  str += std::to_string(mSpace) + " space order, ";
+  str += std::to_string(mDepth) + " depth.\n";
+  str += "\t\tFirst Component\n";
+  str += mFirst.toString();
+  str += "\t\tSecond Component\n";
+  str += mSecond.toString();
+  str += "\t\tFully Compressed\n";
+  str += toString();
+  return str;
+}
+
+#endif /* COMPRESSEDSTACK */

include/compressedStack.hpp

@@ -0,0 +1,108 @@
+#ifndef DATA
+#define DATA
+
+/** Data class : declaration **/
+#include <vector>
+#include <string>
+#include <iostream>
+
+template <class D>
+class Data
+{
+public:
+  // Constructor
+  Data<D>(int index, D data);
+
+  // Getters
+  int getIndex();
+  D getData();
+
+  // IO
+  std::string toString();
+  void print();
+  void println();
+
+private:
+  int mIndex;
+  D mData;
+};
+
+template<class D> using Explicit = std::vector<Data<D>>;
+template<class D> Explicit<D> initExplicit();
+
+/** Constructors **/
+template <class D>
+Data<D>::Data(int index, D data)
+{
+  mIndex = index;
+  mData = data;
+}
+
+/** Getters **/
+template <class D>
+int Data<D>::getIndex()
+{
+  return mIndex;
+}
+template <class D>
+D Data<D>::getData()
+{
+  return mData;
+}
+
+/** IO **/
+template <class D>
+std::string Data<D>::toString()
+{
+  std::string str;
+  str = std::to_string(mIndex);
+  return str;
+}
+template <class D>
+void Data<D>::print()
+{
+  std::string str;
+  str = this->toString();
+  std::cout << str;
+}
+template <class D>
+void Data<D>::println()
+{
+  this->print();
+  std::cout << "\n";
+}
+
+template <class D>
+std::string toString(Explicit<D> xplicit)
+{
+  std::string str;
+  str = "{";
+  for (typename Explicit<D>::iterator it = xplicit.begin() ; it != xplicit.end(); ++it)
+    str += (*it).toString() + ",";
+  str.back() = '}';
+  return str;
+}
+
+template <class D>
+void printExplicit(Explicit<D> xplicit)
+{
+  std::string str;
+  str = toString(xplicit);
+  std::cout << str;
+}
+template <class D>
+void printlnExplicit(Explicit<D> xplicit)
+{
+  printExplicit(xplicit);
+  std::cout << "\n";
+}
+
+// Explicit constructor
+template <class D>
+Explicit<D> initExplicit()
+{
+  Explicit<D> xplicit;
+  return xplicit;
+}
+
+#endif /* DATA */

include/data.hpp

@@ -0,0 +1,72 @@
+#ifndef NORMALSTACK
+#define NORMALSTACK
+
+/**** Normal Stack: declaration ****/
+#include "stack.hpp"
+
+template <class D>
+class NormalStack:Stack<D>
+{
+public:
+  // Constructors
+  NormalStack<D>(int size);
+
+  // Stack common methods
+  Data<D> pop();
+  void push(Data<D> data);
+  Data<D> top(int k);
+
+  // IO
+  void print();
+  void println();
+
+private:
+  Explicit<D> mDatas; // vector of Data
+};
+
+/** Constructors **/
+template <class D>
+NormalStack<D>::NormalStack(int size)
+{
+  Explicit<D> datas;
+  datas = initExplicit<D>();
+  mDatas = datas;
+}
+
+/** Stack internal methods **/
+template <class D>
+  Data<D> NormalStack<D>::pop()
+  {
+    Data<D> data = mDatas.back();
+    mDatas.pop_back();
+    return data;
+  }
+
+template <class D>
+  void NormalStack<D>::push(Data<D> data)
+  {
+    mDatas.push_back(data);
+  }
+
+template <class D>
+  Data<D> NormalStack<D>::top(int k)
+  {
+    int index = mDatas.size() - k;
+    return mDatas.at(index);
+  }
+
+/** IO **/
+template <class D>
+void NormalStack<D>::print()
+{
+  std::cout << "\tNormal Stack (Explicit Datas)\n\t\t";
+  printExplicit(mDatas);
+}
+template <class D>
+  void NormalStack<D>::println()
+{
+  this->print();
+  std::cout << std::endl;
+}
+
+#endif /* NORMALSTACK */

include/normalStack.hpp

@@ -0,0 +1,41 @@
+#ifndef PROBLEM
+#define PROBLEM
+
+/**** 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;
+};
+
+#endif /* PROBLEM */