Replace reference Blob& with pointer std::shared_ptr<Blob> all over the code

Author: kostyafip

blobstamper/blob.cpp

@@ -46,18 +46,18 @@ Blob::Dump()
     hexdump(data + begin, length);
 }
 
-Blob
+std::shared_ptr<Blob>
 Blob::ShiftBytes(size_t n)
 {
     if (this->Size() < n)
     {
         throw OutOfData();
     }
 
-    Blob new_blob(this->data, size);
+    std::shared_ptr<Blob> new_blob = std::make_shared<Blob>(this->data, size);
 
-    new_blob.begin = begin;   /* FIXME this should go private once */
-    new_blob.end = begin + n - 1;
+    new_blob->begin = begin;   /* FIXME this should go private once */
+    new_blob->end = begin + n - 1;
 
     begin += n;
 

blobstamper/blob.h

@@ -22,6 +22,7 @@
 #include <string>
 #include <list>
 #include <vector>
+#include <memory>
 
 
 class StampBase;
@@ -38,7 +39,7 @@ class Blob
         bool isEmpty ();
         size_t Size();
         void Dump();
-        Blob ShiftBytes(size_t n);
+	std::shared_ptr<Blob> ShiftBytes(size_t n);
         std::vector<char> ChopBlank(StampBase &stmp);
         void DataDup(char *& data_out, size_t& size_out);
         std::vector<char> asVector();

blobstamper/galley.cpp

@@ -49,9 +49,9 @@ GalleyVectorBase::minSize()
 
 
 std::vector<std::string>
-GalleyVectorStr::ExtractStrVector(Blob &blob)
+GalleyVectorStr::ExtractStrVector(std::shared_ptr<Blob> blob)
 {
-  std::vector<Blob> blobs = extract_internal(blob);
+  std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);
   std::vector<std::string> res(blobs.size());
 
   for(int i = 0; i<blobs.size(); i++)
@@ -62,9 +62,9 @@ GalleyVectorStr::ExtractStrVector(Blob &blob)
 }
 
 std::vector<std::vector<char>>
-GalleyVectorBin::ExtractBinVector(Blob &blob)
+GalleyVectorBin::ExtractBinVector(std::shared_ptr<Blob> blob)
 {
-  std::vector<Blob> blobs = extract_internal(blob);
+  std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);
   std::vector<std::vector<char>> res(blobs.size());
 
   for(int i = 0; i<blobs.size(); i++)
@@ -74,20 +74,20 @@ GalleyVectorBin::ExtractBinVector(Blob &blob)
   return res;
 }
 
-std::vector<Blob>
-GalleyVectorBase::extract_internal(Blob &blob)
+std::vector<std::shared_ptr<Blob>>
+GalleyVectorBase::extract_internal(std::shared_ptr<Blob> blob)
 {
-  if (blob.Size()<stamp.minSize())
+  if (blob->Size()<stamp.minSize())
   {
      throw OutOfData(); /* FIXME: May be later add option that allows empty lists if needed*/
   }
-  std::vector<Blob> res;
+  std::vector<std::shared_ptr<Blob>> res;
   if (stamp.isFixedSize())
   {
     int size = stamp.minSize();
-    while (blob.Size() >= size)
+    while (blob->Size() >= size)
     {
-      Blob el = blob.ShiftBytes(size);
+      std::shared_ptr<Blob> el = blob->ShiftBytes(size);
       res.push_back(el);
     }
   }
@@ -112,7 +112,7 @@ GalleyVectorBase::extract_internal(Blob &blob)
       */
 
       /* Getting count oracle and normalze it to fit available size */
-      size_t count_max = (blob.Size() - ORACLE_SIZE) / (stamp.minSize() + ORACLE_SIZE);  //First oracle - for number of items, and second one is oracle for each item size
+      size_t count_max = (blob->Size() - ORACLE_SIZE) / (stamp.minSize() + ORACLE_SIZE);  //First oracle - for number of items, and second one is oracle for each item size
 
       ORACLE_STAMP stamp_oracle;
       ORACLE_TYPE count_oracle = stamp_oracle.ExtractValue(blob);
@@ -139,7 +139,7 @@ GalleyVectorBase::extract_internal(Blob &blob)
       }
 
       /* Calculating available vairable size, that will be destributed between parts according to size oracles */
-      int data_size = blob.Size();
+      int data_size = blob->Size();
       int fixed_data_size = stamp.minSize() * count_target;
       int var_data_size = data_size - fixed_data_size;
 
@@ -151,7 +151,7 @@ GalleyVectorBase::extract_internal(Blob &blob)
         int el_size = el_size_f;
         remainder = el_size_f - el_size;
 
-        Blob blob2 = blob.ShiftBytes(el_size);
+	std::shared_ptr<Blob> blob2 = blob->ShiftBytes(el_size);
         res.push_back(blob2);
       }
     }
@@ -163,15 +163,15 @@ GalleyVectorBase::extract_internal(Blob &blob)
       ORACLE_STAMP stamp_oracle;
       while(1)
       {
-        if(stamp.minSize() + stamp_oracle.minSize() > blob.Size())
+        if(stamp.minSize() + stamp_oracle.minSize() > blob->Size())
           break;
 
         ORACLE_TYPE oracle = stamp_oracle.ExtractValue(blob);
 
         int size = (double) oracle / ORACLE_MAX * (var_size + 1); /* +1 -- это грубая эмуляция округления вверх. oracle == ORACLE_MAX-1 == 65534 должен дать count_max*/
         if (size > var_size) size = var_size; // In case we've hit oracle == ORACLE_MAX boundary
         size += fixed_size;
-        Blob blob2 = blob.ShiftBytes(size);
+	std::shared_ptr<Blob> blob2 = blob->ShiftBytes(size);
         res.push_back(blob2);
       }
     }
@@ -181,10 +181,10 @@ GalleyVectorBase::extract_internal(Blob &blob)
 
 /**********************************************/
 
-std::vector<Blob>
-GalleySetBase::extract_internal(Blob &blob)
+std::vector<std::shared_ptr<Blob>>
+GalleySetBase::extract_internal(std::shared_ptr<Blob> blob)
 {
-    std::vector<Blob> res;
+    std::vector<std::shared_ptr<Blob>> res;
     int fixed_total_size = 0;       // Summ of sizes of fixed parts of all stamps
     int max_varited_total_size = 0; // Summ of sizes of variable parts of variated stamps
     ORACLE_STAMP oracle_stamp;
@@ -225,12 +225,12 @@ GalleySetBase::extract_internal(Blob &blob)
        This is a variable that will set limits to gariated stamps greed (will be rediced later */
     int varited_total_size_limit = max_varited_total_size;
 
-    if(fixed_total_size > blob.Size()) /* Not enought data case*/
+    if(fixed_total_size > blob->Size()) /* Not enought data case*/
     {
        throw OutOfData();
     }
 
-    int avaliable_nonfixed_size = blob.Size() - fixed_total_size; /* The ammount of data available for non-fixed part of variated or unbounded stamps*/
+    int avaliable_nonfixed_size = blob->Size() - fixed_total_size; /* The ammount of data available for non-fixed part of variated or unbounded stamps*/
     if (varited_total_size_limit > avaliable_nonfixed_size)
         varited_total_size_limit = avaliable_nonfixed_size; /* Can't use more than we have */
 
@@ -341,33 +341,33 @@ GalleySetBase::extract_internal(Blob &blob)
           unbounded_remainder = len - el_size;
           el_size +=s.minSize();
         }
-        Blob blob2 = blob.ShiftBytes(el_size);
+	std::shared_ptr<Blob> blob2 = blob->ShiftBytes(el_size);
         res.push_back(blob2);
     }
     return res;
 }
 
 void
-GalleySetBase::LoadAll(Blob &blob)
+GalleySetBase::LoadAll(std::shared_ptr<Blob> blob)
 {
-    std::vector<Blob> blobs = extract_internal(blob);
+    std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);
     for(int i=0; i<blobs.size(); i++)
     {
-        Blob blob = blobs[i];
+	std::shared_ptr<Blob> blob = blobs[i];
         StampBase & stamp = stamps[i];
         stamp.Load(blob);
     }
 }
 
 
 std::vector<std::string>
-GalleySetStr::ExtractStrSet(Blob &blob)
+GalleySetStr::ExtractStrSet(std::shared_ptr<Blob> blob)
 {
     std::vector<std::string> res;
-    std::vector<Blob> blobs = extract_internal(blob);
+    std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);
     for(int i=0; i<blobs.size(); i++)
     {
-        Blob blob = blobs[i];
+	std::shared_ptr<Blob> blob = blobs[i];
         StampBaseStr & stamp = s_stamps[i];
         std::string str = stamp.ExtractStr(blob);
         res.push_back(str);
@@ -376,13 +376,13 @@ GalleySetStr::ExtractStrSet(Blob &blob)
 }
 
 std::vector<std::vector<char>>
-GalleySetBin::ExtractBinSet(Blob &blob)
+GalleySetBin::ExtractBinSet(std::shared_ptr<Blob> blob)
 {
     std::vector<std::vector<char>> res;
-    std::vector<Blob> blobs = extract_internal(blob);
+    std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);
     for(int i=0; i<blobs.size(); i++)
     {
-        Blob blob = blobs[i];
+	std::shared_ptr<Blob> blob = blobs[i];
         StampBaseBin & stamp = b_stamps[i];
         std::vector<char> v = stamp.ExtractBin(blob);
         res.push_back(v);

blobstamper/galley.h

@@ -46,7 +46,7 @@ class GalleyVectorBase : public GalleyBase
     StampBase &stamp;
   public:
     GalleyVectorBase(StampBase & stamp_arg) : stamp(stamp_arg) {};
-    std::vector<Blob> extract_internal(Blob &blob);
+    std::vector<std::shared_ptr<Blob>> extract_internal(std::shared_ptr<Blob> blob);
     int minSize() override;
     int maxSize() override {return -1;}; /* Sereies always takes as much data as it can take */
 };
@@ -56,7 +56,7 @@ class GalleyVectorStr: public GalleyVectorBase
 {
   public:
     GalleyVectorStr(StampBaseStr & stamp_arg): GalleyVectorBase(stamp_arg) {};
-    std::vector<std::string> ExtractStrVector(Blob &blob);
+    std::vector<std::string> ExtractStrVector(std::shared_ptr<Blob> blob);
 };
 
 template<class T> class GalleyVectorStrStampBase:  public GalleyVectorStr, public StampBaseStr
@@ -74,7 +74,7 @@ class GalleyVectorBin: public GalleyVectorBase
     StampBaseBin & b_stamp;
   public:
     GalleyVectorBin(StampBaseBin & stamp_arg): GalleyVectorBase(stamp_arg), b_stamp(stamp_arg)  {};
-    std::vector<std::vector<char>> ExtractBinVector(Blob &blob);
+    std::vector<std::vector<char>> ExtractBinVector(std::shared_ptr<Blob> blob);
 };
 
 
@@ -83,14 +83,14 @@ template<class T> class GalleyVectorV: public GalleyVectorBase
     StampBaseV<T>& v_stamp;
   public:
     GalleyVectorV(StampBaseV<T> & stamp_arg): GalleyVectorBase(stamp_arg), v_stamp(stamp_arg)  {};
-    std::vector<T> ExtractValuesVector(Blob &blob);
+    std::vector<T> ExtractValuesVector(std::shared_ptr<Blob> blob);
 };
 
 
 template<class T> std::vector<T>
-GalleyVectorV<T>::ExtractValuesVector(Blob &blob)
+GalleyVectorV<T>::ExtractValuesVector(std::shared_ptr<Blob> blob)
 {
-  std::vector<Blob> blobs = extract_internal(blob);
+  std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);
   std::vector<T> res(blobs.size());
 
   for(int i=0; i<blobs.size(); i++)
@@ -107,8 +107,8 @@ class GalleySetBase : public GalleyBase
     std::vector<std::reference_wrapper<StampBase>> stamps;
   public:
     GalleySetBase(std::vector<std::reference_wrapper<StampBase>> arg) : stamps(arg) {};
-    std::vector<Blob> extract_internal(Blob &blob);
-    void LoadAll(Blob &blob);
+    std::vector<std::shared_ptr<Blob>> extract_internal(std::shared_ptr<Blob> blob);
+    void LoadAll(std::shared_ptr<Blob> blob);
 
     int minSize() override;
     int maxSize() override;
@@ -119,7 +119,7 @@ class GalleySetBin : public GalleySetBase
     std::vector<std::reference_wrapper<StampBaseBin>> b_stamps;
   public:
     GalleySetBin(std::vector<std::reference_wrapper<StampBaseBin>> arg) : GalleySetBase(cast_arg(arg)), b_stamps(arg) {};
-    std::vector<std::vector<char>> ExtractBinSet(Blob &blob);
+    std::vector<std::vector<char>> ExtractBinSet(std::shared_ptr<Blob> blob);
 
     std::vector<std::reference_wrapper<StampBase>> cast_arg(std::vector<std::reference_wrapper<StampBaseBin>> in)
     {
@@ -138,7 +138,7 @@ class GalleySetStr : public GalleySetBase
     std::vector<std::reference_wrapper<StampBaseStr>> s_stamps;
   public:
     GalleySetStr(std::vector<std::reference_wrapper<StampBaseStr>> arg) : GalleySetBase(cast_arg(arg)), s_stamps(arg) {}; 
-    std::vector<std::string> ExtractStrSet(Blob &blob);
+    std::vector<std::string> ExtractStrSet(std::shared_ptr<Blob> blob);
 
     std::vector<std::reference_wrapper<StampBase>> cast_arg(std::vector<std::reference_wrapper<StampBaseStr>> in)
     {

blobstamper/stamp.cpp

@@ -27,24 +27,23 @@
 
 
 void
-StampBase::Load(Blob &blob)
+StampBase::Load(std::shared_ptr<Blob> blob)
 {
 
-  if (minSize() > blob.Size())
+  if (minSize() > blob->Size())
   {
     throw OutOfData();
   }
 
   size_t res_size;
   if (isUnbounded())
   {
-    res_size = blob.Size();
+    res_size = blob->Size();
   } else
   {
     res_size = maxSize();
-    if (res_size > blob.Size())
-        res_size = blob.Size();
+    if (res_size > blob->Size())
+        res_size = blob->Size();
   }
-  Blob *pb = new Blob(blob.ShiftBytes(res_size));
-  bitten_blob = std::unique_ptr<Blob>(pb);
+  bitten_blob = blob->ShiftBytes(res_size);
 }