fixed some whitespace issues

ProjectMutilation · ProjectMutilation · commit 1a6aebd9d208 · 2024-09-17T15:29:46.000+03:00
diff --git a/blobstamper/dict.cpp b/blobstamper/dict.cpp
@@ -16,7 +16,7 @@
  *
  ******************************************************************************/
 
-#include"dict.h"
+#include "dict.h"
 
 
 size_t
diff --git a/blobstamper/dict.h b/blobstamper/dict.h
@@ -20,8 +20,8 @@
 #define DICT_H
 
 
-#include<string>
-#include<vector>
+#include <string>
+#include <vector>
 
 
 class DictBase
@@ -31,10 +31,10 @@ class DictBase
   public:
     size_t size();
     std::string get(size_t n); // FIXME May be it would be good to use operator[]  later.
-    DictBase() {data = {};};
+    DictBase() { data = {}; };
 };
 
-class DictLCAlphaSmall : public DictBase
+class DictLCAlphaSmall: public DictBase
 {
   public:
      DictLCAlphaSmall();
diff --git a/blobstamper/galley.cpp b/blobstamper/galley.cpp
@@ -427,7 +427,7 @@ GalleySetBase::minSize()
     if (unbounded_count > 1) /* One unbounded stamp will take all data. Nothing to predict */
         res += ORACLE_SIZE * unbounded_count;
 
-   return res;
+    return res;
 }
 
 int
diff --git a/blobstamper/galley.h b/blobstamper/galley.h
@@ -81,7 +81,7 @@ GalleyVectorV<T>::ExtractValuesVector(std::shared_ptr<Blob> 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++)
+  for (int i = 0; i < blobs.size(); i++)
   {
     res[i] = std::dynamic_pointer_cast<StampBaseV<T>>(stamp)->ExtractValue(blobs[i]);
   }
diff --git a/blobstamper/oracle.cpp b/blobstamper/oracle.cpp
@@ -31,7 +31,7 @@ OracleProportion(ORACLE_TYPE oracle, size_t min, size_t max)
    * хвоста диапазона предсказания не попасть никогда и тогда он не округлиться 
    * в max + 1*/
   size_t delta = max - min + 1;
-  size_t res = floor(((float) oracle) / ((float) ORACLE_MAX + 1) * delta );
+  size_t res = floor(((float) oracle) / ((float) ORACLE_MAX + 1) * delta);
   return min + res;
 }
 
diff --git a/blobstamper/stamp.cpp b/blobstamper/stamp.cpp
@@ -43,7 +43,7 @@ StampBase::Load(std::shared_ptr<Blob> blob)
   {
     res_size = maxSize();
     if (res_size > blob->Size())
-        res_size = blob->Size();
+      res_size = blob->Size();
   }
   bitten_blob = blob->Chop(res_size);
 }
diff --git a/blobstamper/stamp.h b/blobstamper/stamp.h
@@ -40,9 +40,9 @@ class StampBase
 
     void Load(std::shared_ptr<Blob> blob);
 
-    bool isFixedSize() {return minSize() == maxSize();}
-    bool isVariated()  {return ! isFixedSize() && ! isUnbounded();}
-    bool isUnbounded() {return maxSize() == -1;}
+    bool isFixedSize() { return minSize() == maxSize(); }
+    bool isVariated()  { return !isFixedSize() && !isUnbounded(); }
+    bool isUnbounded() { return maxSize() == -1; }
     virtual bool isRecursive() {return is_recursive;}
 };
 
@@ -90,8 +90,8 @@ StampBasePV<T>::ExtractBin(std::shared_ptr<Blob> blob)
   return v;
 }
 
-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
+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(std::shared_ptr<Blob> blob) = 0;/* Should be defined by derived classes*/
diff --git a/blobstamper/stamp_dict.cpp b/blobstamper/stamp_dict.cpp
@@ -24,17 +24,17 @@
 int
 StampDict::ChooseStampSize(std::shared_ptr<DictBase> dict)
 {
-    if (dict->size() <= UCHAR_MAX+1)
+    if (dict->size() <= UCHAR_MAX + 1)
     {
         stamp_max_value = UCHAR_MAX;
         return 1;
     }
-    if (dict->size() <= USHRT_MAX+1)
+    if (dict->size() <= USHRT_MAX + 1)
     {
         stamp_max_value = USHRT_MAX;
         return 2;
     }
-    if (dict->size() <= UINT_MAX+1)
+    if (dict->size() <= UINT_MAX + 1)
     {
         stamp_max_value = UINT_MAX;
         return 4;
@@ -76,6 +76,6 @@ StampDict::ExtractStr(std::shared_ptr<Blob> blob)
          exit(1);
     }
     long long actual_index = ((double) index_oracle) / stamp_max_value * dict->size();
-    if ( actual_index == dict->size())  actual_index--; /* If we hit the boundary step inside a bit*/
+    if (actual_index == dict->size())  actual_index--; /* If we hit the boundary step inside a bit*/
     return dict->get(actual_index);
 }
diff --git a/blobstamper/stamp_dict.h b/blobstamper/stamp_dict.h
@@ -47,10 +47,10 @@ class StampDict: public StampBaseStr
     int  maxSize() override {return stamp_size;}
 };
 
-class StampDictLCAlphaSmall : public StampDict
+class StampDictLCAlphaSmall: public StampDict
 {
   public:
-    StampDictLCAlphaSmall (): StampDict(std::make_shared<DictLCAlphaSmall>()) {};
+    StampDictLCAlphaSmall(): StampDict(std::make_shared<DictLCAlphaSmall>()) {};
 };
 
 
diff --git a/blobstamper/stamp_enumerator.cpp b/blobstamper/stamp_enumerator.cpp
@@ -29,13 +29,13 @@ std::string StampStrEnumerator::ExtractStr(std::shared_ptr<Blob> blob)
   std::vector<std::string> data = ExtractStrVector(blob);
   std::string res = "";
 
-  for(std::string s : data)
+  for (std::string s : data)
   {
     if (!res.empty())
     {
-      res+= separator;
+      res += separator;
     }
-    res+= s;
+    res += s;
   }
   res = left_bracket + res + right_bracket;
   return res;
diff --git a/blobstamper/stamp_enumerator.h b/blobstamper/stamp_enumerator.h
@@ -19,11 +19,11 @@
 #ifndef STAMP_ENUMERATOR_H
 #define STAMP_ENUMERATOR_H
 
-#include"galley.h"
-#include"stamp.h"
-#include"blob.h"
+#include "galley.h"
+#include "stamp.h"
+#include "blob.h"
 
-#include<string>
+#include <string>
 
 class StampStrEnumerator: public GalleyVectorStr, public StampBaseStr
 {
diff --git a/blobstamper/stamp_json.cpp b/blobstamper/stamp_json.cpp
@@ -27,7 +27,7 @@
 PoolPickerStamp::PoolPickerStamp(std::vector<std::shared_ptr<StampBaseStr>> new_pool)
         : pool{new_pool}
 {
-  for(auto stamp : pool)
+  for (auto stamp : pool)
   {
      std::weak_ptr<StampBaseStr> wp = stamp;
      weak_pool.push_back(wp);
@@ -37,10 +37,10 @@ PoolPickerStamp::PoolPickerStamp(std::vector<std::shared_ptr<StampBaseStr>> new_
 bool
 PoolPickerStamp::isRecursive()
 {
-  if(is_recursive || is_in_recursion)
+  if (is_recursive || is_in_recursion)
     return true;
   is_in_recursion = true;
-  for(auto stamp : weak_pool)
+  for (auto stamp : weak_pool)
   {
     if (stamp.lock()->isRecursive())
     {
@@ -62,7 +62,7 @@ PoolPickerStamp::ExtractStr(std::shared_ptr<Blob> blob)
   std::vector<std::weak_ptr<StampBaseStr>> target_pool;
   std::vector<std::weak_ptr<StampBaseStr>> unbounded_pool;
 
-  for(auto stamp_w : weak_pool)
+  for (auto stamp_w : weak_pool)
   {
     auto stamp = stamp_w.lock();
     if (stamp->minSize() <= blob->Size())
@@ -75,7 +75,7 @@ PoolPickerStamp::ExtractStr(std::shared_ptr<Blob> blob)
     }
   }
   if (unbounded_pool.size()>0)
-        target_pool = unbounded_pool;
+    target_pool = unbounded_pool;
 
   size_t index = OracleProportion(oracle, 0, target_pool.size() - 1);
   return target_pool[index].lock()->ExtractStr(blob);
@@ -111,7 +111,7 @@ PoolPickerStamp::maxSize()
   if (is_recursive || is_in_recursion)
     return -1;
   is_in_recursion = true; /* Do not use isRecursive() inside as it uses same flag*/
-  for(auto stamp : weak_pool)
+  for (auto stamp : weak_pool)
   {
     int candidat = stamp.lock()->maxSize();
     if (candidat == -1)
diff --git a/blobstamper/stamp_json.h b/blobstamper/stamp_json.h
@@ -27,7 +27,7 @@
 #include "stamp_dict.h"
 #include "stamp_enumerator.h"
 
-class PoolPickerStamp : public virtual StampBaseStr
+class PoolPickerStamp: public virtual StampBaseStr
 {
   protected:
     std::vector<std::shared_ptr<StampBaseStr>> pool;
@@ -44,15 +44,15 @@ class PoolPickerStamp : public virtual StampBaseStr
     virtual int maxSize() override;
 };
 
-class StampJSONInt : public virtual StampArithm<long int>
+class StampJSONInt: public virtual StampArithm<long int>
 {
 };
 
-class StampJSONFloat : public virtual StampArithm<double>
+class StampJSONFloat: public virtual StampArithm<double>
 {
 };
 
-class StampJSONString : public virtual StampDictT<DictLCAlphaSmall>
+class StampJSONString: public virtual StampDictT<DictLCAlphaSmall>
 {
   protected:
   public:
@@ -66,8 +66,8 @@ class StampJSONArray: public StampStrEnumerator
 {
   private:
   public:
-    StampJSONArray(std::shared_ptr<PoolPickerStamp> picker)
-            :StampStrEnumerator(picker, ", ", "[", "]") {};
+    StampJSONArray(std::shared_ptr<PoolPickerStamp> picker):
+                   StampStrEnumerator(picker, ", ", "[", "]") {};
 };
 
 class StampJSONHashEl: public StampBaseStr
@@ -76,8 +76,8 @@ class StampJSONHashEl: public StampBaseStr
     std::shared_ptr<StampJSONString> stamp_name;
     std::shared_ptr<PoolPickerStamp> stamp_value;
   public:
-    StampJSONHashEl(std::shared_ptr<PoolPickerStamp> picker)
-            :stamp_value(picker), stamp_name(std::make_shared<StampJSONString>()) {};
+    StampJSONHashEl(std::shared_ptr<PoolPickerStamp> picker):
+                    stamp_value(picker), stamp_name(std::make_shared<StampJSONString>()) {};
     virtual int minSize() override {return stamp_name->minSize() + stamp_value->minSize();};
     virtual int maxSize() override {return -1;};
     std::string ExtractStr(std::shared_ptr<Blob> blob) override;
@@ -88,8 +88,8 @@ class StampJSONHash: public StampStrEnumerator
   private:
     std::shared_ptr<StampJSONHashEl> stamp_el;
   public:
-    StampJSONHash(std::shared_ptr<PoolPickerStamp> picker)
-            :StampStrEnumerator(stamp_el = std::make_shared<StampJSONHashEl>(picker), ", ", "{", "}") {};
+    StampJSONHash(std::shared_ptr<PoolPickerStamp> picker):
+                  StampStrEnumerator(stamp_el = std::make_shared<StampJSONHashEl>(picker), ", ", "{", "}") {};
 };
 
 
diff --git a/blobstamper/stamp_lottery.h b/blobstamper/stamp_lottery.h
@@ -62,10 +62,10 @@ template<class StampT> bool
 StampLottery4Recursion<StampT>::
 soft_maxsize_filter(StampT &stamp, int data_size)
 {
-  if ( stamp.isUnbounded() ||            // Unbounded is always ok
-       stamp.maxSize() > data_size  ||  // Variated that can consume all data is ok
-       stamp.minSize() + stamp.maxSize() > data_size  // Fixed or variated stamp that lefts less data then it's min size will also do
-      )
+  if (stamp.isUnbounded() ||            // Unbounded is always ok
+      stamp.maxSize() > data_size  ||  // Variated that can consume all data is ok
+      stamp.minSize() + stamp.maxSize() > data_size  // Fixed or variated stamp that lefts less data then it's min size will also do
+     )
       return true;
   return false;
 }
@@ -76,7 +76,7 @@ init_stored_min(std::ref_vector<StampT> stamps_arg)
 {
   int min = std::numeric_limits<int>::max();
 
-  for(StampT & stamp : stamps)
+  for (StampT & stamp : stamps)
   {
 
     if (min > stamp.minSize())
@@ -91,13 +91,13 @@ init_stored_max(std::ref_vector<StampT> stamps_arg)
 {
   int max = 0;
 
-  for(StampT & stamp : stamps)
+  for (StampT & stamp : stamps)
   {
     if (stamp.maxSize() == -1)
       return -1;
 
     if (max < stamp.maxSize())
-        max = stamp.maxSize();
+      max = stamp.maxSize();
   }
   return max;
 }
diff --git a/blobstamper/stamp_math_op.cpp b/blobstamper/stamp_math_op.cpp
@@ -30,6 +30,6 @@ std::string
 StampMathBinaryOp::ExtractStr(std::shared_ptr<Blob> blob)
 {
   std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);
-  return (std::string)"(" +  stamp1->ExtractStr(blobs[0]) + " "+  op_name + " " + stamp2->ExtractStr(blobs[1]) + ")";
+  return (std::string)"(" +  stamp1->ExtractStr(blobs[0]) + " " +  op_name + " " + stamp2->ExtractStr(blobs[1]) + ")";
 }
 
diff --git a/blobstamper/stamp_math_op.h b/blobstamper/stamp_math_op.h
@@ -19,9 +19,9 @@
 #ifndef STAMP_MATH_OP_H
 #define STAMP_MATH_OP_H
 
-#include"blob.h"
-#include"stamp.h"
-#include"galley.h"
+#include "blob.h"
+#include "stamp.h"
+#include "galley.h"
 
 
 class StampMathUnaryOp: public StampBaseStr
@@ -31,7 +31,7 @@ class StampMathUnaryOp: public StampBaseStr
     std::shared_ptr<StampBaseStr> stamp;
   public:
     virtual std::string ExtractStr(std::shared_ptr<Blob> blob) override;
-    StampMathUnaryOp(std::string arg_op_name, std::shared_ptr<StampBaseStr> arg_stamp) : op_name(arg_op_name), stamp(arg_stamp) {};
+    StampMathUnaryOp(std::string arg_op_name, std::shared_ptr<StampBaseStr> arg_stamp): op_name(arg_op_name), stamp(arg_stamp) {};
     virtual int maxSize() override {return -1;};
     virtual int minSize() override {return stamp->minSize();};
 };
@@ -48,7 +48,7 @@ class StampMathBinaryOp: public StampBaseStr, public GalleySetBase
     virtual std::string ExtractStr(std::shared_ptr<Blob> blob) override;
     StampMathBinaryOp(std::string arg_op_name,
                       std::shared_ptr<StampBaseStr> arg_stamp1,
-                      std::shared_ptr<StampBaseStr> arg_stamp2) :
+                      std::shared_ptr<StampBaseStr> arg_stamp2):
         GalleySetBase({arg_stamp1, arg_stamp2}),
         op_name(arg_op_name),
         stamp1(arg_stamp1),
diff --git a/blobstamper/stamp_text.cpp b/blobstamper/stamp_text.cpp
@@ -16,7 +16,7 @@
  *
  ******************************************************************************/
 
-#include"stamp_text.h"
+#include "stamp_text.h"
 
 std::string
 StampTextPulp::ExtractStr(std::shared_ptr<Blob> blob)
@@ -26,7 +26,7 @@ StampTextPulp::ExtractStr(std::shared_ptr<Blob> blob)
     std::vector<char>::iterator the_iterator;
 
     the_iterator = data.begin();
-    std:: string res;
+    std::string res;
     while (the_iterator != data.end())
     {
       if (*the_iterator == '\0') { *the_iterator = ' '; }
diff --git a/blobstamper/stamp_text.h b/blobstamper/stamp_text.h
@@ -27,8 +27,8 @@
 class StampTextPulp: public StampBaseStr
 {
   public:
-    virtual int minSize() override {return 1;}
-    virtual int maxSize() override {return -1;}
+    virtual int minSize() override { return  1; }
+    virtual int maxSize() override { return -1; }
     std::string ExtractStr(std::shared_ptr<Blob> blob) override;
 };
 

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@`
`16`	`16`	`*`
`17`	`17`	`******************************************************************************/`
`18`	`18`
`19`		`-#include"dict.h"`
	`19`	`+#include "dict.h"`
`20`	`20`
`21`	`21`
`22`	`22`	`size_t`
Original file line number	Diff line number	Diff line change
`@@ -427,7 +427,7 @@ GalleySetBase::minSize()`
`427`	`427`	`if (unbounded_count > 1) /* One unbounded stamp will take all data. Nothing to predict */`
`428`	`428`	`res += ORACLE_SIZE * unbounded_count;`
`429`	`429`
`430`		`- return res;`
	`430`	`+ return res;`
`431`	`431`	`}`
`432`	`432`
`433`	`433`	`int`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ GalleyVectorV<T>::ExtractValuesVector(std::shared_ptr<Blob> blob)`
`81`	`81`	`std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);`
`82`	`82`	`std::vector<T> res(blobs.size());`
`83`	`83`
`84`		`- for(int i=0; i<blobs.size(); i++)`
	`84`	`+ for (int i = 0; i < blobs.size(); i++)`
`85`	`85`	`{`
`86`	`86`	`res[i] = std::dynamic_pointer_cast<StampBaseV<T>>(stamp)->ExtractValue(blobs[i]);`
`87`	`87`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ OracleProportion(ORACLE_TYPE oracle, size_t min, size_t max)`
`31`	`31`	`* хвоста диапазона предсказания не попасть никогда и тогда он не округлиться`
`32`	`32`	`* в max + 1*/`
`33`	`33`	`size_t delta = max - min + 1;`
`34`		`- size_t res = floor(((float) oracle) / ((float) ORACLE_MAX + 1) * delta );`
	`34`	`+ size_t res = floor(((float) oracle) / ((float) ORACLE_MAX + 1) * delta);`
`35`	`35`	`return min + res;`
`36`	`36`	`}`
`37`	`37`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ StampBase::Load(std::shared_ptr<Blob> blob)`
`43`	`43`	`{`
`44`	`44`	`res_size = maxSize();`
`45`	`45`	`if (res_size > blob->Size())`
`46`		`- res_size = blob->Size();`
	`46`	`+ res_size = blob->Size();`
`47`	`47`	`}`
`48`	`48`	`bitten_blob = blob->Chop(res_size);`
`49`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,17 +24,17 @@`
`24`	`24`	`int`
`25`	`25`	`StampDict::ChooseStampSize(std::shared_ptr<DictBase> dict)`
`26`	`26`	`{`
`27`		`- if (dict->size() <= UCHAR_MAX+1)`
	`27`	`+ if (dict->size() <= UCHAR_MAX + 1)`
`28`	`28`	`{`
`29`	`29`	`stamp_max_value = UCHAR_MAX;`
`30`	`30`	`return 1;`
`31`	`31`	`}`
`32`		`- if (dict->size() <= USHRT_MAX+1)`
	`32`	`+ if (dict->size() <= USHRT_MAX + 1)`
`33`	`33`	`{`
`34`	`34`	`stamp_max_value = USHRT_MAX;`
`35`	`35`	`return 2;`
`36`	`36`	`}`
`37`		`- if (dict->size() <= UINT_MAX+1)`
	`37`	`+ if (dict->size() <= UINT_MAX + 1)`
`38`	`38`	`{`
`39`	`39`	`stamp_max_value = UINT_MAX;`
`40`	`40`	`return 4;`
`@@ -76,6 +76,6 @@ StampDict::ExtractStr(std::shared_ptr<Blob> blob)`
`76`	`76`	`exit(1);`
`77`	`77`	`}`
`78`	`78`	`long long actual_index = ((double) index_oracle) / stamp_max_value * dict->size();`
`79`		`- if ( actual_index == dict->size()) actual_index--; /* If we hit the boundary step inside a bit*/`
	`79`	`+ if (actual_index == dict->size()) actual_index--; /* If we hit the boundary step inside a bit*/`
`80`	`80`	`return dict->get(actual_index);`
`81`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,13 +29,13 @@ std::string StampStrEnumerator::ExtractStr(std::shared_ptr<Blob> blob)`
`29`	`29`	`std::vector<std::string> data = ExtractStrVector(blob);`
`30`	`30`	`std::string res = "";`
`31`	`31`
`32`		`- for(std::string s : data)`
	`32`	`+ for (std::string s : data)`
`33`	`33`	`{`
`34`	`34`	`if (!res.empty())`
`35`	`35`	`{`
`36`		`- res+= separator;`
	`36`	`+ res += separator;`
`37`	`37`	`}`
`38`		`- res+= s;`
	`38`	`+ res += s;`
`39`	`39`	`}`
`40`	`40`	`res = left_bracket + res + right_bracket;`
`41`	`41`	`return res;`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@`
`27`	`27`	`PoolPickerStamp::PoolPickerStamp(std::vector<std::shared_ptr<StampBaseStr>> new_pool)`
`28`	`28`	`: pool{new_pool}`
`29`	`29`	`{`
`30`		`- for(auto stamp : pool)`
	`30`	`+ for (auto stamp : pool)`
`31`	`31`	`{`
`32`	`32`	`std::weak_ptr<StampBaseStr> wp = stamp;`
`33`	`33`	`weak_pool.push_back(wp);`
`@@ -37,10 +37,10 @@ PoolPickerStamp::PoolPickerStamp(std::vector<std::shared_ptr<StampBaseStr>> new_`
`37`	`37`	`bool`
`38`	`38`	`PoolPickerStamp::isRecursive()`
`39`	`39`	`{`
`40`		`- if(is_recursive \|\| is_in_recursion)`
	`40`	`+ if (is_recursive \|\| is_in_recursion)`
`41`	`41`	`return true;`
`42`	`42`	`is_in_recursion = true;`
`43`		`- for(auto stamp : weak_pool)`
	`43`	`+ for (auto stamp : weak_pool)`
`44`	`44`	`{`
`45`	`45`	`if (stamp.lock()->isRecursive())`
`46`	`46`	`{`
`@@ -62,7 +62,7 @@ PoolPickerStamp::ExtractStr(std::shared_ptr<Blob> blob)`
`62`	`62`	`std::vector<std::weak_ptr<StampBaseStr>> target_pool;`
`63`	`63`	`std::vector<std::weak_ptr<StampBaseStr>> unbounded_pool;`
`64`	`64`
`65`		`- for(auto stamp_w : weak_pool)`
	`65`	`+ for (auto stamp_w : weak_pool)`
`66`	`66`	`{`
`67`	`67`	`auto stamp = stamp_w.lock();`
`68`	`68`	`if (stamp->minSize() <= blob->Size())`
`@@ -75,7 +75,7 @@ PoolPickerStamp::ExtractStr(std::shared_ptr<Blob> blob)`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`	`if (unbounded_pool.size()>0)`
`78`		`- target_pool = unbounded_pool;`
	`78`	`+ target_pool = unbounded_pool;`
`79`	`79`
`80`	`80`	`size_t index = OracleProportion(oracle, 0, target_pool.size() - 1);`
`81`	`81`	`return target_pool[index].lock()->ExtractStr(blob);`
`@@ -111,7 +111,7 @@ PoolPickerStamp::maxSize()`
`111`	`111`	`if (is_recursive \|\| is_in_recursion)`
`112`	`112`	`return -1;`
`113`	`113`	`is_in_recursion = true; /* Do not use isRecursive() inside as it uses same flag*/`
`114`		`- for(auto stamp : weak_pool)`
	`114`	`+ for (auto stamp : weak_pool)`
`115`	`115`	`{`
`116`	`116`	`int candidat = stamp.lock()->maxSize();`
`117`	`117`	`if (candidat == -1)`
Original file line number	Diff line number	Diff line change
`@@ -62,10 +62,10 @@ template<class StampT> bool`
`62`	`62`	`StampLottery4Recursion<StampT>::`
`63`	`63`	`soft_maxsize_filter(StampT &stamp, int data_size)`
`64`	`64`	`{`
`65`		`- if ( stamp.isUnbounded() \|\| // Unbounded is always ok`
`66`		`- stamp.maxSize() > data_size \|\| // Variated that can consume all data is ok`
`67`		`- stamp.minSize() + stamp.maxSize() > data_size // Fixed or variated stamp that lefts less data then it's min size will also do`
`68`		`- )`
	`65`	`+ if (stamp.isUnbounded() \|\| // Unbounded is always ok`
	`66`	`+ stamp.maxSize() > data_size \|\| // Variated that can consume all data is ok`
	`67`	`+ stamp.minSize() + stamp.maxSize() > data_size // Fixed or variated stamp that lefts less data then it's min size will also do`
	`68`	`+ )`
`69`	`69`	`return true;`
`70`	`70`	`return false;`
`71`	`71`	`}`
`@@ -76,7 +76,7 @@ init_stored_min(std::ref_vector<StampT> stamps_arg)`
`76`	`76`	`{`
`77`	`77`	`int min = std::numeric_limits<int>::max();`
`78`	`78`
`79`		`- for(StampT & stamp : stamps)`
	`79`	`+ for (StampT & stamp : stamps)`
`80`	`80`	`{`
`81`	`81`
`82`	`82`	`if (min > stamp.minSize())`
`@@ -91,13 +91,13 @@ init_stored_max(std::ref_vector<StampT> stamps_arg)`
`91`	`91`	`{`
`92`	`92`	`int max = 0;`
`93`	`93`
`94`		`- for(StampT & stamp : stamps)`
	`94`	`+ for (StampT & stamp : stamps)`
`95`	`95`	`{`
`96`	`96`	`if (stamp.maxSize() == -1)`
`97`	`97`	`return -1;`
`98`	`98`
`99`	`99`	`if (max < stamp.maxSize())`
`100`		`- max = stamp.maxSize();`
	`100`	`+ max = stamp.maxSize();`
`101`	`101`	`}`
`102`	`102`	`return max;`
`103`	`103`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,6 @@ std::string`
`30`	`30`	`StampMathBinaryOp::ExtractStr(std::shared_ptr<Blob> blob)`
`31`	`31`	`{`
`32`	`32`	`std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);`
`33`		`- return (std::string)"(" + stamp1->ExtractStr(blobs[0]) + " "+ op_name + " " + stamp2->ExtractStr(blobs[1]) + ")";`
	`33`	`+ return (std::string)"(" + stamp1->ExtractStr(blobs[0]) + " " + op_name + " " + stamp2->ExtractStr(blobs[1]) + ")";`
`34`	`34`	`}`
`35`	`35`