Our serialize() method will return one of these status codes:

* Success
* InvalidFormat
* UnsupportedVersion
* ReadError
* WriteError

Serializing a simple class
A "simple class" is defined as an object that has no parent class and is not a collection class. To serialize a simple class, do the following:

1. Serialize the object's signature and version
2. Serialize the object's members (if any)

In the following example, the class Point contains 2 int members that represent the coordinates of a point. The object's signature and version are defined as static members (m_strSignature and m_nVersion), since they apply to all instances of Point.



Serializing a derived class

For the purpose of this discussion, a derived class is one that is derived from a simple class and is not a collection class. To serialize a derived class, do the following:

1. Serialize the object's signature and version
2. Serialize the object's base class << additional step
3. Serialize the object's members (if any)

In the following example, the class ColoredPoint is derived from Point and contains an additional int member called m_nColor, which specifies the point's color. Like all serializable classes, ColoredPoint also defines a static signature and version.



Serializing a homogenous collection class

Homogenous collection classes are used to store dynamically sized collections of the same type of object. To serialize a homogenous collection class, do the following:

1. Serialize the object's signature and version
2. Serialize the object's base class (if any)
3. Serialize the number of items in the collection << additional step
4. Serialize each object in the collection << additional step
5. Serialize the object's other members (if any)

In the following example, the class ColoredPointList is a collection of ColoredPoint objects. To keep things simple, ColoredPointList uses a CPtrArray to store objects. Like all serializable classes, ColoredPointList also defines a static signature and version. Here's what ColoredPointList looks like:


And here's how we serialize it:


i
Serializing a heterogenous collection class

Heterogenous collection classes are used to store dynamically sized collections of potentially different types of objects. To serialize a heterogenous collection class, do the following:

1. Serialize the object's signature and version
2. Serialize the object's base class (if any)
3. Serialize the number of items in the collection
4. For each object in the collection
(a) serialize that object's signature << additional step
(b) then serialize that object
5. Serialize the object's other members (if any)

You'll notice the only additional step in serializing heterogenous collections is 4(a), where we serialize each object's signature before serializing the object itself. This comes in handy when reading back our data. When we serialized a homogeous collection, we dealt with objects of the same type (ColoredPoints in the previous example). To read in a ColoredPoint, we constructed it on the heap and then called its serialize() method.




When we're dealing with heterogenous collections, we need to know the type of object we're reading back in, before actually serializing it. That's where the object's signature comes in. Since we saved the signature on the way out, we can construct an object of the appropriate type on the way in.


In the above code fragment, ColoredPoint, Line and Rectangle are all (eventually) derived from a common base class ISerializable, which is nothing more than an abstract base class containing only pure virtual methods (in other words, an "interface"). ISerializable defines the methods getSignature(), getVersion() and serialize().



OK, let's serialize our heterogenous collection. In the following example, the class ShapeList is a collection of varying numbers of ColoredPoint, Line and Rectangle objects, all of which derive from ISerializable. You can look upon these classes as "implementing the ISerializable interface".


Class Factory
You can replace the ugly if statement in the code fragment by using a "class factory" to serve up a new instance of a class based on its signature. Here are some articles you might want to look at:

* Generic Class Factory by Robert A. T. Káldy
* The Factory Method (Creational) Design Pattern by Gopalan Suresh Raj
* Abstract Factory Pattern by Mark Grand

Although the articles vary in complexity, the basic idea behind them is the same. A class factory is little more than a class that offers an appropriately named static method (eg: create()) that serves up an object of a specific type. You could hide the nasty if statement in the factory's create() method, cleaning up the code a bit.
Collapse

...
// Construct object of appropriate type
ISerializable* pObject = MyClassFactory::create (strSignature);
ASSERT (pObject != NULL);
...

Conclusion
Although this primer refers to MFC objects like CString and CPtrArray, serialization is not specific to MFC. It's a common operation performed by any software that needs to save and restore information to and from persistent storage.

 Article by:   Ravi Bhavnani