Completed the structure for Compressed Stack (with minimal tests)

Author: Azzaare

build/smartstack

@@ -0,0 +1,81 @@
+#ifndef COMPONENT
+#define COMPONENT
+
+/**** 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>();
+  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;
+};
+
+/** Constructors **/
+template <class T, class D>
+Component<T,D>::Component()
+{
+  std::cout << "Using default constructor for Component" << std::endl;
+}
+
+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.reserve(space);
+  mExplicit = xplicit;
+}
+
+/** IO **/
+template <class T>
+std::string levelsToStringInComponent(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" + blockToString(*it) + "\n";
+  }
+  return str;
+}
+
+template <class T, class D>
+std::string Component<T,D>::toString()
+{
+  std::string str;
+  str = levelsToStringInComponent(mPartial);
+  str += "\t\t\tExplicit->\n";
+  str += explicitToString(mExplicit);
+  str += "\t\t\tSignature->\n";
+  //str += (&mSign).toString() + "\n";
+  return str;
+}
+
+#endif /* COMPONENT */

include/component.hpp

@@ -4,30 +4,9 @@
 /**** Compressed Stack: declarations ****/
 #include "sign.hpp"
 #include "stack.hpp"
+#include "component.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;
-};
-
+#include <cmath>
 
 /* Compressed Stack itself */
 template <class T, class D>
@@ -36,8 +15,15 @@ class CompressedStack:Stack<D>
 public:
   CompressedStack<T,D>(int size, int space);
 
+  // Internals
+  Data<D> top(int k);
+  void push(Data<D> data);
+  Data<D> pop();
+
   // IO
   std::string toString();
+  void print();
+  void println();
 
 private:
   // Structure constraints
@@ -55,56 +41,21 @@ class CompressedStack:Stack<D>
 };
 
 /** 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;
-}
+   mSize = size;
+   mSpace = space;
+   mDepth = (int) ceil(log(size)/log(space)-.1); // - 1;
 
-/** 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;
-}
+   mPosition = 0;
 
-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;
+   mFirst = Component<T,D>(mSpace, mDepth);
+   mSecond = Component<T,D>(mSpace, mDepth);
+   mCompressed = initBlock<T>(mSpace);
 }
 
+/** IO **/
 template <class T, class D>
 std::string CompressedStack<T,D>::toString()
 {
@@ -121,4 +72,36 @@ std::string CompressedStack<T,D>::toString()
   return str;
 }
 
+template <class T, class D>
+void CompressedStack<T,D>::print()
+{
+  std::cout << this->toString();
+}
+
+template <class T, class D>
+void CompressedStack<T,D>::println()
+{
+  this->print();
+  std::cout << std::endl;
+}
+
+/** Pushes, pops and accesses **/
+template <class T, class D>
+void CompressedStack<T,D>::push(Data<D> data)
+{
+
+}
+
+template <class T, class D>
+Data<D> CompressedStack<T,D>::pop()
+{
+
+}
+
+template <class T, class D>
+Data<D> CompressedStack<T,D>::top(int k)
+{
+
+}
+
 #endif /* COMPRESSEDSTACK */

include/compressedStack.hpp

@@ -73,21 +73,21 @@ void Data<D>::println()
 }
 
 template <class D>
-std::string toString(Explicit<D> xplicit)
+std::string explicitToString(Explicit<D> xplicit)
 {
   std::string str;
   str = "{";
   for (typename Explicit<D>::iterator it = xplicit.begin() ; it != xplicit.end(); ++it)
     str += (*it).toString() + ",";
-  str.back() = '}';
+  str.back() = ')';
   return str;
 }
 
 template <class D>
 void printExplicit(Explicit<D> xplicit)
 {
   std::string str;
-  str = toString(xplicit);
+  str = explicitToString(xplicit);
   std::cout << str;
 }
 template <class D>

include/data.hpp

@@ -36,11 +36,11 @@ class Signature
 
 /* Derived types: Block and Levels */
 // A Partially Compressed Block is composed of the signatures of its SubBlocks
-template<class T> using Block = std::vector<T,Signature<T>>;
+template<class T> using Block = std::vector<Signature<T>>;
 template<class T> Block<T> initBlock(int space);
 
 // Each level of compressed Blocks (first and second) are stored in Levels
-template<class T> using Levels = std::vector<T,Block<T>>;
+template<class T> using Levels = std::vector<Block<T>>;
 template<class T> Levels<T> initLevels(int space, int depth);
 
 /** Constructors **/
@@ -54,6 +54,28 @@ Signature<T>::Signature(int index, int position, T context)
   mContext = context;
 }
 
+template <class T>
+Block<T> initBlock(int space)
+{
+  Block<T> block;
+  block.reserve(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_back(block);
+   }
+   levels.reserve(depth-1);
+
+   return levels;
+}
+
 /** Setters **/
 template <class T>
 void Signature<T>::setLast(int index)
@@ -107,7 +129,7 @@ void Signature<T>::println()
 }
 
 template<class T>
-std::string toString(Block<T> block)
+std::string blockToString(Block<T> block)
 {
   std::string str;
   str = "[";
@@ -119,4 +141,11 @@ std::string toString(Block<T> block)
   return str;
 }
 
+template<class T>
+std::string levelsToString(Levels<T> levels)
+{
+  std::string str;
+  return str;
+}
+
 #endif /* SIGN */

include/sign.hpp

@@ -2,6 +2,7 @@
 #include "../include/sign.hpp"
 #include "../include/data.hpp"
 #include "../include/normalStack.hpp"
+#include "../include/compressedStack.hpp"
 
 // Test Signature
 void testSign()
@@ -45,10 +46,20 @@ void testNormalStack()
   stack.println();
 }
 
+// Test normal stack
+void testCompressedStack()
+{
+  Block<int> block = initBlock<int>(5);
+  Levels<int> lvls = initLevels<int>(3, 3);
+  Component<int, int> comp(3,5);
+  CompressedStack<int, int> stack = CompressedStack<int, int>(81,3);
+}
+
 // Main
 int main(int argc, char const *argv[]) {
   testSign();
   testData();
   testNormalStack();
+  testCompressedStack();
   return 0;
 }