Re: Serialization

From:

Brian Wood <woodbrian77@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Thu, 4 Nov 2010 19:13:45 -0700 (PDT)

Message-ID:

<f98492e8-8b3d-40da-9b5c-99d683846479@r14g2000yqa.googlegroups.com>

On Nov 4, 12:53 pm, Leigh Johnston <le...@i42.co.uk> wrote:

On 04/11/2010 17:28, Andrea Crotti wrote:

I'm doing a very complicated structure for serialize/deserialize
objects, in short I have this abstract class

--8<---------------cut here---------------start------------->8---
#ifndef STREAMABLE_H
#define STREAMABLE_H

#include "Stream.hpp"

template<typename T>
class Serializable
{
public:
     Serializable() {}
     virtual Stream toStream() = 0;
     // used to parse the given stream and create the object
     virtual T parseStream(const Stream&) = 0;
};

#endif /* STREAMABLE_H */
--8<---------------cut here---------------end--------------->8---

and all the objects that want to bea able to create a stream and parse
it have to overload it.

Now 2 problems:
- the definition of the classes is something like
   class PadNodeID : public Serializable<PadNodeID>

   so the template parameter is always the class itself, maybe is it
   possible to avoid it?

- the "parseStream" function doesn't really make sense to be called from
   one object, since it's supposed to create one.
   But making it static and virtual doens't work, so how should I declare
   it in such a way that I can do.

--8<---------------cut here---------------start------------->8---
   Type t = Type::parseStream(st);
--8<---------------cut here---------------end--------------->8---

Thanks again,
Andrea

Why use templates?

class Serializable
{
public:
      Serializable() {}
      virtual Stream toStream() = 0;
      // used to parse the given stream and create the object
      virtual void parseStream(Stream&) = 0;

};

class PadNodeID : public Serializable
{
      PadNodeID(Stream& aStream) { parseStream(aStream); }
      virtual Stream toStream() { ... }
      virtual void parseStream(const Stream&) { ... }

};

int main()
{
      ...
      Stream st;
      PadNodeID node(st);

}

What is gained by the Serializable base class?
I'd write it like this:

class PadNodeID
{
protected:
  void SendMemberData(SendCompressedBuffer* buf) const;

public:
  template <typename R>
  explicit PadNodeID(ReceiveCompressedBuffer<R>* buf);

  void CalculateMarshallingSize(Counter& cntr) const;

  void
  Send(SendCompressedBuffer* buf, bool = false) const
  {
    SendMemberData(buf);
  }
};

Brian Wood
Ebenezer Enterprises
http://webEbenezer.net