Commit 7290e438 authored by Jakob Otto's avatar Jakob Otto

Rework binary_deserializer to work with other data_types.

parent e48d80e7
......@@ -22,6 +22,7 @@
#include <cstdint>
#include <vector>
#include "caf/byte.hpp"
#include "caf/deserializer.hpp"
namespace caf {
......@@ -33,17 +34,36 @@ public:
using super = deserializer;
using buffer = std::vector<char>;
// -- constructors, destructors, and assignment operators --------------------
binary_deserializer(actor_system& sys, const char* buf, size_t buf_size);
template <class ValueType>
binary_deserializer(actor_system& sys, const ValueType* buf, size_t buf_size)
: super(sys),
current_(reinterpret_cast<const byte*>(buf)),
end_(reinterpret_cast<const byte*>(buf) + buf_size) {
static_assert(sizeof(ValueType) == 1, "sizeof(Value type) > 1");
}
binary_deserializer(execution_unit* ctx, const char* buf, size_t buf_size);
template <class ValueType>
binary_deserializer(execution_unit* ctx, const ValueType* buf,
size_t buf_size)
: super(ctx),
current_(reinterpret_cast<const byte*>(buf)),
end_(reinterpret_cast<const byte*>(buf) + buf_size) {
static_assert(sizeof(ValueType) == 1, "sizeof(Value type) > 1");
}
binary_deserializer(actor_system& sys, const buffer& buf);
template <class BufferType>
binary_deserializer(actor_system& sys, const BufferType& buf)
: binary_deserializer(sys, buf.data(), buf.size()) {
// nop
}
binary_deserializer(execution_unit* ctx, const buffer& buf);
template <class BufferType>
binary_deserializer(execution_unit* ctx, const BufferType& buf)
: binary_deserializer(ctx, buf.data(), buf.size()) {
// nop
}
// -- overridden member functions --------------------------------------------
......@@ -60,12 +80,12 @@ public:
// -- properties -------------------------------------------------------------
/// Returns the current read position.
const char* current() const {
const byte* current() const {
return current_;
}
/// Returns the past-the-end iterator.
const char* end() const {
const byte* end() const {
return end_;
}
......@@ -78,7 +98,6 @@ public:
current_ += num_bytes;
}
protected:
error apply_impl(int8_t&) override;
......@@ -113,8 +132,8 @@ private:
return current_ + read_size <= end_;
}
const char* current_;
const char* end_;
const byte* current_;
const byte* end_;
};
} // namespace caf
......@@ -26,7 +26,6 @@
#include "caf/detail/network_order.hpp"
#include "caf/sec.hpp"
namespace caf {
namespace {
......@@ -49,29 +48,7 @@ error apply_float(binary_deserializer& bs, T& x) {
return none;
}
} // namespace <anonmyous>
binary_deserializer::binary_deserializer(actor_system& sys, const char* buf,
size_t buf_size)
: super(sys), current_(buf), end_(buf + buf_size) {
// nop
}
binary_deserializer::binary_deserializer(execution_unit* ctx, const char* buf,
size_t buf_size)
: super(ctx), current_(buf), end_(buf + buf_size) {
// nop
}
binary_deserializer::binary_deserializer(actor_system& sys, const buffer& buf)
: binary_deserializer(sys, buf.data(), buf.size()) {
// nop
}
binary_deserializer::binary_deserializer(execution_unit* ctx, const buffer& buf)
: binary_deserializer(ctx, buf.data(), buf.size()) {
// nop
}
} // namespace
error binary_deserializer::begin_object(uint16_t& nr, std::string& name) {
if (auto err = apply(nr))
......@@ -172,7 +149,8 @@ error binary_deserializer::apply_impl(std::string& x) {
return err;
if (!range_check(str_size))
return sec::end_of_stream;
x.assign(current_, current_ + str_size);
x.assign(reinterpret_cast<char*>(const_cast<byte*>(current_)),
reinterpret_cast<char*>(const_cast<byte*>(current_)) + str_size);
current_ += str_size;
return end_sequence();
}
......
......@@ -88,67 +88,79 @@ typename Inspector::result_type inspect(Inspector& f, test_data& x) {
struct serialization_fixture {
caf::actor_system_config cfg;
caf::actor_system sys{cfg};
test_data source;
test_data sink{0,
0,
0,
0,
caf::duration(caf::time_unit::seconds, 0),
caf::timestamp{caf::timestamp::duration{0}},
test_enum::a,
""};
test_data data_to_serialize;
test_data deserialized_data{0,
0,
0,
0,
caf::duration(caf::time_unit::seconds, 0),
caf::timestamp{caf::timestamp::duration{0}},
test_enum::a,
""};
};
} // namespace
CAF_TEST_FIXTURE_SCOPE(serializer_impl_tests, serialization_fixture)
CAF_TEST(serialize to std::vector<char>) {
CAF_TEST(serialize and deserialize with std::vector<char>) {
using container_type = std::vector<char>;
std::vector<char> binary_serializer_buffer;
container_type serializer_impl_buffer;
binary_serializer sink1{sys, binary_serializer_buffer};
serializer_impl<container_type> sink2{sys, serializer_impl_buffer};
if (auto err = sink1(source))
if (auto err = sink1(data_to_serialize))
CAF_FAIL("serialization failed: " << sys.render(err));
if (auto err = sink2(source))
if (auto err = sink2(data_to_serialize))
CAF_FAIL("serialization failed: " << sys.render(err));
CAF_CHECK_EQUAL(memcmp(binary_serializer_buffer.data(),
serializer_impl_buffer.data(),
binary_serializer_buffer.size()),
0);
binary_deserializer source(sys, serializer_impl_buffer);
if (auto err = source(deserialized_data))
CAF_FAIL("deserialization failed: " << sys.render(err));
CAF_CHECK_EQUAL(data_to_serialize, deserialized_data);
}
CAF_TEST(serialize to std::vector<byte>) {
CAF_TEST(serialize and deserialize with std::vector<byte>) {
using container_type = std::vector<byte>;
std::vector<char> binary_serializer_buffer;
container_type serializer_impl_buffer;
binary_serializer sink1{sys, binary_serializer_buffer};
serializer_impl<container_type> sink2{sys, serializer_impl_buffer};
if (auto err = sink1(source))
if (auto err = sink1(data_to_serialize))
CAF_FAIL("serialization failed: " << sys.render(err));
if (auto err = sink2(source))
if (auto err = sink2(data_to_serialize))
CAF_FAIL("serialization failed: " << sys.render(err));
CAF_CHECK_EQUAL(memcmp(binary_serializer_buffer.data(),
serializer_impl_buffer.data(),
binary_serializer_buffer.size()),
0);
binary_deserializer source(sys, serializer_impl_buffer);
if (auto err = source(deserialized_data))
CAF_FAIL("deserialization failed: " << sys.render(err));
CAF_CHECK_EQUAL(data_to_serialize, deserialized_data);
}
CAF_TEST(serialize to std::vector<uint8_t>) {
CAF_TEST(serialize and deserialize with std::vector<uint8_t>) {
using container_type = std::vector<uint8_t>;
std::vector<char> binary_serializer_buffer;
container_type serializer_impl_buffer;
binary_serializer sink1{sys, binary_serializer_buffer};
serializer_impl<container_type> sink2{sys, serializer_impl_buffer};
if (auto err = sink1(source))
if (auto err = sink1(data_to_serialize))
CAF_FAIL("serialization failed: " << sys.render(err));
if (auto err = sink2(source))
if (auto err = sink2(data_to_serialize))
CAF_FAIL("serialization failed: " << sys.render(err));
CAF_CHECK_EQUAL(memcmp(binary_serializer_buffer.data(),
serializer_impl_buffer.data(),
binary_serializer_buffer.size()),
0);
binary_deserializer source(sys, serializer_impl_buffer);
if (auto err = source(deserialized_data))
CAF_FAIL("deserialization failed: " << sys.render(err));
CAF_CHECK_EQUAL(data_to_serialize, deserialized_data);
}
CAF_TEST_FIXTURE_SCOPE_END();
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment