16.2.2. Importing Objects with an Abstract Factory

16.2.2. Importing Objects with an Abstract Factory
	16.2. Memento Pattern

[ fromfile: memento.xml id: importing ]

	Prerequisites
	Section 15.2

The importing routine is more sophisticated than the exporting routine, and it has some interesting features.
- It parses XML using the SAX parser.
- Depending on the input, it creates objects.
- The number and types of objects with their parent-child relationships must be reconstructed from the information in the file.
Example 16.12 shows the class definition for QObjectReader.

Example 16.12. src/libs/dataobjects/qobjectreader.h

[ . . . . ]
#include "dobjs_export.h"
#include <QString>
#include <QStack>
#include <QQueue>
#include <QXmlDefaultHandler>

class AbstractFactory;
class DOBJS_EXPORT  QObjectReader : public QXmlDefaultHandler {
  public:
    explicit QObjectReader (AbstractFactory* factory=0) : 
                         m_Factory(factory), m_Current(0) { }
    explicit QObjectReader (QString filename, AbstractFactory* factory=0);
    void parse(QString text);
    void parseFile(QString filename);
    QObject* getRoot();
    ~QObjectReader();

    // callback methods from QXmlDefaultHandler
    bool startElement( const QString& namespaceURI,
                       const QString& name,
                       const QString& qualifiedName,
                       const QXmlAttributes& attributes );
    bool endElement(  const QString& namespaceURI,
                      const QString& localName,
                      const QString& qualifiedName);
    bool endDocument();
  private:
    void addCurrentToQueue();
    AbstractFactory* m_Factory;
    QObject* m_Current;
    QQueue<QObject*> m_ObjectList;
    QStack<QObject*> m_ParentStack;
};
[ . . . . ]

Figure 16.3. QObjectReader and Its Related Classes

QObjectReader is derived from QXmlDefaultHandler,
QXmlDefaultHandler is a plugin for the QXmlSimpleReader.
AbstractFactory is a plugin for QObjectReader.
When you create a QObjectReader, you must supply it with a concrete instance of ObjectFactory or DataObjectFactory.

QObjectReader is now completely separate from the specific types of objects that it can create.
To use it with your own types, just derive a factory from AbstractFactory for them.

Keep the following XML output file in mind as you read the code in Example 16.14.
The goal of this example: produce a CustomerList object, with children, from XML.

Example 16.13. src/xml/propchildren/customerlist.xml

<object class="CustomerList" name="Customers" >

   <object class="Customer" name="Simon" >
     <property name="Name" type="QString" value="Simon" />
     <property name="Date" type="QDate" value="1963-11-22" />
     <property name="LuckyNumber" type="int" value="834" />
     <property name="State" type="QString" value="WA" />
     <property name="Zip" type="QString" value="12345" />
     <property name="FavoriteFood" type="QString" value="Donuts" />
     <property name="FavoriteDrink" type="QString" value="YooHoo"/>
   </object>


   <object class="Customer" name="Raja" >
     <property name="Name" type="QString" value="Raja" />
     <property name="Date" type="QDate" value="1969-06-15" />
     <property name="LuckyNumber" type="int" value="62" />
     <property name="State" type="QString" value="AZ" />
     <property name="Zip" type="QString" value="54321" />
     <property name="FavoriteFood" type="QString" value="Mushrooms" />
     <property name="FavoriteDrink" type="QString" value="Jolt" />
   </object>

</object>

Example 16.14. src/libs/dataobjects/qobjectreader.cpp

[ . . . . ]

bool QObjectReader::startElement( const QString&,
     const QString& elementName, const QString&,
     const QXmlAttributes& atts) {              
    if (elementName == "object") {
        if (m_Current != 0)                     
            m_ParentStack.push(m_Current);      
        QString classname = atts.value("class");
        QString instancename = atts.value("name");
        m_Current = m_Factory->newObject(classname);
        m_Current->setObjectName(instancename);
        if (!m_ParentStack.empty()) {                      
            m_Current->setParent(m_ParentStack.top());
        }
        return true;
    }
    if (elementName == "property") {
        QString fieldType = atts.value("type");
        QString fieldName = atts.value("name");
        QString fieldValue = atts.value("value");
        QVariant qv = QVariant(fieldValue);
        m_Current->setProperty(fieldName.toAscii(), qv);

    }
    return true;
}

	No need to name unused parameters.
	If already inside a <object>,
	push previous current onto stack.
	Top of parentstack, or previous current, should be my parent.

startElement() is called when the SAX parser encounters the initial tag of an XML element.
All other objects encountered between startElement() and the matching endElement() are children of m_Current.
The object is "finished" when we reach endElement(), as shown in Example 16.15.

Example 16.15. src/libs/dataobjects/qobjectreader.cpp

[ . . . . ]

bool QObjectReader::endElement( const QString& ,
                            const QString& elementName,
                            const QString& ) {
    if (elementName == "object") {
        if (!m_ParentStack.empty())
            m_Current = m_ParentStack.pop();
        else {
            addCurrentToQueue();
        }
    }
    return true;
}

QObjectReader uses an Abstract Factory to do the actual object creation.

The callback function, newObject(QString className), creates an object that can hold all the properties described in className.
ObjectFactory creates properly classed objects for the types for which it has a QMetaObject.
For other classes, it creates a regular QObject, but tries to "mimic" the type by setting its className dynamic property.


16.2.1. Exporting to XML		16.3. The Façade Pattern