103 lines
2.8 KiB
C++
103 lines
2.8 KiB
C++
// -*- c++ -*-
|
|
|
|
// This file is part of the Collective Variables module (Colvars).
|
|
// The original version of Colvars and its updates are located at:
|
|
// https://github.com/Colvars/colvars
|
|
// Please update all Colvars source files before making any changes.
|
|
// If you wish to distribute your changes, please submit them to the
|
|
// Colvars repository at GitHub.
|
|
|
|
|
|
#include "colvarmodule.h"
|
|
#include "colvartypes.h"
|
|
#include "colvarvalue.h"
|
|
#include "colvars_memstream.h"
|
|
|
|
|
|
bool cvm::memory_stream::expand_output_buffer(size_t add_bytes)
|
|
{
|
|
auto &buffer = external_output_buffer_ ? *external_output_buffer_ : internal_buffer_;
|
|
if ((buffer.size() + add_bytes) <= max_length_) {
|
|
buffer.resize((buffer.size() + add_bytes));
|
|
} else {
|
|
setstate(std::ios::badbit);
|
|
}
|
|
return bool(*this);
|
|
}
|
|
|
|
|
|
template <> void cvm::memory_stream::write_object(std::string const &t)
|
|
{
|
|
size_t const string_length = t.size();
|
|
size_t const new_data_size = sizeof(size_t) + sizeof(char) * string_length;
|
|
if (expand_output_buffer(new_data_size)) {
|
|
std::memcpy(output_location(), &string_length, sizeof(size_t));
|
|
incr_write_pos(sizeof(size_t));
|
|
std::memcpy(output_location(), t.c_str(), t.size() * sizeof(char));
|
|
incr_write_pos(t.size() * sizeof(char));
|
|
}
|
|
}
|
|
|
|
template <> cvm::memory_stream &operator<<(cvm::memory_stream &os, std::string const &t)
|
|
{
|
|
os.write_object<std::string>(t);
|
|
return os;
|
|
}
|
|
|
|
template <> void cvm::memory_stream::write_object(colvarvalue const &t)
|
|
{
|
|
*this << t;
|
|
}
|
|
|
|
template <> void cvm::memory_stream::write_object(cvm::vector1d<cvm::real> const &t)
|
|
{
|
|
return write_vector<cvm::real>(t.data_array());
|
|
}
|
|
|
|
template <>
|
|
cvm::memory_stream &operator<<(cvm::memory_stream &os, cvm::vector1d<cvm::real> const &t)
|
|
{
|
|
os.write_vector<cvm::real>(t.data_array());
|
|
return os;
|
|
}
|
|
|
|
|
|
template <> void cvm::memory_stream::read_object(std::string &t)
|
|
{
|
|
begin_reading();
|
|
size_t string_length = 0;
|
|
if (has_remaining(sizeof(size_t))) {
|
|
std::memcpy(&string_length, input_location(), sizeof(size_t));
|
|
incr_read_pos(sizeof(size_t));
|
|
if (has_remaining(string_length * sizeof(char))) {
|
|
t.assign(reinterpret_cast<char const *>(input_location()), string_length);
|
|
incr_read_pos(string_length * sizeof(char));
|
|
done_reading();
|
|
} else {
|
|
setstate(std::ios::failbit);
|
|
}
|
|
}
|
|
}
|
|
|
|
template <> cvm::memory_stream &operator>>(cvm::memory_stream &is, std::string &t)
|
|
{
|
|
is.read_object<std::string>(t);
|
|
return is;
|
|
}
|
|
|
|
template <> void cvm::memory_stream::read_object(colvarvalue &t)
|
|
{
|
|
*this >> t;
|
|
}
|
|
|
|
template <> void cvm::memory_stream::read_object(cvm::vector1d<cvm::real> &t)
|
|
{
|
|
return read_vector<cvm::real>(t.data_array());
|
|
}
|
|
|
|
template <> cvm::memory_stream &operator>>(cvm::memory_stream &is, cvm::vector1d<cvm::real> &t)
|
|
{
|
|
is.read_vector<cvm::real>(t.data_array());
|
|
return is;
|
|
}
|