Skip to content

Blob shared ptr #5

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 4 additions & 4 deletions blobstamper/blob.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -46,18 +46,18 @@ Blob::Dump()
hexdump(data + begin, length);
}

Blob
std::shared_ptr<Blob>
Blob::ShiftBytes(size_t n)
{
if (this->Size() < n)
{
throw OutOfData();
}

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

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

begin += n;

Expand Down
3 changes: 2 additions & 1 deletion blobstamper/blob.h
Original file line number Diff line number Diff line change
Expand Up @@ -22,6 +22,7 @@
#include <string>
#include <list>
#include <vector>
#include <memory>


class StampBase;
Expand All @@ -38,7 +39,7 @@ class Blob
bool isEmpty ();
size_t Size();
void Dump();
Blob ShiftBytes(size_t n);
std::shared_ptr<Blob> ShiftBytes(size_t n);
std::vector<char> ChopBlank(StampBase &stmp);
void DataDup(char *& data_out, size_t& size_out);
std::vector<char> asVector();
Expand Down
3 changes: 2 additions & 1 deletion blobstamper/blobstamper.h
Original file line number Diff line number Diff line change
Expand Up @@ -24,4 +24,5 @@
#include "galley.h"
#include "stamp_enumerator.h"
#include "stamp_lottery.h"
#include "stamp_math_op.h"
#include "stamp_math_op.h"
#include "stamp_text.h"
60 changes: 30 additions & 30 deletions blobstamper/galley.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -49,9 +49,9 @@ GalleyVectorBase::minSize()


std::vector<std::string>
GalleyVectorStr::ExtractStrVector(Blob &blob)
GalleyVectorStr::ExtractStrVector(std::shared_ptr<Blob> blob)
{
std::vector<Blob> blobs = extract_internal(blob);
std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);
std::vector<std::string> res(blobs.size());

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

std::vector<std::vector<char>>
GalleyVectorBin::ExtractBinVector(Blob &blob)
GalleyVectorBin::ExtractBinVector(std::shared_ptr<Blob> blob)
{
std::vector<Blob> blobs = extract_internal(blob);
std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);
std::vector<std::vector<char>> res(blobs.size());

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

std::vector<Blob>
GalleyVectorBase::extract_internal(Blob &blob)
std::vector<std::shared_ptr<Blob>>
GalleyVectorBase::extract_internal(std::shared_ptr<Blob> blob)
{
if (blob.Size()<stamp.minSize())
if (blob->Size()<stamp.minSize())
{
throw OutOfData(); /* FIXME: May be later add option that allows empty lists if needed*/
}
std::vector<Blob> res;
std::vector<std::shared_ptr<Blob>> res;
if (stamp.isFixedSize())
{
int size = stamp.minSize();
while (blob.Size() >= size)
while (blob->Size() >= size)
{
Blob el = blob.ShiftBytes(size);
std::shared_ptr<Blob> el = blob->ShiftBytes(size);
res.push_back(el);
}
}
Expand All @@ -112,7 +112,7 @@ GalleyVectorBase::extract_internal(Blob &blob)
*/

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

ORACLE_STAMP stamp_oracle;
ORACLE_TYPE count_oracle = stamp_oracle.ExtractValue(blob);
Expand All @@ -139,7 +139,7 @@ GalleyVectorBase::extract_internal(Blob &blob)
}

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

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

Blob blob2 = blob.ShiftBytes(el_size);
std::shared_ptr<Blob> blob2 = blob->ShiftBytes(el_size);
res.push_back(blob2);
}
}
Expand All @@ -163,15 +163,15 @@ GalleyVectorBase::extract_internal(Blob &blob)
ORACLE_STAMP stamp_oracle;
while(1)
{
if(stamp.minSize() + stamp_oracle.minSize() > blob.Size())
if(stamp.minSize() + stamp_oracle.minSize() > blob->Size())
break;

ORACLE_TYPE oracle = stamp_oracle.ExtractValue(blob);

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

/**********************************************/

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

if(fixed_total_size > blob.Size()) /* Not enought data case*/
if(fixed_total_size > blob->Size()) /* Not enought data case*/
{
throw OutOfData();
}

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

Expand Down Expand Up @@ -341,33 +341,33 @@ GalleySetBase::extract_internal(Blob &blob)
unbounded_remainder = len - el_size;
el_size +=s.minSize();
}
Blob blob2 = blob.ShiftBytes(el_size);
std::shared_ptr<Blob> blob2 = blob->ShiftBytes(el_size);
res.push_back(blob2);
}
return res;
}

void
GalleySetBase::LoadAll(Blob &blob)
GalleySetBase::LoadAll(std::shared_ptr<Blob> blob)
{
std::vector<Blob> blobs = extract_internal(blob);
std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);
for(int i=0; i<blobs.size(); i++)
{
Blob blob = blobs[i];
std::shared_ptr<Blob> blob = blobs[i];
StampBase & stamp = stamps[i];
stamp.Load(blob);
}
}


std::vector<std::string>
GalleySetStr::ExtractStrSet(Blob &blob)
GalleySetStr::ExtractStrSet(std::shared_ptr<Blob> blob)
{
std::vector<std::string> res;
std::vector<Blob> blobs = extract_internal(blob);
std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);
for(int i=0; i<blobs.size(); i++)
{
Blob blob = blobs[i];
std::shared_ptr<Blob> blob = blobs[i];
StampBaseStr & stamp = s_stamps[i];
std::string str = stamp.ExtractStr(blob);
res.push_back(str);
Expand All @@ -376,13 +376,13 @@ GalleySetStr::ExtractStrSet(Blob &blob)
}

std::vector<std::vector<char>>
GalleySetBin::ExtractBinSet(Blob &blob)
GalleySetBin::ExtractBinSet(std::shared_ptr<Blob> blob)
{
std::vector<std::vector<char>> res;
std::vector<Blob> blobs = extract_internal(blob);
std::vector<std::shared_ptr<Blob>> blobs = extract_internal(blob);
for(int i=0; i<blobs.size(); i++)
{
Blob blob = blobs[i];
std::shared_ptr<Blob> blob = blobs[i];
StampBaseBin & stamp = b_stamps[i];
std::vector<char> v = stamp.ExtractBin(blob);
res.push_back(v);
Expand Down
20 changes: 10 additions & 10 deletions blobstamper/galley.h
Original file line number Diff line number Diff line change
Expand Up @@ -46,7 +46,7 @@ class GalleyVectorBase : public GalleyBase
StampBase &stamp;
public:
GalleyVectorBase(StampBase & stamp_arg) : stamp(stamp_arg) {};
std::vector<Blob> extract_internal(Blob &blob);
std::vector<std::shared_ptr<Blob>> extract_internal(std::shared_ptr<Blob> blob);
int minSize() override;
int maxSize() override {return -1;}; /* Sereies always takes as much data as it can take */
};
Expand All @@ -56,7 +56,7 @@ class GalleyVectorStr: public GalleyVectorBase
{
public:
GalleyVectorStr(StampBaseStr & stamp_arg): GalleyVectorBase(stamp_arg) {};
std::vector<std::string> ExtractStrVector(Blob &blob);
std::vector<std::string> ExtractStrVector(std::shared_ptr<Blob> blob);
};

template<class T> class GalleyVectorStrStampBase: public GalleyVectorStr, public StampBaseStr
Expand All @@ -74,7 +74,7 @@ class GalleyVectorBin: public GalleyVectorBase
StampBaseBin & b_stamp;
public:
GalleyVectorBin(StampBaseBin & stamp_arg): GalleyVectorBase(stamp_arg), b_stamp(stamp_arg) {};
std::vector<std::vector<char>> ExtractBinVector(Blob &blob);
std::vector<std::vector<char>> ExtractBinVector(std::shared_ptr<Blob> blob);
};


Expand All @@ -83,14 +83,14 @@ template<class T> class GalleyVectorV: public GalleyVectorBase
StampBaseV<T>& v_stamp;
public:
GalleyVectorV(StampBaseV<T> & stamp_arg): GalleyVectorBase(stamp_arg), v_stamp(stamp_arg) {};
std::vector<T> ExtractValuesVector(Blob &blob);
std::vector<T> ExtractValuesVector(std::shared_ptr<Blob> blob);
};


template<class T> std::vector<T>
GalleyVectorV<T>::ExtractValuesVector(Blob &blob)
GalleyVectorV<T>::ExtractValuesVector(std::shared_ptr<Blob> blob)
{
std::vector<Blob> blobs = extract_internal(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++)
Expand All @@ -107,8 +107,8 @@ class GalleySetBase : public GalleyBase
std::vector<std::reference_wrapper<StampBase>> stamps;
public:
GalleySetBase(std::vector<std::reference_wrapper<StampBase>> arg) : stamps(arg) {};
std::vector<Blob> extract_internal(Blob &blob);
void LoadAll(Blob &blob);
std::vector<std::shared_ptr<Blob>> extract_internal(std::shared_ptr<Blob> blob);
void LoadAll(std::shared_ptr<Blob> blob);

int minSize() override;
int maxSize() override;
Expand All @@ -119,7 +119,7 @@ class GalleySetBin : public GalleySetBase
std::vector<std::reference_wrapper<StampBaseBin>> b_stamps;
public:
GalleySetBin(std::vector<std::reference_wrapper<StampBaseBin>> arg) : GalleySetBase(cast_arg(arg)), b_stamps(arg) {};
std::vector<std::vector<char>> ExtractBinSet(Blob &blob);
std::vector<std::vector<char>> ExtractBinSet(std::shared_ptr<Blob> blob);

std::vector<std::reference_wrapper<StampBase>> cast_arg(std::vector<std::reference_wrapper<StampBaseBin>> in)
{
Expand All @@ -138,7 +138,7 @@ class GalleySetStr : public GalleySetBase
std::vector<std::reference_wrapper<StampBaseStr>> s_stamps;
public:
GalleySetStr(std::vector<std::reference_wrapper<StampBaseStr>> arg) : GalleySetBase(cast_arg(arg)), s_stamps(arg) {};
std::vector<std::string> ExtractStrSet(Blob &blob);
std::vector<std::string> ExtractStrSet(std::shared_ptr<Blob> blob);

std::vector<std::reference_wrapper<StampBase>> cast_arg(std::vector<std::reference_wrapper<StampBaseStr>> in)
{
Expand Down
13 changes: 6 additions & 7 deletions blobstamper/stamp.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -27,24 +27,23 @@


void
StampBase::Load(Blob &blob)
StampBase::Load(std::shared_ptr<Blob> blob)
{

if (minSize() > blob.Size())
if (minSize() > blob->Size())
{
throw OutOfData();
}

size_t res_size;
if (isUnbounded())
{
res_size = blob.Size();
res_size = blob->Size();
} else
{
res_size = maxSize();
if (res_size > blob.Size())
res_size = blob.Size();
if (res_size > blob->Size())
res_size = blob->Size();
}
Blob *pb = new Blob(blob.ShiftBytes(res_size));
bitten_blob = std::unique_ptr<Blob>(pb);
bitten_blob = blob->ShiftBytes(res_size);
}
Loading