Simplify usage of shared_ptr<Data<T,D> in SPData<T,D>

Author: Azzaare

include/buffer.hpp

@@ -32,15 +32,15 @@ class Buffer{
 
   // Getters
   Data<T,D> top(int k);
-  std::shared_ptr<Data<T,D>> getPointer(int k);
+  SPData<T,D> getPointer(int k);
 
   // Setters
   void setStart();
-  void setData(std::shared_ptr<Data<T,D>> elt, int index);
+  void setData(SPData<T,D> elt, int index);
 
   // Push and Pop
-  void push(std::shared_ptr<Data<T,D>> elt);
-  void pop(std::shared_ptr<Data<T,D>> elt);
+  void push(SPData<T,D> elt);
+  void pop(SPData<T,D> elt);
 
   // IO
   std::string toString();
@@ -77,7 +77,7 @@ Data<T,D> Buffer<T,D>::top(int k){
 }
 
 template <class T, class D>
-std::shared_ptr<Data<T,D>> Buffer<T,D>::getPointer(int k){
+SPData<T,D> Buffer<T,D>::getPointer(int k){
   if (k < mSize) {
     int index = (k + mStart - 1) % mSize; // -1 match the start of vectors at 0
     return mExplicit[index];
@@ -93,7 +93,7 @@ void Buffer<T,D>::setStart(){
   mStart = (mStart + 1) % mSize;
 }
 template <class T, class D>
-void Buffer<T,D>::setData(std::shared_ptr<Data<T,D>> elt, int id){
+void Buffer<T,D>::setData(SPData<T,D> elt, int id){
   int index = (id + mStart - 1) % mSize; // -1 match the start of vectors at 0
   mExplicit[index] = elt;
 }
@@ -102,14 +102,14 @@ void Buffer<T,D>::setData(std::shared_ptr<Data<T,D>> elt, int id){
   Stack Functions: push, pop
 ==============================================================================*/
 template <class T, class D>
-void Buffer<T,D>::push(std::shared_ptr<Data<T,D>> elt){
+void Buffer<T,D>::push(SPData<T,D> elt){
   if (mSize > 0) {
     setData(elt, mStart+1);
   }
 }
 
 template <class T, class D>
-void Buffer<T,D>::pop(std::shared_ptr<Data<T,D>> elt){
+void Buffer<T,D>::pop(SPData<T,D> elt){
   setStart();
   setData(elt, mSize);
 }

include/component.hpp

@@ -28,7 +28,7 @@ class Component{
   void clearExplicit(int space);
 
   // Push and pop
-  void pushExplicit(std::shared_ptr<Data<T,D>> elt);
+  void pushExplicit(SPData<T,D> elt);
   void push(Signature<T,D> sign, int lvl);
   Data<T,D> top();
   Signature<T,D> top(int lvl);
@@ -116,7 +116,7 @@ bool Component<T,D>::isExplicitEmpty(){
 }
 
 template <class T, class D>
-void Component<T,D>::pushExplicit(std::shared_ptr<Data<T,D>> elt){
+void Component<T,D>::pushExplicit(SPData<T,D> elt){
   mExplicit.push_back(elt);
 }
 template <class T, class D>

include/compressedStack.hpp

@@ -45,14 +45,14 @@ class CompressedStack: public Stack<T,D>{
   Block<T,D> getFirstPartial(int lvl);
   Block<T,D> getCompressed();
   ExplicitPointer<T,D> getFirstExplicit();
-  std::shared_ptr<Data<T,D>> getExplicitData(int k);
+  SPData<T,D> getExplicitData(int k);
 
   // IO
   std::string toString();
 
   // Push Internals
-  void pushExplicit(std::shared_ptr<Data<T,D>> elt);
-  void pushCompressed(std::shared_ptr<Data<T,D>> elt, int lvl, std::streampos position);
+  void pushExplicit(SPData<T,D> elt);
+  void pushCompressed(SPData<T,D> elt, int lvl, std::streampos position);
   Data<T,D> top();
   int topIndex();
   void compress();
@@ -146,7 +146,7 @@ ExplicitPointer<T,D> CompressedStack<T,D>::getFirstExplicit(){
 }
 
 template <class T, class D>
-std::shared_ptr<Data<T,D>> CompressedStack<T,D>::getExplicitData(int k){
+SPData<T,D> CompressedStack<T,D>::getExplicitData(int k){
   if (k <= (int) mFirst.mExplicit.size()) {
     return mFirst.mExplicit[k-1];
   } else {
@@ -209,7 +209,7 @@ void CompressedStack<T,D>::resetBlock(Signature<T,D> sign, int lvl){
 template <class T, class D>
 void CompressedStack<T,D>::push(const Data<T,D> &elt, std::streampos position){
   // update the buffer (if buffer size is bigger than 0)
-  std::shared_ptr<Data<T,D>> ptr_elt = std::make_shared<Data<T,D>>(elt);
+  SPData<T,D> ptr_elt = std::make_shared<Data<T,D>>(elt);
   mBuffer.push(ptr_elt);
   // update the explicit Blocks, with possibly shifting first to second
   pushExplicit(ptr_elt);
@@ -222,9 +222,9 @@ void CompressedStack<T,D>::push(const Data<T,D> &elt, std::streampos position){
 
 // Function push for the Explicit members of the stack
 template <class T, class D>
-void CompressedStack<T,D>::pushExplicit(std::shared_ptr<Data<T,D>> elt){
+void CompressedStack<T,D>::pushExplicit(SPData<T,D> elt){
   int index = elt->mIndex;
-  std::shared_ptr<Data<T,D>> eltPtr = elt;
+  SPData<T,D> eltPtr = elt;
   Signature<T,D> sign (index, mPosition, mContext, mBuffer);
 
   // If the explicit datas of component 1 are empty we push
@@ -259,7 +259,7 @@ void CompressedStack<T,D>::pushExplicit(std::shared_ptr<Data<T,D>> elt){
 
 // Function push for the part. and fully compressed members of the stack
 template <class T, class D>
-void CompressedStack<T,D>::pushCompressed(std::shared_ptr<Data<T,D>> elt, int lvl, std::streampos position){
+void CompressedStack<T,D>::pushCompressed(SPData<T,D> elt, int lvl, std::streampos position){
   int distSubBlock = std::pow(mSpace,(mDepth - lvl));
   int distBlock = distSubBlock * mSpace;
   int index = elt->mIndex;
@@ -437,14 +437,14 @@ void CompressedStack<T,D>::reconstruct(Problem<T,D> &problem, const Signature<T,
 
 template <class T, class D>
 void CompressedStack<T,D>::popBuffer(){
-  std::shared_ptr<Data<T,D>> elt = getExplicitData(mBuffer.mSize);
+  SPData<T,D> elt = getExplicitData(mBuffer.mSize);
   mBuffer.pop(elt);
 }
 
 template <class T, class D>
 Data<T,D> CompressedStack<T,D>::pop(Problem<T,D> &problem){
   popBuffer();
-  std::shared_ptr<Data<T,D>> elt;
+  SPData<T,D> elt;
   if (mFirst.mExplicit.empty()) {
     if (mSecond.mExplicit.empty()) {
       // Reconstruct the compressed stack with the first available signature

include/data.hpp

@@ -39,10 +39,12 @@ class Data{
   D mData;
 };
 
+template<class T, class D> using SPData = std::shared_ptr<Data<T,D>>;
+
 template<class T, class D> using Explicit = std::vector<Data<T,D>>;
 template<class T, class D> Explicit<T,D> initExplicit();
 
-template<class T, class D> using ExplicitPointer = std::vector<std::shared_ptr<Data<T,D>>>;
+template<class T, class D> using ExplicitPointer = std::vector<SPData<T,D>>;
 template<class T, class D> ExplicitPointer<T,D> initExplicitPointer();
 
 /*==============================================================================