void _serialize(std::iostream &fs, serialization_context &context) {
assert(target > 0);
assert(context.ss.objects.count(target) > 0);
fs << target << " ";
target = 0;
assert(fs.good());
context.is_leaf = false;
}
void grab_content(const char* file_name, std::iostream& in) {
parser p(file_name);
interpreter_DAG ipt(p.get_problem_representation(), in);
if (!in.good())
error("unexpected error");
}
void _deserialize(std::iostream &fs, serialization_context &context) {
assert(target == 0);
ss = &context.ss;
fs >> target;
assert(fs.good());
assert(context.ss.objects.count(target) > 0);
// We just created a new reference to this object and
// invalidated the on-disk reference, so the total refcount
// stays the same.
}
template<class Key, class Value> void serialize(std::iostream &fs,
serialization_context &context,
std::map<Key, Value> &mp)
{
fs << "map " << mp.size() << " {" << std::endl;
assert(fs.good());
for (auto it = mp.begin(); it != mp.end(); ++it) {
fs << " ";
serialize(fs, context, it->first);
fs << " -> ";
serialize(fs, context, it->second);
fs << std::endl;
}
fs << "}" << std::endl;
}
template<class Key, class Value> void deserialize(std::iostream &fs,
serialization_context &context,
std::map<Key, Value> &mp)
{
std::string dummy;
int size = 0;
fs >> dummy >> size >> dummy;
assert(fs.good());
for (int i = 0; i < size; i++) {
Key k;
Value v;
deserialize(fs, context, k);
fs >> dummy;
deserialize(fs, context, v);
mp[k] = v;
}
fs >> dummy;
}
std::string StringUtilities::GetAsString(std::iostream& i_stream)
{
int length;
char* p_buffer;
// get length of file:
i_stream.seekg (0, std::iostream::end);
length = static_cast<int>(i_stream.tellg());
i_stream.seekg (0, std::iostream::beg);
// allocate memory:
p_buffer = new char [length];
//write file
int pos = 0;
while(i_stream.good())
{
p_buffer[pos] = i_stream.get();
++pos;
}
std::string out(p_buffer, pos);
delete[] p_buffer;
return out;
}
