Changes between Version 6 and Version 7 of Documentation/Serialization

Timestamp:

Feb 5, 2010, 9:03:35 AM (15 years ago)

Author:

Christoph Mayer

Comment:

--

Documentation/Serialization

@@ -77 +77 @@
  * const int support - cI( uintmax_t )
  * const char* support - cT( const char* )
- * string and char* support, T( char* | std::string )
+ * string and char* support - T( char* | std::string )
+ * pointer serialization - VO( pointer* )
 
 It is always best to use types that have a specified length, e.g. {{{uint8_t}}}, {{{uint16_t}}}, ... etc. If you are serializing through a inherited type where the serialization is provided in the base class, use the {{{&}}} operator before. Such a case is e.g. the {{{NodeID}}} class:
@@ -111 +112 @@
 You will find the following code in the !PingPong sample that shows how to convert the incoming message to your format and invoke the deserializer:
 {{{
+#!cpp
 void PingPong::onMessage(const DataMessage& msg, const NodeID& remote, const LinkID& lnk) {
     PingPongMessage* pingmsg = msg.getMessage()->convert<PingPongMessage> ();
@@ -117 +119 @@
 }}}
 
-
-
-
-
-
-
-
-
+Sometimes, it is necessary to transfer a complete vector of objects through a message. The following code is taken from the {{{NodeListingReply.h}}} file of the OneHop overlay in Ariba. 
+
+{{{
+#!cpp
+using_serialization;
+
+class NodeListingReply : public Message {
+        VSERIALIZEABLE;
+public:
+        NodeListingReply();
+        virtual ~NodeListingReply();
+
+        typedef pair<NodeID,EndpointDescriptor*> NodeEndpoint;
+        typedef vector<NodeEndpoint> NodeEndpointList;
+
+        void add(const NodeID& node, EndpointDescriptor* endp);
+        const NodeEndpointList& getList();
+
+private:
+        NodeEndpointList descriptors;
+};
+
+sznBeginDefault( ariba::overlay::NodeListingReply, X ) {
+        uint16_t len = descriptors.size();
+        X && len;
+        if (X.isDeserializer()) descriptors.resize(len);
+        for (int i=0; i<len; i++)
+                X && &descriptors[i].first && VO(descriptors[i].second);
+} sznEnd();
+}}}
+
+In this message we want to transfer a vector that holds combinations of NodeID and EndpointDescriptor. Also note, that we store pointers to EndpointDescriptors:
+{{{
+#!cpp
+typedef pair<NodeID,EndpointDescriptor*> NodeEndpoint;
+typedef vector<NodeEndpoint> NodeEndpointList;
+}}}
+
+The serializer first gets the size of the vector and stores it:
+{{{
+#!cpp
+uint16_t len = descriptors.size();
+X && len;
+}}}
+In case of serialization the actual length {{{len}}} will be stored in the serialization, in case of deserialization the len that has been set to the size of the vector will be overwritten with the value stored in the message. Next, in case we are performing a deserialization, we resize the vector according to the size stored in the message:
+{{{
+#!cpp
+if (X.isDeserializer()) descriptors.resize(len);
+}}}
+Then, we iterate through the vector size and de/serializa the two items in the vector:
+{{{
+#!cpp
+for (int i=0; i<len; i++)
+   X && &descriptors[i].first && VO(descriptors[i].second);
+}}}
+The following points are of importance: First, note the & before {{{descriptors[i].first}}}. This is required as the actual serialization code of the {{{NodeID}}} class remains in a base class. Second, we use the {{{VO}}} macro to deserialize through a pointer. In case of deserialization, this will directly create a new {{{EndpointDescriptor}}} object through the new operator.