Skip to content

Commit 13caa8a

Browse files
kostyafipnataraj-hates-MS-for-stealing-github
kostyafip
authored and
nataraj-hates-MS-for-stealing-github
committed
Replace reference Blob& with pointer std::shared_ptr<Blob> all over the code
1 parent 626e572 commit 13caa8a

26 files changed

+164
-164
lines changed

‎blobstamper/blob.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -46,18 +46,18 @@ Blob::Dump()
4646
hexdump(data + begin, length);
4747
}
4848

49-
Blob
49+
std::shared_ptr<Blob>
5050
Blob::ShiftBytes(size_t n)
5151
{
5252
if (this->Size() < n)
5353
{
5454
throw OutOfData();
5555
}
5656

57-
Blob new_blob(this->data, size);
57+
std::shared_ptr<Blob> new_blob = std::make_shared<Blob>(this->data, size);
5858

59-
new_blob.begin = begin; /* FIXME this should go private once */
60-
new_blob.end = begin + n - 1;
59+
new_blob->begin = begin; /* FIXME this should go private once */
60+
new_blob->end = begin + n - 1;
6161

6262
begin += n;
6363

‎blobstamper/blob.h

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,7 @@
2222
#include <string>
2323
#include <list>
2424
#include <vector>
25+
#include <memory>
2526

2627

2728
class StampBase;
@@ -38,7 +39,7 @@ class Blob
3839
bool isEmpty ();
3940
size_t Size();
4041
void Dump();
41-
Blob ShiftBytes(size_t n);
42+
std::shared_ptr<Blob> ShiftBytes(size_t n);
4243
std::vector<char> ChopBlank(StampBase &stmp);
4344
void DataDup(char *& data_out, size_t& size_out);
4445
std::vector<char> asVector();

‎blobstamper/galley.cpp

Lines changed: 30 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -49,9 +49,9 @@ GalleyVectorBase::minSize()
4949

5050

5151
std::vector<std::string>
52-
GalleyVectorStr::ExtractStrVector(Blob &blob)
52+
GalleyVectorStr::ExtractStrVector(std::shared_ptr<Blob> blob)
5353
{
54-
std::vector<Blob> blobs = extract_internal(blob);
54+
std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);
5555
std::vector<std::string> res(blobs.size());
5656

5757
for(int i = 0; i<blobs.size(); i++)
@@ -62,9 +62,9 @@ GalleyVectorStr::ExtractStrVector(Blob &blob)
6262
}
6363

6464
std::vector<std::vector<char>>
65-
GalleyVectorBin::ExtractBinVector(Blob &blob)
65+
GalleyVectorBin::ExtractBinVector(std::shared_ptr<Blob> blob)
6666
{
67-
std::vector<Blob> blobs = extract_internal(blob);
67+
std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);
6868
std::vector<std::vector<char>> res(blobs.size());
6969

7070
for(int i = 0; i<blobs.size(); i++)
@@ -74,20 +74,20 @@ GalleyVectorBin::ExtractBinVector(Blob &blob)
7474
return res;
7575
}
7676

77-
std::vector<Blob>
78-
GalleyVectorBase::extract_internal(Blob &blob)
77+
std::vector<std::shared_ptr<Blob>>
78+
GalleyVectorBase::extract_internal(std::shared_ptr<Blob> blob)
7979
{
80-
if (blob.Size()<stamp.minSize())
80+
if (blob->Size()<stamp.minSize())
8181
{
8282
throw OutOfData(); /* FIXME: May be later add option that allows empty lists if needed*/
8383
}
84-
std::vector<Blob> res;
84+
std::vector<std::shared_ptr<Blob>> res;
8585
if (stamp.isFixedSize())
8686
{
8787
int size = stamp.minSize();
88-
while (blob.Size() >= size)
88+
while (blob->Size() >= size)
8989
{
90-
Blob el = blob.ShiftBytes(size);
90+
std::shared_ptr<Blob> el = blob->ShiftBytes(size);
9191
res.push_back(el);
9292
}
9393
}
@@ -112,7 +112,7 @@ GalleyVectorBase::extract_internal(Blob &blob)
112112
*/
113113

114114
/* Getting count oracle and normalze it to fit available size */
115-
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
115+
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
116116

117117
ORACLE_STAMP stamp_oracle;
118118
ORACLE_TYPE count_oracle = stamp_oracle.ExtractValue(blob);
@@ -139,7 +139,7 @@ GalleyVectorBase::extract_internal(Blob &blob)
139139
}
140140

141141
/* Calculating available vairable size, that will be destributed between parts according to size oracles */
142-
int data_size = blob.Size();
142+
int data_size = blob->Size();
143143
int fixed_data_size = stamp.minSize() * count_target;
144144
int var_data_size = data_size - fixed_data_size;
145145

@@ -151,7 +151,7 @@ GalleyVectorBase::extract_internal(Blob &blob)
151151
int el_size = el_size_f;
152152
remainder = el_size_f - el_size;
153153

154-
Blob blob2 = blob.ShiftBytes(el_size);
154+
std::shared_ptr<Blob> blob2 = blob->ShiftBytes(el_size);
155155
res.push_back(blob2);
156156
}
157157
}
@@ -163,15 +163,15 @@ GalleyVectorBase::extract_internal(Blob &blob)
163163
ORACLE_STAMP stamp_oracle;
164164
while(1)
165165
{
166-
if(stamp.minSize() + stamp_oracle.minSize() > blob.Size())
166+
if(stamp.minSize() + stamp_oracle.minSize() > blob->Size())
167167
break;
168168

169169
ORACLE_TYPE oracle = stamp_oracle.ExtractValue(blob);
170170

171171
int size = (double) oracle / ORACLE_MAX * (var_size + 1); /* +1 -- это грубая эмуляция округления вверх. oracle == ORACLE_MAX-1 == 65534 должен дать count_max*/
172172
if (size > var_size) size = var_size; // In case we've hit oracle == ORACLE_MAX boundary
173173
size += fixed_size;
174-
Blob blob2 = blob.ShiftBytes(size);
174+
std::shared_ptr<Blob> blob2 = blob->ShiftBytes(size);
175175
res.push_back(blob2);
176176
}
177177
}
@@ -181,10 +181,10 @@ GalleyVectorBase::extract_internal(Blob &blob)
181181

182182
/**********************************************/
183183

184-
std::vector<Blob>
185-
GalleySetBase::extract_internal(Blob &blob)
184+
std::vector<std::shared_ptr<Blob>>
185+
GalleySetBase::extract_internal(std::shared_ptr<Blob> blob)
186186
{
187-
std::vector<Blob> res;
187+
std::vector<std::shared_ptr<Blob>> res;
188188
int fixed_total_size = 0; // Summ of sizes of fixed parts of all stamps
189189
int max_varited_total_size = 0; // Summ of sizes of variable parts of variated stamps
190190
ORACLE_STAMP oracle_stamp;
@@ -225,12 +225,12 @@ GalleySetBase::extract_internal(Blob &blob)
225225
This is a variable that will set limits to gariated stamps greed (will be rediced later */
226226
int varited_total_size_limit = max_varited_total_size;
227227

228-
if(fixed_total_size > blob.Size()) /* Not enought data case*/
228+
if(fixed_total_size > blob->Size()) /* Not enought data case*/
229229
{
230230
throw OutOfData();
231231
}
232232

233-
int avaliable_nonfixed_size = blob.Size() - fixed_total_size; /* The ammount of data available for non-fixed part of variated or unbounded stamps*/
233+
int avaliable_nonfixed_size = blob->Size() - fixed_total_size; /* The ammount of data available for non-fixed part of variated or unbounded stamps*/
234234
if (varited_total_size_limit > avaliable_nonfixed_size)
235235
varited_total_size_limit = avaliable_nonfixed_size; /* Can't use more than we have */
236236

@@ -341,33 +341,33 @@ GalleySetBase::extract_internal(Blob &blob)
341341
unbounded_remainder = len - el_size;
342342
el_size +=s.minSize();
343343
}
344-
Blob blob2 = blob.ShiftBytes(el_size);
344+
std::shared_ptr<Blob> blob2 = blob->ShiftBytes(el_size);
345345
res.push_back(blob2);
346346
}
347347
return res;
348348
}
349349

350350
void
351-
GalleySetBase::LoadAll(Blob &blob)
351+
GalleySetBase::LoadAll(std::shared_ptr<Blob> blob)
352352
{
353-
std::vector<Blob> blobs = extract_internal(blob);
353+
std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);
354354
for(int i=0; i<blobs.size(); i++)
355355
{
356-
Blob blob = blobs[i];
356+
std::shared_ptr<Blob> blob = blobs[i];
357357
StampBase & stamp = stamps[i];
358358
stamp.Load(blob);
359359
}
360360
}
361361

362362

363363
std::vector<std::string>
364-
GalleySetStr::ExtractStrSet(Blob &blob)
364+
GalleySetStr::ExtractStrSet(std::shared_ptr<Blob> blob)
365365
{
366366
std::vector<std::string> res;
367-
std::vector<Blob> blobs = extract_internal(blob);
367+
std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);
368368
for(int i=0; i<blobs.size(); i++)
369369
{
370-
Blob blob = blobs[i];
370+
std::shared_ptr<Blob> blob = blobs[i];
371371
StampBaseStr & stamp = s_stamps[i];
372372
std::string str = stamp.ExtractStr(blob);
373373
res.push_back(str);
@@ -376,13 +376,13 @@ GalleySetStr::ExtractStrSet(Blob &blob)
376376
}
377377

378378
std::vector<std::vector<char>>
379-
GalleySetBin::ExtractBinSet(Blob &blob)
379+
GalleySetBin::ExtractBinSet(std::shared_ptr<Blob> blob)
380380
{
381381
std::vector<std::vector<char>> res;
382-
std::vector<Blob> blobs = extract_internal(blob);
382+
std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);
383383
for(int i=0; i<blobs.size(); i++)
384384
{
385-
Blob blob = blobs[i];
385+
std::shared_ptr<Blob> blob = blobs[i];
386386
StampBaseBin & stamp = b_stamps[i];
387387
std::vector<char> v = stamp.ExtractBin(blob);
388388
res.push_back(v);

‎blobstamper/galley.h

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -46,7 +46,7 @@ class GalleyVectorBase : public GalleyBase
4646
StampBase &stamp;
4747
public:
4848
GalleyVectorBase(StampBase & stamp_arg) : stamp(stamp_arg) {};
49-
std::vector<Blob> extract_internal(Blob &blob);
49+
std::vector<std::shared_ptr<Blob>> extract_internal(std::shared_ptr<Blob> blob);
5050
int minSize() override;
5151
int maxSize() override {return -1;}; /* Sereies always takes as much data as it can take */
5252
};
@@ -56,7 +56,7 @@ class GalleyVectorStr: public GalleyVectorBase
5656
{
5757
public:
5858
GalleyVectorStr(StampBaseStr & stamp_arg): GalleyVectorBase(stamp_arg) {};
59-
std::vector<std::string> ExtractStrVector(Blob &blob);
59+
std::vector<std::string> ExtractStrVector(std::shared_ptr<Blob> blob);
6060
};
6161

6262
template<class T> class GalleyVectorStrStampBase: public GalleyVectorStr, public StampBaseStr
@@ -74,7 +74,7 @@ class GalleyVectorBin: public GalleyVectorBase
7474
StampBaseBin & b_stamp;
7575
public:
7676
GalleyVectorBin(StampBaseBin & stamp_arg): GalleyVectorBase(stamp_arg), b_stamp(stamp_arg) {};
77-
std::vector<std::vector<char>> ExtractBinVector(Blob &blob);
77+
std::vector<std::vector<char>> ExtractBinVector(std::shared_ptr<Blob> blob);
7878
};
7979

8080

@@ -83,14 +83,14 @@ template<class T> class GalleyVectorV: public GalleyVectorBase
8383
StampBaseV<T>& v_stamp;
8484
public:
8585
GalleyVectorV(StampBaseV<T> & stamp_arg): GalleyVectorBase(stamp_arg), v_stamp(stamp_arg) {};
86-
std::vector<T> ExtractValuesVector(Blob &blob);
86+
std::vector<T> ExtractValuesVector(std::shared_ptr<Blob> blob);
8787
};
8888

8989

9090
template<class T> std::vector<T>
91-
GalleyVectorV<T>::ExtractValuesVector(Blob &blob)
91+
GalleyVectorV<T>::ExtractValuesVector(std::shared_ptr<Blob> blob)
9292
{
93-
std::vector<Blob> blobs = extract_internal(blob);
93+
std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);
9494
std::vector<T> res(blobs.size());
9595

9696
for(int i=0; i<blobs.size(); i++)
@@ -107,8 +107,8 @@ class GalleySetBase : public GalleyBase
107107
std::vector<std::reference_wrapper<StampBase>> stamps;
108108
public:
109109
GalleySetBase(std::vector<std::reference_wrapper<StampBase>> arg) : stamps(arg) {};
110-
std::vector<Blob> extract_internal(Blob &blob);
111-
void LoadAll(Blob &blob);
110+
std::vector<std::shared_ptr<Blob>> extract_internal(std::shared_ptr<Blob> blob);
111+
void LoadAll(std::shared_ptr<Blob> blob);
112112

113113
int minSize() override;
114114
int maxSize() override;
@@ -119,7 +119,7 @@ class GalleySetBin : public GalleySetBase
119119
std::vector<std::reference_wrapper<StampBaseBin>> b_stamps;
120120
public:
121121
GalleySetBin(std::vector<std::reference_wrapper<StampBaseBin>> arg) : GalleySetBase(cast_arg(arg)), b_stamps(arg) {};
122-
std::vector<std::vector<char>> ExtractBinSet(Blob &blob);
122+
std::vector<std::vector<char>> ExtractBinSet(std::shared_ptr<Blob> blob);
123123

124124
std::vector<std::reference_wrapper<StampBase>> cast_arg(std::vector<std::reference_wrapper<StampBaseBin>> in)
125125
{
@@ -138,7 +138,7 @@ class GalleySetStr : public GalleySetBase
138138
std::vector<std::reference_wrapper<StampBaseStr>> s_stamps;
139139
public:
140140
GalleySetStr(std::vector<std::reference_wrapper<StampBaseStr>> arg) : GalleySetBase(cast_arg(arg)), s_stamps(arg) {};
141-
std::vector<std::string> ExtractStrSet(Blob &blob);
141+
std::vector<std::string> ExtractStrSet(std::shared_ptr<Blob> blob);
142142

143143
std::vector<std::reference_wrapper<StampBase>> cast_arg(std::vector<std::reference_wrapper<StampBaseStr>> in)
144144
{

‎blobstamper/stamp.cpp

Lines changed: 6 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -27,24 +27,23 @@
2727

2828

2929
void
30-
StampBase::Load(Blob &blob)
30+
StampBase::Load(std::shared_ptr<Blob> blob)
3131
{
3232

33-
if (minSize() > blob.Size())
33+
if (minSize() > blob->Size())
3434
{
3535
throw OutOfData();
3636
}
3737

3838
size_t res_size;
3939
if (isUnbounded())
4040
{
41-
res_size = blob.Size();
41+
res_size = blob->Size();
4242
} else
4343
{
4444
res_size = maxSize();
45-
if (res_size > blob.Size())
46-
res_size = blob.Size();
45+
if (res_size > blob->Size())
46+
res_size = blob->Size();
4747
}
48-
Blob *pb = new Blob(blob.ShiftBytes(res_size));
49-
bitten_blob = std::unique_ptr<Blob>(pb);
48+
bitten_blob = blob->ShiftBytes(res_size);
5049
}

0 commit comments

Comments
 (0)
pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy