GCS  0.2.3
gu_serializable.hpp
1 // Copyright (C) 2013 Codership Oy <info@codership.com>
9 #ifndef GU_SERIALIZABLE_HPP
10 #define GU_SERIALIZABLE_HPP
11 
12 #include "gu_types.hpp"
13 #include "gu_throw.hpp"
14 #include "gu_assert.hpp"
15 
16 #include <vector>
17 #include <stdexcept> // for std::length_error
18 
19 namespace gu
20 {
21 
23 {
24 public:
25 
27  ssize_t serial_size () const
28  {
29  return my_serial_size();
30  }
31 
41  ssize_t serialize_to (void* const buf, ssize_t const size) const
42  {
43  return my_serialize_to (buf, size);
44  }
45 
50  ssize_t serialize_to (std::vector<byte_t>& v) const
51  {
52  size_t const old_size (v.size());
53  size_t const new_size (serial_size() + old_size);
54 
55  try
56  {
57  v.resize (new_size, 0);
58  }
59  catch (std::length_error& l)
60  {
61  gu_throw_error(EMSGSIZE) << "length_error: " << l.what();
62  }
63  catch (...)
64  {
65  gu_throw_error(ENOMEM) << "could not resize to " << new_size
66  << " bytes";
67  }
68 
69  try
70  {
71  return serialize_to (&v[old_size], new_size - old_size);
72  }
73  catch (...)
74  {
75  v.resize (old_size);
76  throw;
77  }
78  }
79 
80 protected:
81 
82  ~Serializable() {}
83 
84 private:
85 
86  virtual ssize_t my_serial_size () const = 0;
87 
88  virtual ssize_t my_serialize_to (void* buf, ssize_t size) const = 0;
89 };
90 
91 static inline std::vector<byte_t>&
92 operator << (std::vector<byte_t>& out, const Serializable& s)
93 {
94  s.serialize_to (out);
95  return out;
96 }
97 
98 #if 0 // seems to be a pointless idea
99 class DeSerializable
100 {
101 public:
102 
103  /* serial size of an object stored at ptr, may be not implemented */
104  template <class DS>
105  static ssize_t serial_size (const byte_t* const buf, ssize_t const size)
106  {
107  assert (size > 0);
108  return DS::my_serial_size (buf, size);
109  }
110 
111  /* serial size of an object stored at ptr, may be not implemented */
112  ssize_t deserialize_from (const byte_t* const buf, ssize_t const size)
113  {
114  assert (size > 0);
115  return my_deserialize_from (buf, size);
116  }
117 
118  ssize_t deserialize_from (const std::vector<byte_t>& in,size_t const offset)
119  {
120  return deserialize_from (&in[offset], in.size() - offset);
121  }
122 
123 protected:
124 
125  ~DeSerializable() {}
126 
127 private:
128 
129  /* serial size of an object stored at ptr, may be not implemented */
130  virtual ssize_t my_deserialize_from (const byte_t* buf, ssize_t size) = 0;
131 };
132 #endif // 0
133 
134 } /* namespace gu */
135 
136 #endif /* GU_SERIALIZABLE_HPP */
ssize_t serialize_to(std::vector< byte_t > &v) const
Definition: gu_serializable.hpp:50
ssize_t serial_size() const
Definition: gu_serializable.hpp:27
ssize_t serialize_to(void *const buf, ssize_t const size) const
Definition: gu_serializable.hpp:41
Definition: gu_serializable.hpp:22