POO optimal

Author: Azzaare

include/buffer.hpp

@@ -14,67 +14,57 @@
   Class      : template (D datas)
   Extensions :
   Aliases    :
-  Friends   ->
+  Friends   -> CompressedStack
             <-
 ==============================================================================*/
-template <class D>
+template <class T, class D> class CompressedStack; // Required for the friendship
+template <class T, class D>
 class Buffer{
-public:
+  friend class CompressedStack<T,D>;
+
+private:
   // Constructor
-  Buffer<D>(int size = 0);
+  Buffer<T,D>(int size = 0);
 
   // Getters
-  Data<D> top(int k);
-  int getSize();
-  int getStart();
+  Data<T,D> top(int k);
 
   // Setters
   void setStart();
-  void setStart(int start);
-  void setData(std::shared_ptr<Data<D>> elt, int index);
+  void setData(std::shared_ptr<Data<T,D>> elt, int index);
 
   // Push and Pop
-  void push(std::shared_ptr<Data<D>> elt);
+  void push(std::shared_ptr<Data<T,D>> elt);
   void pop();
 
   // IO
   std::string toString();
-  void print();
-  void println();
 
-private:
+  // Members
   int mSize;
   int mStart;
-  ExplicitPointer<D> mExplicit;
+  ExplicitPointer<T,D> mExplicit;
 };
 
 /*==============================================================================
   Constructors
 ==============================================================================*/
-template <class D>
-Buffer<D>::Buffer(int size){
+template <class T, class D>
+Buffer<T,D>::Buffer(int size){
   mSize = size;
   mStart = 0;
 
-  ExplicitPointer<D> xplicit = initExplicitPointer<D>();
+  ExplicitPointer<T,D> xplicit = initExplicitPointer<T,D>();
   xplicit.reserve(size);
   mExplicit = xplicit;
 }
 
 /*==============================================================================
   Getters
 ==============================================================================*/
-template <class D>
-int Buffer<D>::getSize(){
-  return mSize;
-}
-template <class D>
-int Buffer<D>::getStart(){
-  return mStart;
-}
-template <class D>
-Data<D> Buffer<D>::top(int k){
-  if (k < getSize()) {
+template <class T, class D>
+Data<T,D> Buffer<T,D>::top(int k){
+  if (k < mSize) {
     int index = (k + mStart - 1) % mSize; // -1 match the start of vectors at 0
     return *(mExplicit[index]);
   }
@@ -84,56 +74,41 @@ Data<D> Buffer<D>::top(int k){
 /*==============================================================================
   Setters
 ==============================================================================*/
-template <class D>
-void Buffer<D>::setStart(int start){
-  mStart = start;
-}
-template <class D>
-void Buffer<D>::setStart(){
+template <class T, class D>
+void Buffer<T,D>::setStart(){
   mStart = (mStart + 1) % mSize;
 }
-template <class D>
-void Buffer<D>::setData(std::shared_ptr<Data<D>> elt, int id){
+template <class T, class D>
+void Buffer<T,D>::setData(std::shared_ptr<Data<T,D>> elt, int id){
   int index = (id + mStart - 1) % mSize; // -1 match the start of vectors at 0
   mExplicit[index] = elt;
 }
 
 /*==============================================================================
   Stack Functions: push, pop
 ==============================================================================*/
-template <class D>
-void Buffer<D>::push(std::shared_ptr<Data<D>> elt){
+template <class T, class D>
+void Buffer<T,D>::push(std::shared_ptr<Data<T,D>> elt){
   if (mSize > 0) {
     setData(elt, mStart+1);
   }
 }
 
-template <class D>
-void Buffer<D>::pop(){
+template <class T, class D>
+void Buffer<T,D>::pop(){
   setStart();
 }
 
 /*==============================================================================
   IO : toString
 ==============================================================================*/
-template <class D>
-std::string Buffer<D>::toString(){
+template <class T, class D>
+std::string Buffer<T,D>::toString(){
   std::string str;
   str = "\t\tBuffer size is " + std::to_string(mSize);
   str += " and start at index " + std::to_string(mStart) + "\n";
   str += explicitPointerToString(mExplicit);
   return str;
 }
-template <class D>
-void Buffer<D>::print(){
-  std::string str;
-  str = this->toString();
-  std::cout << str;
-}
-template <class D>
-void Buffer<D>::println(){
-  this->print();
-  std::cout << "\n";
-}
 
 #endif /* BUFFER */

include/component.hpp

@@ -13,74 +13,64 @@
   Class      : template (T context, D datas)
   Extensions :
   Aliases    :
-  Friends   ->
-            <-
+  Friends   -> CompressedStack
+            <- Data, Signature
 ==============================================================================*/
+template <class T, class D> class CompressedStack; // Required for the friendship
 template <class T, class D>
 class Component{
-public:
-  Component<T,D>(int space, int depth);
+  friend class CompressedStack<T,D>;
 
-  // Getters
-  Signature<T> getSign();
-  std::shared_ptr<Signature<T>> getSignPtr();
-  int getLastSign();
-  ExplicitPointer<D> getExplicit();
+private:
+  Component<T,D>(int space, int depth);
 
   // Setters
-  void setSignature(std::shared_ptr<Signature<T>> sign);
-  void setLastSign(int index);
-  void setExplicit(ExplicitPointer<D> xplicit);
   void clearExplicit(int space);
 
   // Push and pop
-  void pushExplicit(std::shared_ptr<Data<D>> elt);
-  void push(Signature<T> sign, int lvl);
-  Data<D> top();
-  Signature<T> top(int lvl);
-  int topIndex(int lvl);
-  int topIndex();
+  void pushExplicit(std::shared_ptr<Data<T,D>> elt);
+  void push(Signature<T,D> sign, int lvl);
+  Data<T,D> top();
+  Signature<T,D> top(int lvl);
+  int topIndex(int lvl = 0);
 
   // IO
   std::string toString();
-  void print();
-  void println();
 
   // State
   bool isempty();
   bool isempty(int lvl);
   bool isExplicitEmpty();
 
-private:
-  Levels<T> mPartial;
-  ExplicitPointer<D> mExplicit;
-  std::shared_ptr<Signature<T>> mSign;
+  Levels<T,D> mPartial;
+  ExplicitPointer<T,D> mExplicit;
+  std::shared_ptr<Signature<T,D>> mSign;
 };
 
 /*==============================================================================
   Constructors
 ==============================================================================*/
 template <class T, class D>
 Component<T,D>::Component(int space, int depth){
-  mSign = std::shared_ptr<Signature<T>> (nullptr);
+  mSign = std::shared_ptr<Signature<T,D>> (nullptr);
 
-  Levels<T> partial = initLevels<T>(space, depth);
+  Levels<T,D> partial = initLevels<T,D>(space, depth);
   mPartial = partial;
 
-  ExplicitPointer<D> xplicit = initExplicitPointer<D>();
+  ExplicitPointer<T,D> xplicit = initExplicitPointer<T,D>();
   xplicit.reserve(space);
   mExplicit = xplicit;
 }
 
 /*==============================================================================
-  IO
+  IO : levelsToStringInComponent, toString
 ==============================================================================*/
-template <class T>
-std::string levelsToStringInComponent(Levels<T> levels){
+template <class T, class D>
+std::string levelsToString(Levels<T,D> levels){
   std::string str;
   str = "";
   int index = 0;
-  for (typename Levels<T>::iterator it = levels.begin() ; it != levels.end(); ++it)
+  for (typename Levels<T,D>::iterator it = levels.begin() ; it != levels.end(); ++it)
   {
     index++;
     str += "\t\t\tLevel" + std::to_string(index) + "->\n";
@@ -92,15 +82,17 @@ std::string levelsToStringInComponent(Levels<T> levels){
 template <class T, class D>
 std::string Component<T,D>::toString(){
   std::string str;
-  str = levelsToStringInComponent(mPartial);
+  str = levelsToString(mPartial);
   str += "\t\t\tExplicit->\n";
   str += explicitPointerToString(mExplicit);
   str += "\t\t\tSignature->\n";
   //str += (&mSign).toString() + "\n";
   return str;
 }
 
-/* State of the component */
+/*==============================================================================
+  Stack Functions: push, pop, top, topIndex, isempty, isExplicitEmpty
+==============================================================================*/
 template <class T, class D>
 bool Component<T,D>::isempty(){
   bool b = bool (mSign);
@@ -123,85 +115,40 @@ bool Component<T,D>::isExplicitEmpty(){
   return (mExplicit.empty());
 }
 
-/*==============================================================================
-  Stack Functions: push, pop, top, topIndex
-==============================================================================*/
 template <class T, class D>
-void Component<T,D>::pushExplicit(std::shared_ptr<Data<D>> elt){
+void Component<T,D>::pushExplicit(std::shared_ptr<Data<T,D>> elt){
   mExplicit.push_back(elt);
 }
 template <class T, class D>
-void Component<T,D>::push(Signature<T> sign, int lvl){
+void Component<T,D>::push(Signature<T,D> sign, int lvl){
   mPartial[lvl].push_back(sign);
 }
 
 template <class T, class D>
-Data<D> Component<T,D>::top(){
+Data<T,D> Component<T,D>::top(){
   return *(mExplicit.back());
 }
 template <class T, class D>
-Signature<T> Component<T,D>::top(int lvl){
+Signature<T,D> Component<T,D>::top(int lvl){
   return mPartial[lvl].back();
 }
 
-template <class T, class D>
-int Component<T,D>::topIndex(){
-  Data<D> elt = top();
-  int index = elt.getIndex();
-  return index;
-}
 template <class T, class D>
 int Component<T,D>::topIndex(int lvl){
-  Signature<T> sign = top(lvl);
-  int index = sign.getLast();
-  return index;
+  if (lvl == 0) {
+    return top().mIndex;
+  } else {
+    return top(lvl).mLast;
+  }
 }
 
 /*==============================================================================
   Setters
 ==============================================================================*/
-template <class T, class D>
-void Component<T,D>::setSignature(std::shared_ptr<Signature<T>> sign){
-  mSign = sign;
-}
-
-template <class T, class D>
-void Component<T,D>::setLastSign(int index){
-  mSign->setLast(index);
-}
-
-template <class T, class D>
-void Component<T,D>::setExplicit(ExplicitPointer<D> xplicit){
-  mExplicit = xplicit;
-}
-
 template <class T, class D>
 void Component<T,D>::clearExplicit(int space){
   mExplicit.clear();
   mExplicit.reserve(space);
 }
 
-/*==============================================================================
-  Getters
-==============================================================================*/
-template <class T, class D>
-Signature<T> Component<T,D>::getSign(){
-  return *mSign;
-}
-
-template <class T, class D>
-std::shared_ptr<Signature<T>> Component<T,D>::getSignPtr(){
-  return mSign;
-}
-
-template <class T, class D>
-int Component<T,D>::getLastSign(){
-  return mSign->getLast();
-}
-
-template <class T, class D>
-ExplicitPointer<D> Component<T,D>::getExplicit(){
-  return mExplicit;
-}
-
 #endif /* COMPONENT */