std::string

PoolPickerStamp::ExtractStr(std::shared_ptr<Blob> blob)

{

fprintf(stderr,"*");

static ORACLE_STAMP stamp_oracle;

ORACLE_TYPE oracle = stamp_oracle.ExtractValue(blob);

:StampStrEnumerator(picker,",","[","]") {};

};

classStampJSONHashEl:publicStampBaseStr

{

std::shared_ptr<StampJSONString> stamp_name;

std::shared_ptr<PoolPickerStamp> stamp_value;

StampJSONHashEl(std::shared_ptr<PoolPickerStamp> picker)

:stamp_value(picker), stamp_name(std::make_shared<StampJSONString>()) {};

virtualintminSize()override {return stamp_name->minSize() + stamp_value->minSize();};

virtualintmaxSize()override {return -1;};

std::stringExtractStr(std::shared_ptr<Blob> blob)override;

};

std::string

StampJSONHashEl::ExtractStr(std::shared_ptr<Blob> blob)

{

std::string n = stamp_name->ExtractStr(blob);

std::string v = stamp_value->ExtractStr(blob);

return n +":" + v;

}

classStampJSONHash:publicStampStrEnumerator

{

std::shared_ptr<StampJSONHashEl> stamp_el;

StampJSONHash(std::shared_ptr<PoolPickerStamp> picker)

:StampStrEnumerator(stamp_el = std::make_shared<StampJSONHashEl>(picker),",","{","}") {};

};

classStampJSON:publicPoolPickerStamp

{

std::shared_ptr<StampJSONString> stamp_s;

std::shared_ptr<StampJSONInt> stamp_i;

std::shared_ptr<StampJSONFloat> stamp_f;

std::shared_ptr<StampJSONArray> stamp_a;

std::shared_ptr<StampJSONHash> stamp_h;

StampJSON();

};

voidnull_deleter(StampJSON *) {}

StampJSON::StampJSON()

: PoolPickerStamp({})

{

stamp_i = std::make_shared<StampJSONInt>();

stamp_f = std::make_shared<StampJSONFloat>();

stamp_s = std::make_shared<StampJSONString>();

stamp_a = std::make_shared<StampJSONArray>(std::shared_ptr<StampJSON>(this, null_deleter));

stamp_h = std::make_shared<StampJSONHash>(std::shared_ptr<StampJSON>(this, null_deleter));

add_weak(stamp_i);

add_weak(stamp_f);

add_weak(stamp_s);

add_weak(stamp_a);

add_weak(stamp_h);

}

main()

{

auto stamp_d = std::make_shared<StampJSONString>();

auto stamp_i = std::make_shared<StampJSONInt>();

auto stamp_f = std::make_shared<StampJSONFloat>();

std::shared_ptr<PoolPickerStamp>picker(newPoolPickerStamp({stamp_i, stamp_f, stamp_d}));

std::shared_ptr<PoolPickerStamp>picker(newPoolPickerStamp({stamp_f, stamp_i, stamp_d}));

auto stamp_a = std::make_shared<StampJSONArray>(picker);

picker->add_weak(stamp_a);

auto stamp_h = std::make_shared<StampJSONHash>(picker);

picker->add_weak(stamp_h);

fprintf(stderr," hash sizes= %i %i\n",stamp_h->minSize(), stamp_h->maxSize());

std::shared_ptr<Blob> blob = std::make_shared<Blob>((char *)bin_sample,strlen((char *)bin_sample));

auto blob = std::make_shared<Blob>((char *)bin_sample,strlen((char *)bin_sample));

auto stamp_j = std::make_shared<StampJSON>();

fprintf(stderr,"%i %i\n",stamp_a->minSize(), stamp_a->maxSize());

{

std::string s = stamp_a->ExtractStr(blob);

std::string s = stamp_h->ExtractStr(blob);

fprintf(stderr,"%i %s\n",picker->isRecursive(), s.c_str());

}