Consolidate protocol messages in one namespace

Rather than defining the various messages as nested classes in SignalProxy,
RemoteConnection and in the future even more locations, have them defined
within a single namespace (and file, protocol.h).
This should make it much easier to see at a glance what kind of messages
Quassel sends, and thus help with protocol implementations.

diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index a21f807..3043bb1 100644 (file)
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -74,6 +74,7 @@ set(HEADERS ${MOC_HDRS}
     networkevent.h
     logger.h
     message.h
+    protocol.h
     types.h
     util.h)
 

diff --git a/src/common/internalconnection.cpp b/src/common/internalconnection.cpp
index a194a03..fb8b959 100644 (file)
--- a/src/common/internalconnection.cpp
+++ b/src/common/internalconnection.cpp
@@ -23,6 +23,8 @@
 
 #include "internalconnection.h"
 
+using namespace Protocol;
+
 template<class T>
 class PeerMessageEvent : public QEvent
 {
@@ -131,25 +133,25 @@ void InternalConnection::peerDisconnected()
 }
 
 
-void InternalConnection::dispatch(const SignalProxy::SyncMessage &msg)
+void InternalConnection::dispatch(const SyncMessage &msg)
 {
     dispatch(SyncMessageEvent, msg);
 }
 
 
-void InternalConnection::dispatch(const SignalProxy::RpcCall &msg)
+void InternalConnection::dispatch(const RpcCall &msg)
 {
     dispatch(RpcCallEvent, msg);
 }
 
 
-void InternalConnection::dispatch(const SignalProxy::InitRequest &msg)
+void InternalConnection::dispatch(const InitRequest &msg)
 {
     dispatch(InitRequestEvent, msg);
 }
 
 
-void InternalConnection::dispatch(const SignalProxy::InitData &msg)
+void InternalConnection::dispatch(const InitData &msg)
 {
     dispatch(InitDataEvent, msg);
 }
@@ -186,22 +188,22 @@ void InternalConnection::customEvent(QEvent *event)
 {
     switch ((int)event->type()) {
         case SyncMessageEvent: {
-            PeerMessageEvent<SignalProxy::SyncMessage> *e = static_cast<PeerMessageEvent<SignalProxy::SyncMessage> *>(event);
+            PeerMessageEvent<SyncMessage> *e = static_cast<PeerMessageEvent<SyncMessage> *>(event);
             handle(e->message);
             break;
         }
         case RpcCallEvent: {
-            PeerMessageEvent<SignalProxy::RpcCall> *e = static_cast<PeerMessageEvent<SignalProxy::RpcCall> *>(event);
+            PeerMessageEvent<RpcCall> *e = static_cast<PeerMessageEvent<RpcCall> *>(event);
             handle(e->message);
             break;
         }
         case InitRequestEvent: {
-            PeerMessageEvent<SignalProxy::InitRequest> *e = static_cast<PeerMessageEvent<SignalProxy::InitRequest> *>(event);
+            PeerMessageEvent<InitRequest> *e = static_cast<PeerMessageEvent<InitRequest> *>(event);
             handle(e->message);
             break;
         }
         case InitDataEvent: {
-            PeerMessageEvent<SignalProxy::InitData> *e = static_cast<PeerMessageEvent<SignalProxy::InitData> *>(event);
+            PeerMessageEvent<InitData> *e = static_cast<PeerMessageEvent<InitData> *>(event);
             handle(e->message);
             break;
         }

diff --git a/src/common/internalconnection.h b/src/common/internalconnection.h
index 31f3756..32b8fc2 100644 (file)
--- a/src/common/internalconnection.h
+++ b/src/common/internalconnection.h
@@ -23,6 +23,7 @@
 
 #include <QTcpSocket>
 
+#include "protocol.h"
 #include "signalproxy.h"
 
 class QEvent;
@@ -56,10 +57,10 @@ public:
 
     int lag() const;
 
-    void dispatch(const SignalProxy::SyncMessage &msg);
-    void dispatch(const SignalProxy::RpcCall &msg);
-    void dispatch(const SignalProxy::InitRequest &msg);
-    void dispatch(const SignalProxy::InitData &msg);
+    void dispatch(const Protocol::SyncMessage &msg);
+    void dispatch(const Protocol::RpcCall &msg);
+    void dispatch(const Protocol::InitRequest &msg);
+    void dispatch(const Protocol::InitData &msg);
 
 public slots:
     void close(const QString &reason = QString());

diff --git a/src/common/protocol.h b/src/common/protocol.h
new file mode 100644 (file)
index 0000000..af98b8b
--- /dev/null
+++ b/src/common/protocol.h
@@ -0,0 +1,128 @@
+/***************************************************************************
+ *   Copyright (C) 2005-2013 by the Quassel Project                        *
+ *   devel@quassel-irc.org                                                 *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) version 3.                                           *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
+ ***************************************************************************/
+
+#ifndef PROTOCOL_H_
+#define PROTOCOL_H_
+
+#include <QByteArray>
+#include <QDateTime>
+#include <QVariantList>
+
+namespace Protocol {
+
+/*** handled by SignalProxy ***/
+
+class SyncMessage
+{
+public:
+    inline SyncMessage(const QByteArray &className, const QString &objectName, const QByteArray &slotName, const QVariantList &params)
+    : _className(className), _objectName(objectName), _slotName(slotName), _params(params) {}
+
+    inline QByteArray className() const { return _className; }
+    inline QString objectName() const { return _objectName; }
+    inline QByteArray slotName() const { return _slotName; }
+
+    inline QVariantList params() const { return _params; }
+
+private:
+    QByteArray _className;
+    QString _objectName;
+    QByteArray _slotName;
+    QVariantList _params;
+};
+
+
+class RpcCall
+{
+public:
+    inline RpcCall(const QByteArray &slotName, const QVariantList &params)
+    : _slotName(slotName), _params(params) {}
+
+    inline QByteArray slotName() const { return _slotName; }
+    inline QVariantList params() const { return _params; }
+
+private:
+    QByteArray _slotName;
+    QVariantList _params;
+};
+
+
+class InitRequest
+{
+public:
+    inline InitRequest(const QByteArray &className, const QString &objectName)
+    : _className(className), _objectName(objectName) {}
+
+    inline QByteArray className() const { return _className; }
+    inline QString objectName() const { return _objectName; }
+
+private:
+    QByteArray _className;
+    QString _objectName;
+};
+
+
+class InitData
+{
+public:
+    inline InitData(const QByteArray &className, const QString &objectName, const QVariantMap &initData)
+    : _className(className), _objectName(objectName), _initData(initData) {}
+
+    inline QByteArray className() const { return _className; }
+    inline QString objectName() const { return _objectName; }
+
+    inline QVariantMap initData() const { return _initData; }
+
+private:
+    QByteArray _className;
+    QString _objectName;
+    QVariantMap _initData;
+};
+
+
+/*** handled by RemoteConnection ***/
+
+class HeartBeat
+{
+public:
+    inline HeartBeat(const QDateTime &timestamp) : _timestamp(timestamp) {}
+
+    inline QDateTime timestamp() const { return _timestamp; }
+
+private:
+    QDateTime _timestamp;
+};
+
+
+class HeartBeatReply
+{
+public:
+    inline HeartBeatReply(const QDateTime &timestamp) : _timestamp(timestamp) {}
+
+    inline QDateTime timestamp() const { return _timestamp; }
+
+private:
+    QDateTime _timestamp;
+};
+
+
+};
+
+#endif

diff --git a/src/common/protocols/legacy/legacyconnection.cpp b/src/common/protocols/legacy/legacyconnection.cpp
index ec6b26a..5b99574 100644 (file)
--- a/src/common/protocols/legacy/legacyconnection.cpp
+++ b/src/common/protocols/legacy/legacyconnection.cpp
@@ -20,6 +20,8 @@
 
 #include "legacyconnection.h"
 
+using namespace Protocol;
+
 LegacyConnection::LegacyConnection(QTcpSocket *socket, QObject *parent)
     : RemoteConnection(socket, parent),
     _blockSize(0),
@@ -164,7 +166,7 @@ void LegacyConnection::handlePackedFunc(const QVariant &packedFunc)
             QByteArray className = params.takeFirst().toByteArray();
             QString objectName = params.takeFirst().toString();
             QByteArray slotName = params.takeFirst().toByteArray();
-            handle(SignalProxy::SyncMessage(className, objectName, slotName, params));
+            handle(Protocol::SyncMessage(className, objectName, slotName, params));
             break;
         }
         case RpcCall: {
@@ -173,7 +175,7 @@ void LegacyConnection::handlePackedFunc(const QVariant &packedFunc)
                 return;
             }
             QByteArray slotName = params.takeFirst().toByteArray();
-            handle(SignalProxy::RpcCall(slotName, params));
+            handle(Protocol::RpcCall(slotName, params));
             break;
         }
         case InitRequest: {
@@ -183,7 +185,7 @@ void LegacyConnection::handlePackedFunc(const QVariant &packedFunc)
             }
             QByteArray className = params[0].toByteArray();
             QString objectName = params[1].toString();
-            handle(SignalProxy::InitRequest(className, objectName));
+            handle(Protocol::InitRequest(className, objectName));
             break;
         }
         case InitData: {
@@ -194,7 +196,7 @@ void LegacyConnection::handlePackedFunc(const QVariant &packedFunc)
             QByteArray className = params[0].toByteArray();
             QString objectName = params[1].toString();
             QVariantMap initData = params[2].toMap();
-            handle(SignalProxy::InitData(className, objectName, initData));
+            handle(Protocol::InitData(className, objectName, initData));
             break;
         }
         case HeartBeat: {
@@ -206,7 +208,7 @@ void LegacyConnection::handlePackedFunc(const QVariant &packedFunc)
             // so we assume it's sent today, which works in exactly the same cases as it did in the old implementation
             QDateTime dateTime = QDateTime::currentDateTimeUtc();
             dateTime.setTime(params[0].toTime());
-            handle(RemoteConnection::HeartBeat(dateTime));
+            handle(Protocol::HeartBeat(dateTime));
             break;
         }
         case HeartBeatReply: {
@@ -218,7 +220,7 @@ void LegacyConnection::handlePackedFunc(const QVariant &packedFunc)
             // so we assume it's sent today, which works in exactly the same cases as it did in the old implementation
             QDateTime dateTime = QDateTime::currentDateTimeUtc();
             dateTime.setTime(params[0].toTime());
-            handle(RemoteConnection::HeartBeatReply(dateTime));
+            handle(Protocol::HeartBeatReply(dateTime));
             break;
         }
 
@@ -226,37 +228,37 @@ void LegacyConnection::handlePackedFunc(const QVariant &packedFunc)
 }
 
 
-void LegacyConnection::dispatch(const SignalProxy::SyncMessage &msg)
+void LegacyConnection::dispatch(const Protocol::SyncMessage &msg)
 {
     dispatchPackedFunc(QVariantList() << (qint16)Sync << msg.className() << msg.objectName() << msg.slotName() << msg.params());
 }
 
 
-void LegacyConnection::dispatch(const SignalProxy::RpcCall &msg)
+void LegacyConnection::dispatch(const Protocol::RpcCall &msg)
 {
     dispatchPackedFunc(QVariantList() << (qint16)RpcCall << msg.slotName() << msg.params());
 }
 
 
-void LegacyConnection::dispatch(const SignalProxy::InitRequest &msg)
+void LegacyConnection::dispatch(const Protocol::InitRequest &msg)
 {
     dispatchPackedFunc(QVariantList() << (qint16)InitRequest << msg.className() << msg.objectName());
 }
 
 
-void LegacyConnection::dispatch(const SignalProxy::InitData &msg)
+void LegacyConnection::dispatch(const Protocol::InitData &msg)
 {
     dispatchPackedFunc(QVariantList() << (qint16)InitData << msg.className() << msg.objectName() << msg.initData());
 }
 
 
-void LegacyConnection::dispatch(const RemoteConnection::HeartBeat &msg)
+void LegacyConnection::dispatch(const Protocol::HeartBeat &msg)
 {
     dispatchPackedFunc(QVariantList() << (qint16)HeartBeat << msg.timestamp().time());
 }
 
 
-void LegacyConnection::dispatch(const RemoteConnection::HeartBeatReply &msg)
+void LegacyConnection::dispatch(const Protocol::HeartBeatReply &msg)
 {
     dispatchPackedFunc(QVariantList() << (qint16)HeartBeatReply << msg.timestamp().time());
 }

diff --git a/src/common/protocols/legacy/legacyconnection.h b/src/common/protocols/legacy/legacyconnection.h
index c05ce51..e3a4635 100644 (file)
--- a/src/common/protocols/legacy/legacyconnection.h
+++ b/src/common/protocols/legacy/legacyconnection.h
@@ -46,13 +46,13 @@ public:
 
     void setSignalProxy(SignalProxy *proxy);
 
-    void dispatch(const SignalProxy::SyncMessage &msg);
-    void dispatch(const SignalProxy::RpcCall &msg);
-    void dispatch(const SignalProxy::InitRequest &msg);
-    void dispatch(const SignalProxy::InitData &msg);
+    void dispatch(const Protocol::SyncMessage &msg);
+    void dispatch(const Protocol::RpcCall &msg);
+    void dispatch(const Protocol::InitRequest &msg);
+    void dispatch(const Protocol::InitData &msg);
 
-    void dispatch(const RemoteConnection::HeartBeat &msg);
-    void dispatch(const RemoteConnection::HeartBeatReply &msg);
+    void dispatch(const Protocol::HeartBeat &msg);
+    void dispatch(const Protocol::HeartBeatReply &msg);
 
     // FIXME: this is only used for the auth phase and should be replaced by something more generic
     void writeSocketData(const QVariant &item);

diff --git a/src/common/remoteconnection.cpp b/src/common/remoteconnection.cpp
index 4b73768..1ce29d4 100644 (file)
--- a/src/common/remoteconnection.cpp
+++ b/src/common/remoteconnection.cpp
@@ -27,6 +27,8 @@
 
 #include "remoteconnection.h"
 
+using namespace Protocol;
+
 RemoteConnection::RemoteConnection(QTcpSocket *socket, QObject *parent)
     : SignalProxy::AbstractPeer(parent),
     _socket(socket),

diff --git a/src/common/remoteconnection.h b/src/common/remoteconnection.h
index 198627a..948d610 100644 (file)
--- a/src/common/remoteconnection.h
+++ b/src/common/remoteconnection.h
@@ -24,6 +24,7 @@
 #include <QDateTime>
 #include <QTcpSocket>
 
+#include "protocol.h"
 #include "signalproxy.h"
 
 class QTimer;
@@ -67,19 +68,16 @@ signals:
     void transferProgress(int current, int max);
 
 protected:
-    class HeartBeat;
-    class HeartBeatReply;
-
     SignalProxy *signalProxy() const;
 
     template<class T>
     void handle(const T &protoMessage);
 
-    void handle(const HeartBeat &heartBeat);
-    void handle(const HeartBeatReply &heartBeatReply);
-
-    virtual void dispatch(const HeartBeat &msg) = 0;
-    virtual void dispatch(const HeartBeatReply &msg) = 0;
+    // These protocol messages get handled internally and won't reach SignalProxy
+    void handle(const Protocol::HeartBeat &heartBeat);
+    void handle(const Protocol::HeartBeatReply &heartBeatReply);
+    virtual void dispatch(const Protocol::HeartBeat &msg) = 0;
+    virtual void dispatch(const Protocol::HeartBeatReply &msg) = 0;
 
 private slots:
     void sendHeartBeat();
@@ -94,32 +92,6 @@ private:
 };
 
 
-// These protocol messages get handled internally and won't reach SignalProxy
-
-class RemoteConnection::HeartBeat
-{
-public:
-    inline HeartBeat(const QDateTime &timestamp) : _timestamp(timestamp) {}
-
-    inline QDateTime timestamp() const { return _timestamp; }
-
-private:
-    QDateTime _timestamp;
-};
-
-
-class RemoteConnection::HeartBeatReply
-{
-public:
-    inline HeartBeatReply(const QDateTime &timestamp) : _timestamp(timestamp) {}
-
-    inline QDateTime timestamp() const { return _timestamp; }
-
-private:
-    QDateTime _timestamp;
-};
-
-
 // Template methods we need in the header
 template<class T> inline
 void RemoteConnection::handle(const T &protoMessage)

diff --git a/src/common/signalproxy.cpp b/src/common/signalproxy.cpp
index fca6d0d..4cadfa8 100644 (file)
--- a/src/common/signalproxy.cpp
+++ b/src/common/signalproxy.cpp
@@ -40,9 +40,12 @@
 #include <QEvent>
 #include <QCoreApplication>
 
+#include "protocol.h"
 #include "syncableobject.h"
 #include "util.h"
 
+using namespace Protocol;
+
 class RemovePeerEvent : public QEvent
 {
 public:
@@ -153,7 +156,7 @@ int SignalProxy::SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **
                 params << QVariant(argTypes[i], _a[i+1]);
             }
 
-            proxy()->dispatch(SignalProxy::RpcCall(signal.signature, params));
+            proxy()->dispatch(RpcCall(signal.signature, params));
         }
         _id -= _slots.count();
     }
@@ -508,7 +511,7 @@ void SignalProxy::dispatch(const T &protoMessage)
 }
 
 
-void SignalProxy::handle(SignalProxy::AbstractPeer *peer, const SignalProxy::SyncMessage &syncMessage)
+void SignalProxy::handle(SignalProxy::AbstractPeer *peer, const SyncMessage &syncMessage)
 {
     if (!_syncSlave.contains(syncMessage.className()) || !_syncSlave[syncMessage.className()].contains(syncMessage.objectName())) {
         qWarning() << QString("no registered receiver for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(syncMessage.className(), syncMessage.slotName(), syncMessage.objectName())
@@ -550,7 +553,7 @@ void SignalProxy::handle(SignalProxy::AbstractPeer *peer, const SignalProxy::Syn
 }
 
 
-void SignalProxy::handle(SignalProxy::AbstractPeer *peer, const SignalProxy::InitRequest &initRequest)
+void SignalProxy::handle(SignalProxy::AbstractPeer *peer, const InitRequest &initRequest)
 {
    if (!_syncSlave.contains(initRequest.className())) {
         qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:"
@@ -569,7 +572,7 @@ void SignalProxy::handle(SignalProxy::AbstractPeer *peer, const SignalProxy::Ini
 }
 
 
-void SignalProxy::handle(SignalProxy::AbstractPeer *peer, const SignalProxy::InitData &initData)
+void SignalProxy::handle(SignalProxy::AbstractPeer *peer, const InitData &initData)
 {
     Q_UNUSED(peer)
 
@@ -590,7 +593,7 @@ void SignalProxy::handle(SignalProxy::AbstractPeer *peer, const SignalProxy::Ini
 }
 
 
-void SignalProxy::handle(SignalProxy::AbstractPeer *peer, const SignalProxy::RpcCall &rpcCall)
+void SignalProxy::handle(SignalProxy::AbstractPeer *peer, const RpcCall &rpcCall)
 {
     Q_UNUSED(peer)
 

diff --git a/src/common/signalproxy.h b/src/common/signalproxy.h
index 645157e..dddb785 100644 (file)
--- a/src/common/signalproxy.h
+++ b/src/common/signalproxy.h
@@ -33,9 +33,12 @@
 #include <QByteArray>
 #include <QTimer>
 
+#include "protocol.h"
+
 class SyncableObject;
 struct QMetaObject;
 
+
 class SignalProxy : public QObject
 {
     Q_OBJECT
@@ -45,11 +48,6 @@ class SignalProxy : public QObject
 public:
     class AbstractPeer;
 
-    class SyncMessage;
-    class RpcCall;
-    class InitRequest;
-    class InitData;
-
     enum ProxyMode {
         Server,
         Client
@@ -131,10 +129,10 @@ private:
     template<class T>
     void dispatch(const T &protoMessage);
 
-    void handle(AbstractPeer *peer, const SyncMessage &syncMessage);
-    void handle(AbstractPeer *peer, const RpcCall &rpcCall);
-    void handle(AbstractPeer *peer, const InitRequest &initRequest);
-    void handle(AbstractPeer *peer, const InitData &initData);
+    void handle(AbstractPeer *peer, const Protocol::SyncMessage &syncMessage);
+    void handle(AbstractPeer *peer, const Protocol::RpcCall &rpcCall);
+    void handle(AbstractPeer *peer, const Protocol::InitRequest &initRequest);
+    void handle(AbstractPeer *peer, const Protocol::InitData &initData);
 
     bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params, QVariant &returnValue);
     bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params = QVariantList());
@@ -182,7 +180,7 @@ class SignalProxy::ExtendedMetaObject
 {
     class MethodDescriptor
     {
-public:
+    public:
         MethodDescriptor(const QMetaMethod &method);
         MethodDescriptor() : _returnType(-1), _minArgCount(-1), _receiverMode(SignalProxy::Client) {}
 
@@ -192,7 +190,7 @@ public:
         inline int minArgCount() const { return _minArgCount; }
         inline SignalProxy::ProxyMode receiverMode() const { return _receiverMode; }
 
-private:
+    private:
         QByteArray _methodName;
         QList<int> _argTypes;
         int _returnType;
@@ -257,10 +255,10 @@ public:
     virtual int lag() const = 0;
 
 public slots:
-    virtual void dispatch(const SyncMessage &msg) = 0;
-    virtual void dispatch(const RpcCall &msg) = 0;
-    virtual void dispatch(const InitRequest &msg) = 0;
-    virtual void dispatch(const InitData &msg) = 0;
+    virtual void dispatch(const Protocol::SyncMessage &msg) = 0;
+    virtual void dispatch(const Protocol::RpcCall &msg) = 0;
+    virtual void dispatch(const Protocol::InitRequest &msg) = 0;
+    virtual void dispatch(const Protocol::InitData &msg) = 0;
 
     virtual void close(const QString &reason = QString()) = 0;
 
@@ -271,75 +269,4 @@ signals:
     void lagUpdated(int msecs);
 };
 
-
-// ==================================================
-//  Protocol Messages
-// ==================================================
-class SignalProxy::SyncMessage
-{
-public:
-    inline SyncMessage(const QByteArray &className, const QString &objectName, const QByteArray &slotName, const QVariantList &params)
-    : _className(className), _objectName(objectName), _slotName(slotName), _params(params) {}
-
-    inline QByteArray className() const { return _className; }
-    inline QString objectName() const { return _objectName; }
-    inline QByteArray slotName() const { return _slotName; }
-
-    inline QVariantList params() const { return _params; }
-
-private:
-    QByteArray _className;
-    QString _objectName;
-    QByteArray _slotName;
-    QVariantList _params;
-};
-
-
-class SignalProxy::RpcCall
-{
-public:
-    inline RpcCall(const QByteArray &slotName, const QVariantList &params)
-    : _slotName(slotName), _params(params) {}
-
-    inline QByteArray slotName() const { return _slotName; }
-    inline QVariantList params() const { return _params; }
-
-private:
-    QByteArray _slotName;
-    QVariantList _params;
-};
-
-
-class SignalProxy::InitRequest
-{
-public:
-    inline InitRequest(const QByteArray &className, const QString &objectName)
-    : _className(className), _objectName(objectName) {}
-
-    inline QByteArray className() const { return _className; }
-    inline QString objectName() const { return _objectName; }
-
-private:
-    QByteArray _className;
-    QString _objectName;
-};
-
-
-class SignalProxy::InitData
-{
-public:
-    inline InitData(const QByteArray &className, const QString &objectName, const QVariantMap &initData)
-    : _className(className), _objectName(objectName), _initData(initData) {}
-
-    inline QByteArray className() const { return _className; }
-    inline QString objectName() const { return _objectName; }
-
-    inline QVariantMap initData() const { return _initData; }
-
-private:
-    QByteArray _className;
-    QString _objectName;
-    QVariantMap _initData;
-};
-
 #endif