Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Commit ba7f4f6

Browse files
nataraj-hates-MS-for-stealing-githubnataraj-hates-MS-for-stealing-github
committed
JSON Stamp. Work started
1 parent 2faa3fa commit ba7f4f6

File tree

5 files changed

+298
-13
lines changed

5 files changed

+298
-13
lines changed

‎blobstamper/galley.cpp

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -152,7 +152,7 @@ GalleyVectorBase::extract_internal(std::shared_ptr<Blob> blob)
152152
int el_size = el_size_f;
153153
remainder = el_size_f - el_size;
154154

155-
std::shared_ptr<Blob> blob2 = blob->Chop(el_size);
155+
std::shared_ptr<Blob> blob2 = blob->Chop(el_size);
156156
res.push_back(blob2);
157157
}
158158
}
@@ -161,6 +161,8 @@ GalleyVectorBase::extract_internal(std::shared_ptr<Blob> blob)
161161
/* Stamp is variated size */
162162
int fixed_size = stamp->minSize();
163163
int var_size = stamp->maxSize() - fixed_size;
164+
fprintf(stderr, "fixed = %i, var_size = %i\n", fixed_size, var_size);
165+
164166
ORACLE_STAMP stamp_oracle;
165167
while(1)
166168
{
@@ -172,7 +174,8 @@ GalleyVectorBase::extract_internal(std::shared_ptr<Blob> blob)
172174
int size = (double) oracle / ORACLE_MAX * (var_size + 1); /* +1 -- это грубая эмуляция округления вверх. oracle == ORACLE_MAX-1 == 65534 должен дать count_max*/
173175
if (size > var_size) size = var_size; // In case we've hit oracle == ORACLE_MAX boundary
174176
size += fixed_size;
175-
std::shared_ptr<Blob> blob2 = blob->Chop(size);
177+
fprintf(stderr,"---- %i %i\n", size, blob->Size());
178+
std::shared_ptr<Blob> blob2 = blob->Chop(size);
176179
res.push_back(blob2);
177180
}
178181
}

‎blobstamper/stamp.h

Lines changed: 14 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -32,15 +32,27 @@ class StampBase
3232
{
3333
protected:
3434
std::shared_ptr<Blob> bitten_blob;
35+
bool is_recursive = 0;
36+
bool is_in_recursion = 0;
3537
public:
36-
virtual int minSize() = 0;
37-
virtual int maxSize() = 0;
38+
virtual int minSize() = 0;
39+
virtual int maxSize() = 0;
3840

3941
void Load(std::shared_ptr<Blob> blob);
4042

4143
bool isFixedSize() {return minSize() == maxSize();}
4244
bool isVariated() {return ! isFixedSize() && ! isUnbounded();}
4345
bool isUnbounded() {return maxSize() == -1;}
46+
virtual bool isRecursive() {return is_recursive;}
47+
};
48+
49+
class StampRecursive: public virtual StampBase
50+
{
51+
protected:
52+
// bool is_in_recursion = 0;
53+
public:
54+
StampRecursive() {is_recursive = 1;}
55+
virtual ssize_t minSizeNR() = 0;
4456
};
4557

4658

‎blobstamper/stamp_dict.h

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -53,4 +53,14 @@ class StampDictLCAlphaSmall : public StampDict
5353
StampDictLCAlphaSmall (): StampDict(std::make_shared<DictLCAlphaSmall>()) {};
5454
};
5555

56+
57+
template<class T> class StampDictT: public StampDict
58+
{
59+
protected:
60+
std::shared_ptr<T> dict;
61+
public:
62+
StampDictT<T>(): StampDict(dict = std::make_shared<T>()) {};
63+
};
64+
65+
5666
#endif /* STAMP_DICT_H */

‎t/300-galley.cpp

Lines changed: 14 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -123,26 +123,31 @@ main()
123123
but at least here we check that it work the same way it worked before. May be this test should be improved later*/
124124

125125
char sample[]="z1234567*89abcde&fghijklm";
126-
126+
char sample2[]="1234";
127127
std::string expected1 = "234";
128128
std::string expected2 = "7*8";
129129
std::string expected3 = "bcde";
130130
std::string expected4 = "ghij";
131131

132-
std::shared_ptr<Blob> blob = std::make_shared<Blob>(sample, strlen(sample));
133-
std::shared_ptr<StampSeveralChars> stamp = std::make_shared<StampSeveralChars>();
132+
auto blob = std::make_shared<Blob>(sample, strlen(sample));
133+
auto stamp = std::make_shared<StampSeveralChars>();
134134
GalleyVectorStr galley(stamp);
135135

136136
std::vector<std::string> res = galley.ExtractStrVector(blob);
137-
std::string str;
137+
// std::string str;
138138

139-
is(res[0], expected1, "GalleyVector, unlimited size string stamp: First element of shifted list is ok");
140-
is(res[1], expected2, "GalleyVector, unlimited size string stamp: Second element of shifted list is ok");
141-
is(res[2], expected3, "GalleyVector, unlimited size string stamp: Third element of shifted list is ok");
142-
is(res[3], expected4, "GalleyVector, unlimited size string stamp: Fourth element of shifted list is ok");
139+
is(res[0], expected1, "GalleyVector, variated size string stamp: First element of shifted list is ok");
140+
is(res[1], expected2, "GalleyVector, variated size string stamp: Second element of shifted list is ok");
141+
is(res[2], expected3, "GalleyVector, variated size string stamp: Third element of shifted list is ok");
142+
is(res[3], expected4, "GalleyVector, variated size string stamp: Fourth element of shifted list is ok");
143+
144+
is(res.size(), 4, "GalleyVector, variated size string stamp: The list has only 4 members");
143145

144-
is(res.size(), 4, "GalleyVector, unlimited size string stamp: The list has only 4 members");
146+
auto blob2 = std::make_shared<Blob>(sample2, strlen(sample2));
147+
res = galley.ExtractStrVector(blob2);
148+
145149

150+
146151
}
147152

148153
/* Test GalleySet with fixed size stamps*/

‎t/321-galley-recursion-experiments_2.cpp

Lines changed: 255 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,255 @@
1+
/******************************************************************************
2+
*
3+
* Copyright 2021 Nikolay Shaplov (Postgres Professional)
4+
*
5+
* Licensed under the Apache License, Version 2.0 (the "License");
6+
* you may not use this file except in compliance with the License.
7+
* You may obtain a copy of the License at
8+
*
9+
* http://www.apache.org/licenses/LICENSE-2.0
10+
*
11+
* Unless required by applicable law or agreed to in writing, software
12+
* distributed under the License is distributed on an "AS IS" BASIS,
13+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14+
* See the License for the specific language governing permissions and
15+
* limitations under the License.
16+
*
17+
******************************************************************************/
18+
19+
#include <string.h>
20+
21+
#include <exception>
22+
#include <string>
23+
#include <cstdlib>
24+
#include <vector>
25+
#include <cassert>
26+
#define WANT_TEST_EXTRAS
27+
#include <tap++/tap++.h>
28+
29+
#include "blobstamper/blobstamper.h"
30+
#include "blobstamper/dict.h"
31+
32+
#include "test-chars-stamps.h"
33+
34+
using namespace TAP;
35+
36+
char short_sample[]="1234567";
37+
char longer_sample[]="z1234567*89abcde&fghijklmnopqrstuvwxyzAB%CDEFGHIJKLMNOPQRSTUVWXYZ!";
38+
unsigned char bin_sample[]= {49, 22, 152, 226, 89, 119, 247, 115, 43, 42, 243, 71, 234, 231, 91, 35, 78, 108, 115, 39, 181, 248, 211, 52, 47, 94, 60, 237, 18, 39, 148, 62, 205, 214, 156, 184, 18, 201, 84, 183, 74, 134, 94, 72, 14, 116, 145, 109, 1, 230, 17, 95, 154, 100, 60, 15, 12, 102, 20, 115, 35, 183, 47, 176, 78, 176, 189, 113, 131, 93, 206, 62, 158, 166, 131, 95, 232, 217, 32, 171, 87, 31, 172, 160, 66, 160, 222, 134, 253, 1, 7, 191, 91, 125, 81, 148, 41, 46, 38, 171, 83, 215, 79, 34, 23, 215, 183, 118, 236, 191, 59, 160, 135, 58, 32, 199, 170, 183, 213, 53, 162, 138, 178, 118, 23, 202, 133, 8, 192, 183, 195, 199, 250, 29, 230, 34, 159, 10, 145, 74, 121, 85, 168, 204, 192, 25, 232, 88, 85, 76, 61, 168, 247, 128, 141, 176, 112, 113, 100, 201, 82, 183, 219, 236, 226, 171, 85, 97, 160, 1, 50, 250, 161, 51, 61, 220, 167, 227, 195, 17, 164, 211, 189, 130, 52, 167, 169, 42, 17, 29, 95, 15, 178, 165, 110, 87, 149, 214, 55, 12, 236, 138, 2, 245, 158, 84, 140, 24, 225, 169, 115, 16, 130, 253, 237, 182, 95, 109, 4, 28, 249, 4, 254, 166, 62, 107, 228, 113, 130, 127, 70, 79, 140, 41, 84, 218, 134, 146, 88, 65, 24, 174, 252, 253, 226, 214, 22, 92, 248, 14, 29, 60, 180, 94, 30, 186, 0};
39+
40+
41+
42+
//class SimpeRecursionNode;
43+
//class TestRNode1;
44+
//class TestRNode2;
45+
//class TestRNode3;
46+
47+
size_t
48+
Proportion(ORACLE_TYPE oracle, size_t min, size_t max)
49+
{
50+
/* Sorry explanation is in Russian. PR translation if you can */
51+
/* Считаем пропорацию, с округлением вниз.
52+
* Диапазон увиличиваем на единицу, чтобы хвост диапазона пресказания при
53+
* округлении вниз как раз попадал в последний элемент целевого диапозона.
54+
* Разброс предсказания увеличиваем на единицу, так чтобы ровно на конец
55+
* хвоста диапазона предсказания не попасть никогда и тогда он не округлиться
56+
* в max + 1*/
57+
size_t delta = max - min + 1;
58+
size_t res = floor(((float) oracle) / ((float) ORACLE_MAX + 1) * delta );
59+
return min + res;
60+
}
61+
62+
class PoolPickerStamp : public virtual StampBaseStr
63+
{
64+
protected:
65+
std::vector<std::shared_ptr<StampBaseStr>> pool;
66+
std::vector<std::weak_ptr<StampBaseStr>> weak_pool;
67+
68+
public:
69+
PoolPickerStamp(std::vector<std::shared_ptr<StampBaseStr>> new_pool);
70+
~PoolPickerStamp() {fprintf(stderr, "DESTROY!\n");};
71+
72+
std::string ExtractStr(std::shared_ptr<Blob> blob) override;
73+
virtual void add_weak(std::shared_ptr<StampBaseStr> stamp);
74+
virtual bool isRecursive();
75+
virtual int minSize() override;
76+
virtual int maxSize() override;
77+
};
78+
79+
80+
PoolPickerStamp::PoolPickerStamp(std::vector<std::shared_ptr<StampBaseStr>> new_pool)
81+
: pool{new_pool}
82+
{
83+
for(auto stamp : pool)
84+
{
85+
std::weak_ptr<StampBaseStr> wp = stamp;
86+
weak_pool.push_back(wp);
87+
}
88+
}
89+
90+
bool
91+
PoolPickerStamp::isRecursive()
92+
{
93+
if(is_recursive || is_in_recursion)
94+
return true;
95+
is_in_recursion = true;
96+
for(auto stamp : pool)
97+
{
98+
if (stamp->isRecursive())
99+
{
100+
is_recursive = true; // Once recursive -- recursive forever.
101+
is_in_recursion = false;
102+
return true;
103+
}
104+
}
105+
is_in_recursion = false;
106+
return false;
107+
}
108+
109+
std::string
110+
PoolPickerStamp::ExtractStr(std::shared_ptr<Blob> blob)
111+
{
112+
fprintf(stderr, "*");
113+
static ORACLE_STAMP stamp_oracle;
114+
ORACLE_TYPE oracle = stamp_oracle.ExtractValue(blob);
115+
116+
std::vector<std::weak_ptr<StampBaseStr>> target_pool;
117+
for(auto stamp : weak_pool)
118+
{
119+
if (stamp.lock()->minSize() <= blob->Size())
120+
{
121+
target_pool.push_back(stamp);
122+
}
123+
}
124+
125+
size_t index = Proportion(oracle, 0, target_pool.size() - 1);
126+
return target_pool[index].lock()->ExtractStr(blob);
127+
}
128+
129+
int
130+
PoolPickerStamp::minSize()
131+
{
132+
int res = INT_MAX;
133+
/* Do not check is_recursive here: even if stamp is known to be recursive we
134+
* still should iterate all his non-recursive children to find real minimal
135+
* size */
136+
if (is_in_recursion)
137+
return res;
138+
is_in_recursion = 1; /* Do not use isRecursive() inside as it uses same flag*/
139+
for(auto stamp : pool)
140+
{
141+
int candidat = stamp->minSize();
142+
if (res > candidat)
143+
res = candidat;
144+
}
145+
is_in_recursion = 0;
146+
res += ORACLE_SIZE;
147+
return res;
148+
}
149+
150+
int
151+
PoolPickerStamp::maxSize()
152+
{
153+
int res = 0;
154+
if (is_recursive || is_in_recursion)
155+
return -1;
156+
is_in_recursion = 1; /* Do not use isRecursive() inside as it uses same flag*/
157+
for(auto stamp : pool)
158+
{
159+
int candidat = stamp->maxSize();
160+
if (candidat == -1)
161+
return -1;
162+
if (res < candidat)
163+
res = candidat;
164+
}
165+
is_in_recursion = 0;
166+
res += ORACLE_SIZE;
167+
return res;
168+
}
169+
170+
void
171+
PoolPickerStamp::add_weak(std::shared_ptr<StampBaseStr> stamp)
172+
{
173+
weak_pool.push_back(stamp);
174+
}
175+
176+
class StampJSONInt : public virtual StampArithm<long int>
177+
{
178+
};
179+
180+
class StampJSONFloat : public virtual StampArithm<double>
181+
{
182+
};
183+
184+
class StampJSONString : public virtual StampDictT<DictLCAlphaSmall>
185+
{
186+
protected:
187+
public:
188+
std::string ExtractStr(std::shared_ptr<Blob> blob) override;
189+
};
190+
191+
192+
std::string
193+
StampJSONString::ExtractStr(std::shared_ptr<Blob> blob)
194+
{
195+
std::string res = "\"" + StampDictT<DictLCAlphaSmall>::ExtractStr(blob) +"\"";
196+
return res;
197+
}
198+
199+
200+
class StampJSONArray: public StampStrEnumerator
201+
{
202+
private:
203+
public:
204+
StampJSONArray(std::shared_ptr<PoolPickerStamp> picker)
205+
:StampStrEnumerator(picker, ", ", "[", "]") {};
206+
};
207+
208+
209+
210+
int
211+
main()
212+
{
213+
// auto dict =std::make_shared<DictLCAlphaSmall>();
214+
// auto stamp_d = std::make_shared<StampDict>(dict);
215+
// auto stamp_d = std::make_shared<StampDictT<DictLCAlphaSmall>>();
216+
// auto stamp_i = std::make_shared<StampArithm<long int>>();
217+
// auto stamp_f = std::make_shared<StampArithm<float>>();
218+
//
219+
auto stamp_d = std::make_shared<StampJSONString>();
220+
auto stamp_i = std::make_shared<StampJSONInt>();
221+
auto stamp_f = std::make_shared<StampJSONFloat>();
222+
223+
224+
// PoolPickerStamp stamp({stamp_i, stamp_f, stamp_d});
225+
std::shared_ptr<PoolPickerStamp> picker(new PoolPickerStamp({stamp_i, stamp_f, stamp_d}));
226+
// picker->add_weak(picker);
227+
auto stamp_a = std::make_shared<StampJSONArray>(picker);
228+
picker->add_weak(stamp_a);
229+
230+
231+
std::shared_ptr<Blob> blob = std::make_shared<Blob>((char *)bin_sample, strlen((char *)bin_sample));
232+
233+
234+
fprintf(stderr,"%i %i \n",stamp_a->minSize(), stamp_a->maxSize());
235+
// for(int i =0; i<25; i++)
236+
{
237+
std::string s = stamp_a->ExtractStr(blob);
238+
239+
fprintf(stderr,"%i %s\n",picker->isRecursive(), s.c_str());
240+
}
241+
242+
243+
244+
TEST_START(6);
245+
{
246+
is(Proportion(0,0,255), 0);
247+
is(Proportion(255,0,255), 0);
248+
is(Proportion(256,0,255), 1);
249+
is(Proportion(65535,0,255), 255);
250+
is(Proportion(65535-255,0,255), 255);
251+
is(Proportion(65535-256,0,255), 254);
252+
253+
}
254+
TEST_END;
255+
}

0 commit comments

Comments
 (0)