The pack/unpack function implements ``serialisation'', or the conversion of an object into a binary form that can be saved to a file or transmitted over the network to a process running in a different memory address space. The obvious strategy of simply sending sizeof(object) bytes starting at address &object doesn't work, as the object may contain members that are implemented using pointers -- eg dynamic strings or arrays. The obvious strategy will simply copy the contents of the pointer, which will not be valid in the destination's address space.
Using the recursive approach, simple data types can be serialised in the obvious way, or even transformed using into a machine independent form such as XDR. Data types such as arrays or strings can be handled in a type dependent fashion by supplying appropriate specialised definitions.
In this case, the pack_t type implements a buffer into/from which the data is packed/unpacked. It has public members char *data; int size which point to the buffer and its size, that can then be used for further functionality such as the checkpoint/restart functionality of Eco Lab.
There are 4 methods of using the pack function on an object --
template <class T> pack_t& pack_t::operator<<(T&)
template <class T> ::pack(pack_t&, string, T&)
template <class T> ::pack(pack_t&, string, is_array, T*, int)
void pack_t::packraw(char *,int)
classdesc::stringargument is not used, just pass
""to it. The third method above is a utility routine for packing arrays of objects,
is_arrayis a dummy type, so just pass the object returned by the default constructor
is_array(), then the final two arguments are the array pointer and size respectively. One could easily explicitly loop over the array elements using the first two methods. The last method is used to pack arbitrary byte data into the buffer. It differs from
::pack(pack_t&, string, is_array, char*, int)in that the latter packs a series of characters, which are usually 32 bit quantities. It is thus both more efficient than the latter, as well as providing a means to unpack data stored in packed char format.
xdr_pack is derived from
Instead of packing to native data representation, it uses XDR data
representation, which is machine independent. The
XDR_PACK macro symbol must be defined to
enable this functionality, otherwise
xdr_pack is synonymous
pack_t, allowing the code to be employed on machines that
do not provide XDR functionality.
unpack_t is typedef'd to pack_t, and unpack_base.h is a link to pack_base.h.
In order to use the streaming operators
need to include the file
pack_stream.h, after all the
pack() definitions. This is automatically done by