I the last few posts I wrote about serializing data in an extensible and effective binary format using QDataStream. So far it was focused on value types and simple structures that can be easily converted to QVariant and QVariantMap. In the last post I mentioned that creating objects dynamically based on class name requires implementing some kind of an object factory. Now let's analyse what is needed to serialize an entire hierarchy of abstract objects that refer to one another. Note that this is a very complex topic and there is no single, universal solution, so I won't provide the full code. Instead I will discuss what is necessary to craft such solution depending on the exact requirements.
Let's assume that we're serializing a project which consists of shapes of various types - circles, squares, etc. There are also some complex shapes, like groups or layers, which consist of other shapes. The first difficulty is that shape is an abstract type, so we need to store the actual class name along with the object data in order to be able to re-create the object upon deserialization. This was more or less covered in the last post.
Another difficulty is that objects refer to one another by pointers, forming a graph of relations, in which one object may be accessed from many other objects. We need to ensure that the object is only serialized and deserialized once, and all other references must be correctly maintained. There even can be cyclic dependencies; for example a parent object can have a pointer to a child, and the child can have a pointer to the parent.
For sake of simplicity I will assume that each serializable class inherits QObject; that's not really necessary, but having a single common base class makes things easier. The class should also be registered in the object factory discussed before. Finally, it should implement the following interface, which provides methods for serializing and deserializing the object:
class Serializable
{
public:
virtual void serialize( QVariantMap& data, SerializationContext* context ) const = 0;
virtual void deserialize( const QVariantMap& data, SerializationContext* context ) = 0;
};
The data is stored in a QVariantMap for reasons that were also discussed in one of the previous articles, so that the file format is extensible and backward compatible. The context object is responsible for performing the serialization and deserialization. We will get to it in a moment.
Note that the Serializable class could be an abstract class which inherits QObject. All concrete classes could then inherit it and implement the serialization methods. However, in this case it wouldn't be possible to add serialization capabilities to existing subclasses of QObject, for example widgets. Using a separate interface gives us more flexibility. Although multiple inheritance in C++ is a very complex subject, it's very common in most object oriented languages for a class to inherit behavior and implementation from a single base class, and implement a number of additional interfaces.
An incomplete example of a serializable class containing a pointer might look like this:
class Shape : public QObject, public Serializable
{
Q_OBJECT
public:
void serialize( QVariantMap& data, SerializationContext* context ) const
{
data[ "Name" ] << m_name;
data[ "Other" ] = context->serialize( m_other );
}
void deserialize( const QVariantMap& data, SerializationContext* context )
{
data[ "Name" ] >> m_name;
m_other = context->deserialize<Shape>( data[ "Other" ] );
}
private:
QString m_name;
Shape* m_other;
};
The serialize method of the SerializationContext first checks if the given object was already serialized. If not, it appends it to the internal list of objects and calls the serialize method on this object to store its data in a QVariantMap. Then it returns a handle to the object, which is a QVariant. Internally it contains an integer value identifying the object in the given context.
The deserialize method checks if the object with the given handle was already deserialized. If not, it creates a new instance of the appropriate class using the object factory and calls the deserialize method. Note that the object is not necessarily a Shape; it might actually be a subclass of it like Square or Circle.
Note that the context doesn't actually read or write any data from/to a stream. Instead, it stores a list of records, which include the pointer to the object, its class name and serialized data. So the handle is simply the position of the object in the list. The entire context can be written into the stream once all objects are serialized. Conversely, when deserializing, the context is first read from the stream, and then individual objects are deserialized.
We may serialize as many objects as we need using the same context, but we need to store the handles in the stream along with the context data, because we will need them when deserializing. Alternatively, we may serialize an entire hierarchy of objects by serializing the "root" object and ensuring that all children are serialized recursively:
QDataStream stream;
SerializationContext contex;
context.serialize( root );
stream << context;
In that case we don't need to store the handle, because we know that the handle of the first serialized object is always integer zero (not to be confused with invalid variant, which represents a NULL pointer):
QDataStream stream;
SerializationContext contex;
stream >> context;
Shape* root = context.deserialize<Shape>( QVariant::fromValue<int>( 0 ) );
So what does the SerializationContext class look like? This is an incomplete definition:
class SerializationContext
{
public:
template<typename T>
QVariant serialize( T* ptr );
template<typename T>
T* deserialize( const QVariant& handle );
friend QDataStream& operator <<( QDataStream& stream, const SerializationContext& context );
friend QDataStream& operator >>( QDataStream& stream, SerializationContext& context );
private:
struct Record
{
QObject* m_object;
QByteArray m_type;
QVariantMap m_data;
};
private:
QList<Record> m_records;
QHash<QObject*, int> m_map;
};
The serialize and deserialize methods are discussed below. The shift operators make it possible to read and write the entire context from/to the stream. The list of records stores information about objects, including their type and data. The map is optional; it simply makes lookup slightly faster for a large number of objects.
You can notice that both the serialize and deserialize methods are templates. Why not simply cast everything to void*? Also why the record and the map stores a QObject*, instead of a void*?
This is because of how multiple inheritance works in C++. Let's assume that you have a pointer to a Shape object. When you cast it to QObject*, and to Serializable*, you will receive two different pointers, that may be different from the original one. That's because in memory, the Shape object consists of a QObject, followed by Serializable, so an offset must be added or subtracted to convert one pointer to another.
You can safely cast pointers up and down the hierarchy of classes using the static_cast operator, and the compiler will ensure behid the scenes that the pointers are adjusted accordingly. But when you cast something to void*, you lose all the information, so casting it back to some other pointer may produce wrong results!
Let's take a look at the serialize method:
template<typename T>
QVariant SerializationContext::serialize( T* ptr )
{
if ( ptr == NULL )
return QVariant();
QObject* object = static_cast<QObject*>( ptr );
QHash<QObject*, int>::iterator it = m_map.find( object );
if ( it != m_map.end() )
return QVariant( it.value() );
int index = m_records.count();
Record record;
record.m_object = object;
record.m_type = object->metaObject()->className();
m_records.append( record );
m_map.insert( object, index );
Serializable* serializable = static_cast<Serializable*>( ptr );
QVariantMap data;
serializable->serialize( data, this );
m_records[ index ].m_data = data;
return QVariant( index );
}
Notice how the pointer is explicitly casted to QObject*, and later it's casted to Serializable*? It's not possible to cast a QObject* to Serializable*, because they are unrelated classes, and forcing the cast by using reinterpret_cast or casting to void* would certainly crash the application. This is even more apparent in the deserialize method:
template<typename T>
T* SerializationContext::deserialize( const QVariant& handle )
{
if ( !handle.isValid() )
return NULL;
int index = handle.toInt();
Record& record = m_records[ index ];
if ( record.m_object != NULL )
return static_cast<T*>( record.m_object );
QObject* object = ObjectFactory::createObject( record.m_type );
record.m_object = object;
m_map.insert( object, index );
T* ptr = static_cast<T*>( object );
Serializable* serializable = static_cast<Serializable*>( ptr );
serializable->deserialize( record.m_data, this );
return ptr;
}
Here the QObject* is first casted "up" to the actual type, T*, and then "down" to Serializable*. It doesn't matter if T is a Shape and the object is actually a Square or Circle, because all subclasses of Shape have the same layout of base classes.
Other than that, the code is quite straightforward, though there is another gotcha when dealing with circular references between objects. The record must be appended to the list before the serialize method is called on the object. This way, if the same pointer is encountered while serializing the object, it is not serialized again, which would lead to infinite recursion.
