Introduce 'Loaded' stamps

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

Makefile

@@ -41,6 +41,7 @@ blob-stamper-clean:
 clean: blob-stamper-clean
 	$(MAKE) -C blobstamper clean
 	$(MAKE) -C t clean
+	$(MAKE) -C examples clean
 	$(MAKE) -C libtappp clean
 	@echo Clean done!
 

blobstamper/stamp.cpp

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

blobstamper/stamp.h

@@ -22,16 +22,21 @@
 #include <string>
 #include <list>
 #include <vector>
+#include <memory>
 
 #include "helpers.h"
 
 
 class StampBase
 {
+  protected:
+    std::unique_ptr<Blob> bitten_blob;
   public:
     virtual int  minSize() = 0;
     virtual int  maxSize() = 0;
 
+    void Load(Blob &blob);
+
     bool isFixedSize() {return minSize() == maxSize();}
     bool isVariated()  {return ! isFixedSize() && ! isUnbounded();}
     bool isUnbounded() {return maxSize() == -1;}
@@ -42,20 +47,23 @@ class StampBaseStr: public virtual StampBase
 {
   public:
     virtual std::string ExtractStr(Blob &blob) = 0;
+    std::string UnloadStr() {return ExtractStr(*bitten_blob);};
 };
 
 
 class StampBaseBin: public virtual StampBase
 {
   public:
     virtual std::vector<char> ExtractBin(Blob &blob) = 0;
+    std::vector<char> UnloadBin() {return ExtractBin(*bitten_blob);};
 };
 
 
 template<class T> class StampBasePV: public StampBaseBin
 {
   public:
     virtual sized_ptr<T> ExtractPValue(Blob &blob) = 0;/* Shoud be defined by derived classes*/
+    sized_ptr<T> UnloadPValue() {return ExtractPValue(*bitten_blob);};
     virtual std::vector<char> ExtractBin(Blob &blob) override;
 };
 
@@ -70,9 +78,12 @@ StampBasePV<T>::ExtractBin(Blob &blob)
 }
 
 template<class T> class StampBaseV: public StampBasePV<T>
+,public virtual StampBase //FIXME I do not understand why do we need it here, but wihtout it, it does not build
 {
   public:
     virtual T ExtractValue(Blob &blob) = 0;/* Shoud be defined by derived classes*/
+    T UnloadValue() {return ExtractValue(*bitten_blob);};
+
     virtual std::vector<char> ExtractBin(Blob &blob) override;
     virtual sized_ptr<T> ExtractPValue(Blob &blob) override;
 };

examples/example01a.cpp

@@ -0,0 +1,22 @@
+#include<stdio.h>
+#include<string.h>
+
+#include<string>
+#include<iostream>
+
+#include<blobstamper/blobstamper.h>
+
+int main()
+{
+  char data[] = "abcde";
+  Blob blob(data, strlen(data));
+  StampArithm<short int> stamp;
+  stamp.Load(blob);
+
+  std::string s = stamp.UnloadStr();
+
+  std::cout << "Stamp minSize: " << stamp.minSize() << "\n";
+  std::cout << "Stamp maxSize: " << stamp.maxSize() << "\n";
+  std::cout << "Extracted value: " << s <<"\n";
+  std::cout << "Remaining blob: " << blob.asString() << "\n";
+}

examples/example02a.cpp

@@ -0,0 +1,34 @@
+#include<stdio.h>
+#include<string.h>
+
+#include<string>
+#include<iostream>
+
+#include<blobstamper/blobstamper.h>
+
+int main()
+{
+  char data[] = "abcdefjhi";
+  Blob blob(data, strlen(data));
+  StampArithm<short int> stamp1;
+  StampArithm<short int> stamp2;
+  StampArithm<short int> stamp3;
+  StampArithm<short int> stamp4;
+
+  stamp1.Load(blob);
+  stamp2.Load(blob);
+  stamp3.Load(blob);
+  stamp4.Load(blob);
+
+  std::string s = stamp1.UnloadStr();
+  std::vector<char> vec= stamp2.UnloadBin();
+  short int i = stamp3.UnloadValue();
+
+  sized_ptr<short int> spi = stamp4.UnloadPValue();
+  short int *pi = spi;
+
+  std::cout << "String value: '" << s <<"'\n";
+  std::cout << "Bin value: '" << vec[0] <<"', '" << vec[1] <<"'\n";
+  std::cout << "Value: " << i  <<"\n";
+  std::cout << "PValue: " << *pi  <<"\n";
+}