Interface formatting (all hpp files)

Author: Azzaare

include/buffer.hpp

@@ -1,16 +1,24 @@
 #ifndef BUFFER
 #define BUFFER
 
-/** Buffer class : declaration **/
+/*==============================================================================
+  Includes
+==============================================================================*/
 #include "data.hpp"
 #include <vector>
 #include <string>
 #include <iostream>
 #include <memory>
 
+/*==============================================================================
+  Class      : template (D datas)
+  Extensions :
+  Aliases    :
+  Friends   ->
+            <-
+==============================================================================*/
 template <class D>
-class Buffer
-{
+class Buffer{
 public:
   // Constructor
   Buffer<D>(int size = 0);
@@ -40,12 +48,11 @@ class Buffer
   ExplicitPointer<D> mExplicit;
 };
 
-
-
-/** Constructors **/
+/*==============================================================================
+  Constructors
+==============================================================================*/
 template <class D>
-Buffer<D>::Buffer(int size)
-{
+Buffer<D>::Buffer(int size){
   mSize = size;
   mStart = 0;
 
@@ -54,81 +61,77 @@ Buffer<D>::Buffer(int size)
   mExplicit = xplicit;
 }
 
-/** Getters **/
+/*==============================================================================
+  Getters
+==============================================================================*/
 template <class D>
-int Buffer<D>::getSize()
-{
+int Buffer<D>::getSize(){
   return mSize;
 }
 template <class D>
-int Buffer<D>::getStart()
-{
+int Buffer<D>::getStart(){
   return mStart;
 }
-
 template <class D>
-Data<D> Buffer<D>::top(int k)
-{
+Data<D> Buffer<D>::top(int k){
   if (k < getSize()) {
     int index = (k + mStart - 1) % mSize; // -1 match the start of vectors at 0
     return *(mExplicit[index]);
   }
   throw "Access to a top element bigger than the size of the buffer";
 }
 
-/** Setters **/
+/*==============================================================================
+  Setters
+==============================================================================*/
 template <class D>
-void Buffer<D>::setStart(int start)
-{
+void Buffer<D>::setStart(int start){
   mStart = start;
 }
 template <class D>
-void Buffer<D>::setStart()
-{
+void Buffer<D>::setStart(){
   mStart = (mStart + 1) % mSize;
 }
 template <class D>
-void Buffer<D>::setData(std::shared_ptr<Data<D>> elt, int id)
-{
+void Buffer<D>::setData(std::shared_ptr<Data<D>> elt, int id){
   int index = (id + mStart - 1) % mSize; // -1 match the start of vectors at 0
   mExplicit[index] = elt;
 }
 
-/** Push and Pop**/
+/*==============================================================================
+  Stack Functions: push, pop
+==============================================================================*/
 template <class D>
-void Buffer<D>::push(std::shared_ptr<Data<D>> elt)
-{
+void Buffer<D>::push(std::shared_ptr<Data<D>> elt){
   if (mSize > 0) {
     setData(elt, mStart+1);
   }
 }
 
 template <class D>
-void Buffer<D>::pop()
-{
+void Buffer<D>::pop(){
   setStart();
 }
 
-/** IO **/
+/*==============================================================================
+  IO : toString
+==============================================================================*/
 template <class D>
-std::string Buffer<D>::toString()
-{
+std::string Buffer<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()
-{
+void Buffer<D>::print(){
   std::string str;
   str = this->toString();
   std::cout << str;
 }
 template <class D>
-void Buffer<D>::println()
-{
+void Buffer<D>::println(){
   this->print();
   std::cout << "\n";
 }

include/component.hpp

@@ -1,16 +1,23 @@
 #ifndef COMPONENT
 #define COMPONENT
 
-/**** Compressed Stack: declarations ****/
+/*==============================================================================
+  Includes
+==============================================================================*/
 #include "sign.hpp"
 #include "stack.hpp"
 #include <string>
 #include <memory>
 
-/* Component of a Compressed Stack */
+/*==============================================================================
+  Class      : template (T context, D datas)
+  Extensions :
+  Aliases    :
+  Friends   ->
+            <-
+==============================================================================*/
 template <class T, class D>
-class Component
-{
+class Component{
 public:
   Component<T,D>(int space, int depth);
 
@@ -50,10 +57,11 @@ class Component
   std::shared_ptr<Signature<T>> mSign;
 };
 
-/** Constructors **/
+/*==============================================================================
+  Constructors
+==============================================================================*/
 template <class T, class D>
-Component<T,D>::Component(int space, int depth)
-{
+Component<T,D>::Component(int space, int depth){
   mSign = std::shared_ptr<Signature<T>> (nullptr);
 
   Levels<T> partial = initLevels<T>(space, depth);
@@ -64,10 +72,11 @@ Component<T,D>::Component(int space, int depth)
   mExplicit = xplicit;
 }
 
-/** IO **/
+/*==============================================================================
+  IO
+==============================================================================*/
 template <class T>
-std::string levelsToStringInComponent(Levels<T> levels)
-{
+std::string levelsToStringInComponent(Levels<T> levels){
   std::string str;
   str = "";
   int index = 0;
@@ -81,8 +90,7 @@ std::string levelsToStringInComponent(Levels<T> levels)
 }
 
 template <class T, class D>
-std::string Component<T,D>::toString()
-{
+std::string Component<T,D>::toString(){
   std::string str;
   str = levelsToStringInComponent(mPartial);
   str += "\t\t\tExplicit->\n";
@@ -115,7 +123,9 @@ bool Component<T,D>::isExplicitEmpty(){
   return (mExplicit.empty());
 }
 
-/** Push and pop **/
+/*==============================================================================
+  Stack Functions: push, pop, top, topIndex
+==============================================================================*/
 template <class T, class D>
 void Component<T,D>::pushExplicit(std::shared_ptr<Data<D>> elt){
   mExplicit.push_back(elt);
@@ -147,7 +157,9 @@ int Component<T,D>::topIndex(int lvl){
   return index;
 }
 
-/** Setters **/
+/*==============================================================================
+  Setters
+==============================================================================*/
 template <class T, class D>
 void Component<T,D>::setSignature(std::shared_ptr<Signature<T>> sign){
   mSign = sign;
@@ -169,7 +181,9 @@ void Component<T,D>::clearExplicit(int space){
   mExplicit.reserve(space);
 }
 
-// Getters
+/*==============================================================================
+  Getters
+==============================================================================*/
 template <class T, class D>
 Signature<T> Component<T,D>::getSign(){
   return *mSign;

include/compressedStack.hpp

@@ -1,7 +1,9 @@
 #ifndef COMPRESSEDSTACK
 #define COMPRESSEDSTACK
 
-/**** Compressed Stack: declarations ****/
+/*==============================================================================
+  Includes
+==============================================================================*/
 #include "sign.hpp"
 #include "stack.hpp"
 #include "component.hpp"
@@ -11,10 +13,15 @@
 #include <cmath>
 #include <memory>
 
-/* Compressed Stack itself */
+/*==============================================================================
+  Class      : template (T context, D datas)
+  Extensions :
+  Aliases    :
+  Friends   ->
+            <-
+==============================================================================*/
 template <class T, class D>
-class CompressedStack: public Stack<D>
-{
+class CompressedStack: public Stack<D>{
 public:
   CompressedStack<T,D>(int size, int space, int buffer, std::shared_ptr<T> context, std::streampos position);
 
@@ -56,13 +63,12 @@ class CompressedStack: public Stack<D>
   std::shared_ptr<T> mContext;
 };
 
-/** Constructors **/
+/*==============================================================================
+  Constructors
+==============================================================================*/
 template <class T, class D>
 CompressedStack<T,D>::CompressedStack(int size, int space, int buffer, std::shared_ptr<T> context, std::streampos position)
-: mFirst(size,space)
-, mSecond(size,space)
-, mBuffer(buffer)
-{
+:mFirst(size,space), mSecond(size,space), mBuffer(buffer){
   mSize = size;
   mSpace = space;
   mDepth = (int) ceil(log(size)/log(space)-.1); // - 1;
@@ -74,10 +80,11 @@ CompressedStack<T,D>::CompressedStack(int size, int space, int buffer, std::shar
   mContext = context;
 }
 
-/** IO **/
+/*==============================================================================
+  IO : toString
+==============================================================================*/
 template <class T, class D>
-std::string CompressedStack<T,D>::toString()
-{
+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, ";
@@ -93,19 +100,19 @@ std::string CompressedStack<T,D>::toString()
 }
 
 template <class T, class D>
-void CompressedStack<T,D>::print()
-{
+void CompressedStack<T,D>::print(){
   std::cout << this->toString();
 }
 
 template <class T, class D>
-void CompressedStack<T,D>::println()
-{
+void CompressedStack<T,D>::println(){
   this->print();
   std::cout << std::endl;
 }
 
-/** Pushes, pops and accesses **/
+/*==============================================================================
+  Stack Functions: push, pop, isempty
+==============================================================================*/
 template <class T, class D>
 bool CompressedStack<T,D>::isempty(){
   return (mFirst.isempty() && mSecond.isempty());
@@ -195,24 +202,21 @@ void CompressedStack<T,D>::pushCompressed(std::shared_ptr<Data<D>> elt, int lvl)
 }
 
 template <class T, class D>
-Data<D> CompressedStack<T,D>::pop()
-{
+Data<D> CompressedStack<T,D>::pop(){
   Data<D> d (1,1);
   return d;
 }
 
 template <class T, class D>
-Data<D> CompressedStack<T,D>::top(int k)
-{
+Data<D> CompressedStack<T,D>::top(int k){
   if (k == 0) {
     return top();
   }
   return mBuffer.top(k);
 }
 
 template <class T, class D>
-Data<D> CompressedStack<T,D>::top()
-{
+Data<D> CompressedStack<T,D>::top(){
   if (mFirst.isExplicitEmpty()) {
     return mSecond.top();
   }