template<classT,classArrayT>

VLATO_ptr<T,ArrayT>::VLATO_ptr(size_t offset,size_t length)

{

_ptr = (T*)malloc( offset +sizeof(ArrayT) * length);

_ptr = (T*)malloc( offset +sizeof(ArrayT) * length -1);

_length = length;

_offset = offset;

}

#include<string>

#include<cstdlib>

#include<vector>

#include<cassert>

#defineWANT_TEST_EXTRAS

#include<tap++/tap++.h>

char short_sample[]="1234567";

char longer_sample[]="z1234567*89abcde&fghijklmnopqrstuvwxyzAB%CDEFGHIJKLMNOPQRSTUVWXYZ!";

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};

template<classT>using my_refvector = std::vector<std::reference_wrapper<T>>;/* This defines my_refvector type a shortcut to std::vector<std::reference_wrapper<T>>*/

{

int variant_count =1;

int variant_selected = -1;

bool enabled =true;

voidSetVariantCount(int i) {variant_count = i;};

intGetVariantCount(){if(enabled)return variant_count;return0;};

voidSetVariantSelected(int i) {variant_selected = i;};

intGetVariantSelected(){return variant_selected;};

voidEnable(){enabled =true;};

voidDisable(){enabled =false;};

};

Variants&

VariantPicker(my_refvector<Variants> ref_vec,unsignedchar seed)

{

unsignedchar max =255;

int total =0;

for(Variants& v : ref_vec)

{

total += v.GetVariantCount();

}

double step = (double)max / total;

int i =0;

double sum =0;

Variants * last_variant;

for(Variants& v : ref_vec)

{

if (v.GetVariantCount() ==0)

continue;

last_variant = &v;

for(i=0; i <v.GetVariantCount(); i++)

{

sum += step/** v.GetVariantCount()*/;

if (seed <= sum)

{

v.SetVariantSelected(i);

return v;

}

}

}

if (abs( seed - sum) >0.1)

{

fprintf(stderr,"Something is really wrong\n");

exit(1);

}

last_variant->SetVariantSelected(last_variant->GetVariantCount()-1);

return ref_vec.back();/*FIXME here should set last variant!!!*/

}

std::vector<unsignedint>

fit_sizes(std::vector<unsignedint> seeds,unsignedint fit_in)

{

long seed_sum =0;

for(int seed : seeds)

{

seed_sum += seed;

}

double proportion = (double) fit_in / (double) seed_sum;

doubleremainder =0;

std::vector<unsignedint> res;

int res_sum =0;

for(int seed : seeds)

{

double d_size = (double) seed * proportion +remainder;

unsignedint size =round(d_size);

remainder = d_size - size;

res.push_back(size);

res_sum += size;

}

assert(res_sum == fit_in);

return res;

}

template<classT>classWeightedRef

{

classGalleySimpleRecusion;

classSimpeRecursionNode:publicStampBase

classSimpeRecursionNode:publicStampBase,publicVariants

{

GalleySimpleRecusion * recursor;

virtual std::stringdo_recursion(Blob &blob) = 0;

virtual std::stringtmpID() = 0;

};

classTestRNode1:publicSimpeRecursionNode

{

std::vector<std::string> operations = {"+","-","*","/","^"};

virtual std::stringdo_recursion(Blob &blob)override;

intminSize()override {return1; };// FIXME correct it

intmaxSize()override {return -1;};/* Sereies always takes as much data as it can take*/

TestRNode1() {SetVariantCount(operations.size());};

std::stringtmpID()override {return"A";};

};

classTestRNode2:publicSimpeRecursionNode

{

virtual std::stringdo_recursion(Blob &blob)override;

intminSize()override {return1; };// FIXME correct it

intmaxSize()override {return -1;};/* Sereies always takes as much data as it can take*/

std::stringtmpID()override {return"B";}

};

classTestRNode3:publicSimpeRecursionNode

{

virtual std::stringdo_recursion(Blob &blob)override;

intminSize()override {return1; };// FIXME correct it

intmaxSize()override {return -1;};/* Sereies always takes as much data as it can take*/

std::stringtmpID()override {return"C";}

};

classGalleySimpleRecusion :publicGalleyBase

TestRNode2 node2;

TestRNode3 node3;

std::vector<std::reference_wrapper<SimpeRecursionNode>> stamps = {node1, node2, node3};

std::vector<std::reference_wrapper<SimpeRecursionNode>> stamps = {node1/*, node2, node3*/};

intminSize()override {return1; };// FIXME correct it

std::string

TestRNode1::do_recursion(Blob &blob)

{

int variant_n =GetVariantSelected();/* Copy it as early as possible as it can be overwritten while recursion*/

StampArithm<unsignedchar> stamp_char;

StampArithm<unsignedshortint> stamp_sint;

unsignedshortint spl_val;

if (blob.Size() < (stamp_sint.minSize() +4* stamp_char.minSize()) )

{

try{

std::string val = stamp_char.ExtractStr(blob);

return val;

}

catch (OutOfData)

{

printf("___________________________ %i\n", blob.Size());

return"Q";

}

}

try{

Blob tmp = blob.ShiftBytes(1);

spl_val = stamp_sint.ExtractValue(blob);

}

catch (OutOfData)

{

return"0";

return"Z";

}

return"1 +" + recursor->do_recursion(blob);

std::vector<unsignedint> split_data_in = {spl_val, (unsignedshortint) std::numeric_limits<unsignedshortint>::max() - spl_val };

std::vector<unsignedint> split_data =fit_sizes(split_data_in, blob.Size() -4* stamp_char.minSize());

printf("llll - %i %i\n", split_data[0], split_data[1]);

Blob blob_left = blob.ShiftBytes(split_data[0]+2*stamp_char.minSize() );

printf("~~~ %i\n",variant_n);

return"(" + recursor->do_recursion(blob_left) +"" + operations[variant_n] +""+ recursor->do_recursion(blob)+")";

}

std::string

std::string

GalleySimpleRecusion::do_recursion(Blob& blob)

{

StampArithm<char> stamp_char;

char c;

StampArithm<unsignedchar> stamp_char;

unsignedchar c;

try{

c = stamp_char.ExtractValue(blob);

}

return"0";

}

c = c %3;

SimpeRecursionNode &node = stamps[c];

std::vector<std::reference_wrapper<Variants>> stamps_v = {node1/*, node2, node3*/};

SimpeRecursionNode& node = (SimpeRecursionNode&)VariantPicker(stamps_v, c);

printf("--- %s - %i - %i\n",node.tmpID().c_str(), c, node.GetVariantSelected());

node.recursor =this;

return node.do_recursion(blob);

}

main()

{

std::vector<unsignedint> v = {1,20,30,10,1};

std::vector<unsignedint> res =fit_sizes(v,6);

for(unsignedint i : res)

{

printf("*** %i\n",i);

}

}

TEST_START(1);

{

Blobblob(short_sample,strlen(short_sample));

Blobblob((char *)bin_sample,strlen((char *)bin_sample));

GalleySimpleRecusion galley;

fprintf(stderr,"--1\n");