Rework code that deals with chopping blob into pieces... Now you should point only size values

Author: nataraj-hates-MS-for-stealing-github

blobstamper/blob.cpp

@@ -46,46 +46,40 @@ Blob::Dump()
     hexdump(data + begin, length);
 }
 
+
 std::shared_ptr<Blob>
-Blob::ShiftBytes(size_t n)
+Blob::Chop(size_t chop_size)
 {
-    if (this->Size() < n)
+    if (this->Size() < chop_size)
     {
         throw OutOfData();
     }
 
-    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;
-
-    begin += n;
+    std::shared_ptr<Blob> new_blob = std::make_shared<Blob>(this->data + begin, chop_size);
+    begin += chop_size;
 
     return new_blob;
 }
 
-std::vector<char>
-Blob::ChopBlank(StampBase &stamp)
+std::shared_ptr<Blob>
+Blob::Chop(size_t min_size, size_t max_size)
 {
-    if (stamp.minSize() > this->Size())
+    if (this->Size() < min_size)
     {
         throw OutOfData();
     }
-    size_t res_size;
-    if (stamp.isUnbounded())
-    {
-        res_size = this->Size();
-    } else
-    {
-        res_size = stamp.maxSize();
-        if (res_size > this->Size())
-            res_size = this->Size();
-    }
-    std::vector<char> res((char*)this->data + this->begin, (char*)this->data + this->begin + res_size);
-    this->begin += res_size;
-    return res;
+    if (this->Size() >= max_size)
+        return this->Chop(max_size);
+
+    return this->Chop(this->Size());
 }
 
+std::vector<char>
+Blob::AsByteVector()
+{
+    std::vector<char> res(data + begin, data + begin + size);
+    return res;
+}
 
 size_t
 Blob::Size()

blobstamper/blob.h

@@ -39,8 +39,11 @@ class Blob
         bool isEmpty ();
         size_t Size();
         void Dump();
-	std::shared_ptr<Blob> ShiftBytes(size_t n);
-        std::vector<char> ChopBlank(StampBase &stmp);
+
+        std::vector<char> AsByteVector();
+        std::shared_ptr<Blob> Chop(size_t chop_size);
+        std::shared_ptr<Blob> Chop(size_t min_size, size_t max_size);
+
         void DataDup(char *& data_out, size_t& size_out);
         std::vector<char> asVector();
         std::string asString(); /* Should not be used in prod, for tests and examples only*/

blobstamper/galley.cpp

@@ -87,7 +87,7 @@ GalleyVectorBase::extract_internal(std::shared_ptr<Blob> blob)
     int size = stamp.minSize();
     while (blob->Size() >= size)
     {
-      std::shared_ptr<Blob> el = blob->ShiftBytes(size);
+      std::shared_ptr<Blob> el = blob->Chop(size);
       res.push_back(el);
     }
   }
@@ -151,7 +151,7 @@ GalleyVectorBase::extract_internal(std::shared_ptr<Blob> blob)
         int el_size = el_size_f;
         remainder = el_size_f - el_size;
 
-	std::shared_ptr<Blob> blob2 = blob->ShiftBytes(el_size);
+	std::shared_ptr<Blob> blob2 = blob->Chop(el_size);
         res.push_back(blob2);
       }
     }
@@ -171,7 +171,7 @@ GalleyVectorBase::extract_internal(std::shared_ptr<Blob> 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;
-	std::shared_ptr<Blob> blob2 = blob->ShiftBytes(size);
+	std::shared_ptr<Blob> blob2 = blob->Chop(size);
         res.push_back(blob2);
       }
     }
@@ -341,7 +341,7 @@ GalleySetBase::extract_internal(std::shared_ptr<Blob> blob)
           unbounded_remainder = len - el_size;
           el_size +=s.minSize();
         }
-	std::shared_ptr<Blob> blob2 = blob->ShiftBytes(el_size);
+	std::shared_ptr<Blob> blob2 = blob->Chop(el_size);
         res.push_back(blob2);
     }
     return res;

blobstamper/stamp.cpp

@@ -45,5 +45,5 @@ StampBase::Load(std::shared_ptr<Blob> blob)
     if (res_size > blob->Size())
         res_size = blob->Size();
   }
-  bitten_blob = blob->ShiftBytes(res_size);
+  bitten_blob = blob->Chop(res_size);
 }

blobstamper/stamp_arithm.h

@@ -42,7 +42,7 @@ StampArithm<T>::ExtractStr(std::shared_ptr<Blob> blob)
 template<class T> T
 StampArithm<T>::ExtractValue(std::shared_ptr<Blob> blob)
 {
-  std::vector<char> v = blob->ChopBlank(*this);  /* Chop out blank of maxSize */
+  std::vector<char> v = blob->Chop(sizeof(T))->AsByteVector();  /* Chop out blank of type's size */
   T *pT = (T *) &v[0]; /* And interpret it as value of arithmetic type */
   return *pT;
 }

blobstamper/stamp_text.cpp

@@ -21,8 +21,7 @@
 std::string
 StampTextPulp::ExtractStr(std::shared_ptr<Blob> blob)
 {
-
-    std::vector<char> data = blob->ChopBlank(*this);
+    std::vector<char> data = blob->Chop(minSize(), maxSize())->AsByteVector();
 
     std::vector<char>::iterator the_iterator;
 

t/001-blob-generic.cpp

@@ -56,7 +56,7 @@ main()
         char expected2[]="123";
 
 	std::shared_ptr<Blob> blob1 = std::make_shared<Blob>(short_sample,strlen(short_sample));
-	std::shared_ptr<Blob> blob2 = blob1->ShiftBytes(3);
+	std::shared_ptr<Blob> blob2 = blob1->Chop(3);
 
         blob1->DataDup(ptr,size);
         ok(size == strlen(expected1), "Blob shifted data size ok");
@@ -73,7 +73,7 @@ main()
 	std::shared_ptr<Blob> blob = std::make_shared<Blob>(my_data, strlen(my_data));
         try
         {
-	  std::shared_ptr<Blob> blob_res = blob->ShiftBytes(99999);
+	  std::shared_ptr<Blob> blob_res = blob->Chop(99999);
           ok(false, "Shift too many bytes");
         }
         catch (OutOfData)

t/320-galley-recursion-experiments.cpp

@@ -292,7 +292,7 @@ printf("___________________________ %i\n", blob->Size());
 
   printf("llll - %i %i \n",  split_data[0],  split_data[1]);
 
-  std::shared_ptr<Blob> blob_left =  blob->ShiftBytes(split_data[0]+ 2*stamp_char.minSize() );
+  std::shared_ptr<Blob> blob_left =  blob->Chop(split_data[0]+ 2*stamp_char.minSize() );
 
 printf("~~~ %i\n",variant_n);
 
@@ -303,7 +303,7 @@ std::string
 TestRNode2::do_recursion(std::shared_ptr<Blob> blob)
 {
   try{
-    std::shared_ptr<Blob> tmp = blob->ShiftBytes(1);
+    std::shared_ptr<Blob> tmp = blob->Chop(1);
   }
   catch (OutOfData)
   {
@@ -318,7 +318,7 @@ std::string
 TestRNode3::do_recursion(std::shared_ptr<Blob> blob)
 {
   try{
-	  std::shared_ptr<Blob> tmp = blob->ShiftBytes(1);
+	  std::shared_ptr<Blob> tmp = blob->Chop(1);
   }
   catch (OutOfData)
   {

t/README.md

@@ -0,0 +1,5 @@
+Запуск отдельного теста:
+
+```
+LD_LIBRARY_PATH=../libtappp ./001-blob-generic.t
+```

t/test-chars-stamps.h

@@ -32,7 +32,7 @@ std::string
 StampTwoChars::ExtractStr(std::shared_ptr<Blob> blob)
 {
     /* Chopping suitable data chunk from blob */
-    std::vector<char> data = blob->ChopBlank(*this);
+    std::vector<char> data = blob->Chop(minSize(), maxSize())->AsByteVector();
 
     size_t buf_size = data.size() + 1;
     char * buf = (char *) malloc(buf_size);
@@ -59,8 +59,7 @@ class StampSeveralChars: public StampBaseStr
 std::string
 StampSeveralChars::ExtractStr(std::shared_ptr<Blob> blob)
 {
-
-    std::vector<char> data = blob->ChopBlank(*this);
+    std::vector<char> data = blob->Chop(minSize(), maxSize())->AsByteVector();
     /* Save optained data as string */
     /* NEVER do this in prod, as in real live blob is binary and may have 0 in the middle of it */
     char * buf;