simplify XML RPC code

3 files changed, 68 insertions, 109 deletions

diff --git a/source/QXmppRpcIq.cpp b/source/QXmppRpcIq.cpp
index 15f428f1..41c34856 100644
--- a/source/QXmppRpcIq.cpp
+++ b/source/QXmppRpcIq.cpp
@@ -66,8 +66,9 @@ void QXmppRpcResponseIq::parseElementFromChild(const QDomElement &element)
     QDomElement queryElement = element.firstChildElement("query");
     QDomElement methodElement = queryElement.firstChildElement("methodResponse");
 
-    XMLRPC::ResponseMessage message( methodElement );
-    m_payload = message.values().first();
+    XMLRPC::ResponseMessage message;
+    if (message.parse(methodElement))
+        m_payload = message.values().first();
 }
 
 void QXmppRpcResponseIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
@@ -124,11 +125,13 @@ void QXmppRpcInvokeIq::parseElementFromChild(const QDomElement &element)
     QDomElement queryElement = element.firstChildElement("query");
     QDomElement methodElement = queryElement.firstChildElement("methodCall");
 
-    XMLRPC::RequestMessage message( methodElement );
-
-    m_interface = message.method().split('.').value(0);
-    m_method = message.method().split('.').value(1);
-    m_payload = message.args();
+    XMLRPC::RequestMessage message;
+    if (message.parse(methodElement))
+    {
+        m_interface = message.method().split('.').value(0);
+        m_method = message.method().split('.').value(1);
+        m_payload = message.args();
+    }
 }
 
 void QXmppRpcInvokeIq::toXmlElementFromChild(QXmlStreamWriter *writer) const
diff --git a/source/xmlrpc.cpp b/source/xmlrpc.cpp
index 8ce4efeb..82830c46 100644
--- a/source/xmlrpc.cpp
+++ b/source/xmlrpc.cpp
@@ -1,11 +1,12 @@
 #include "xmlrpc.h"
+#include <QDebug>
 #include <QMap>
 #include <QVariant>
 #include <QDateTime>
 #include <QStringList>
 #include <QTextStream>
 
-void XMLRPC::MessageBase::marshall( QXmlStreamWriter *writer, const QVariant &value ) const
+static void marshall( QXmlStreamWriter *writer, const QVariant &value)
 {
     writer->writeStartElement("value");
     switch( value.type() )
@@ -75,22 +76,11 @@ void XMLRPC::MessageBase::marshall( QXmlStreamWriter *writer, const QVariant &va
     writer->writeEndElement();
 }
 
-bool XMLRPC::MessageBase::isValid() const
-{
-    return m_valid;
-}
-
-QString XMLRPC::MessageBase::error() const
-{
-    return m_message;
-}
-
-QVariant XMLRPC::MessageBase::demarshall( const QDomElement &elem ) const
+static QVariant demarshall(const QDomElement &elem, QStringList &errors)
 {
     if ( elem.tagName().toLower() != "value" )
     {
-        m_valid = false;
-        m_message = "bad param value";
+        errors << "Bad param value";
         return QVariant();
     }
 
@@ -103,22 +93,25 @@ QVariant XMLRPC::MessageBase::demarshall( const QDomElement &elem ) const
     const QString typeName = typeData.tagName().toLower();
 
     if ( typeName == "string" )
-                return QVariant( typeData.text() );
+    {
+        return QVariant( typeData.text() );
+    }
     else if (typeName == "int" || typeName == "i4" )
     {
         bool ok = false;
         QVariant val( typeData.text().toInt( &ok ) );
-        if( ok )
+        if (ok)
             return val;
-        m_message = "I was looking for an integer but data was courupt";
+        errors << "I was looking for an integer but data was courupt";
+        return QVariant();
     }
     else if( typeName == "double" )
     {
         bool ok = false;
         QVariant val( typeData.text().toDouble( &ok ) );
-        if( ok )
+        if (ok)
             return val;
-        m_message = "I was looking for an double but data was courupt";
+        errors <<  "I was looking for an double but data was corrupt";
     }
     else if( typeName == "boolean" )
         return QVariant( ( typeData.text().toLower() == "true" || typeData.text() == "1")?true:false );
@@ -128,9 +121,9 @@ QVariant XMLRPC::MessageBase::demarshall( const QDomElement &elem ) const
     {
         QList<QVariant> arr;
         QDomNode valueNode = typeData.firstChild().firstChild();
-        while( !valueNode.isNull() && m_valid )
+        while (!valueNode.isNull() && errors.isEmpty())
         {
-            arr.append( demarshall( valueNode.toElement() ) );
+            arr.append(demarshall(valueNode.toElement(), errors));
             valueNode = valueNode.nextSibling();
         }
         return QVariant( arr );
@@ -139,11 +132,11 @@ QVariant XMLRPC::MessageBase::demarshall( const QDomElement &elem ) const
     {
         QMap<QString,QVariant> stct;
         QDomNode valueNode = typeData.firstChild();
-        while( !valueNode.isNull() && m_valid )
+        while(!valueNode.isNull() && errors.isEmpty())
         {
             const QDomElement memberNode = valueNode.toElement().elementsByTagName("name").item(0).toElement();
             const QDomElement dataNode = valueNode.toElement().elementsByTagName("value").item(0).toElement();
-            stct[ memberNode.text() ] = demarshall( dataNode );
+            stct[ memberNode.text() ] = demarshall(dataNode, errors);
             valueNode = valueNode.nextSibling();
         }
         return QVariant(stct);
@@ -157,38 +150,25 @@ QVariant XMLRPC::MessageBase::demarshall( const QDomElement &elem ) const
         QDataStream ds(&dest, QIODevice::ReadOnly);
         ds.setVersion(QDataStream::Qt_4_0);
         ds >> returnVariant;
-        if( returnVariant.isValid() )
+        if (returnVariant.isValid())
             return returnVariant;
         else
             return QVariant( dest );
     }
-    setError(QString( "Cannot handle type %1").arg(typeName));
-    return QVariant();
-}
-
-void XMLRPC::MessageBase::setError( const QString & message ) const
-{
-    m_valid = false;
-    m_message = message;
-}
 
-XMLRPC::MessageBase::MessageBase( ) : m_valid(true)
-{
+    errors << QString( "Cannot handle type %1").arg(typeName);
+    return QVariant();
 }
 
-XMLRPC::MessageBase::~MessageBase( )
+XMLRPC::RequestMessage::RequestMessage(const QByteArray &method, const QList<QVariant> &args)
+    : m_method(method), m_args(args)
 {
 }
 
-XMLRPC::RequestMessage::RequestMessage( const QByteArray &method, const QList<QVariant> &args )
-: MessageBase()
+bool XMLRPC::RequestMessage::parse(const QDomElement &element)
 {
-    m_method = method;
-    m_args = args;
-}
+    QStringList errors;
 
-XMLRPC::RequestMessage::RequestMessage( const QDomElement  &element )
-{
     m_args.clear();
     m_method.clear();
 
@@ -199,20 +179,24 @@ XMLRPC::RequestMessage::RequestMessage( const QDomElement  &element )
     }
     else
     {
-        setError("Missing methodName property.");
-        return;
+        errors << "Missing methodName property";
+        return false;
     }
 
     const QDomElement methodParams = element.firstChildElement("params");
     if( !methodParams.isNull() )
     {
         QDomNode param = methodParams.firstChild();
-        while( !param.isNull() && isValid() )
+        while (!param.isNull())
         {
-            m_args.append( demarshall( param.firstChild().toElement() ) );
+            QVariant arg = demarshall(param.firstChild().toElement(), errors);
+            if (!errors.isEmpty())
+                return false;
+            m_args << arg;
             param = param.nextSibling();
         }
     }
+    return true;
 }
 
 QList< QVariant > XMLRPC::RequestMessage::args() const
@@ -244,34 +228,41 @@ void XMLRPC::RequestMessage::writeXml( QXmlStreamWriter *writer ) const
 }
 
 XMLRPC::ResponseMessage::ResponseMessage( const QList< QVariant > & theValue  )
-: MessageBase(), m_values(theValue)
+    : m_values(theValue)
 {
 }
 
-XMLRPC::ResponseMessage::ResponseMessage( const QDomElement &element )
+bool XMLRPC::ResponseMessage::parse(const QDomElement &element)
 {
+    QStringList errors;
     const QDomElement contents = element.firstChild().toElement();
     if( contents.tagName().toLower() == "params")
     {
         QDomNode param = contents.firstChild();
-        while( !param.isNull() && isValid() )
+        while (!param.isNull())
         {
-            m_values.append( demarshall( param.firstChild().toElement() ) );
+            const QVariant value = demarshall(param.firstChild().toElement(), errors);
+            if (!errors.isEmpty())
+                return false;
+            m_values << value;
             param = param.nextSibling();
         }
+        return true;
     }
     else if( contents.tagName().toLower() == "fault")
     {
         const QDomElement errElement = contents.firstChild().toElement();
-        const QVariant error = demarshall( errElement );
+        const QVariant error = demarshall(errElement, errors);
 
-        setError( QString("XMLRPC Fault %1: %2")
+        qWarning() << QString("XMLRPC Fault %1: %2")
                         .arg(error.toMap()["faultCode"].toString() )
-                        .arg(error.toMap()["faultString"].toString() ) );
+                        .arg(error.toMap()["faultString"].toString() );
+        return true;
     }
     else
     {
-        setError("Bad XML response");
+        qWarning("Bad XML response");
+        return false;
     }
 }
 
diff --git a/source/xmlrpc.h b/source/xmlrpc.h
index 3b846f23..67f1a028 100644
--- a/source/xmlrpc.h
+++ b/source/xmlrpc.h
@@ -41,55 +41,22 @@
 namespace XMLRPC
 {
 /**
- * Base utility methods for working with XMLRPC messages.
-@author Ian Reinhart Geiser <geiseri@kde.org>
-*/
-class MessageBase
-{
-public:
-    MessageBase();
-    virtual ~MessageBase();
-
-    /**
-    * Returns a human readable error that was recived from the server.
-    */
-    QString error() const;
-
-    /**
-     * Sets the human readable error message.
-     */
-    virtual void setError( const QString &message ) const;
-
-    /**
-    * Returns if the current message is valid.
-    */
-    bool isValid() const;
-
-protected:
-    virtual void marshall( QXmlStreamWriter *writer, const QVariant &val ) const;
-    virtual QVariant demarshall( const QDomElement &elem ) const;
-
-private:
-    mutable QString m_message;
-    mutable bool m_valid;
-};
-
-/**
 * Creates an XMLRPC message that will call a method with a series of
 * QVariants that will be converted to XMLRPC types.
 @author Ian Reinhart Geiser <geiseri@kde.org>
 */
-class RequestMessage : public MessageBase
+class RequestMessage
 {
 public:
-    RequestMessage( const QDomElement &element );
-
     /**
     * Creates a method packet that will call method with a list of args.
     */
-    RequestMessage( const QByteArray &method, const QList<QVariant> &args );
+    RequestMessage(const QByteArray &method = QByteArray(), const QList<QVariant> &args = QList<QVariant>());
 
-    virtual ~RequestMessage() {;}
+    /**
+    * Parse an xml packet.
+    */
+    bool parse(const QDomElement &element);
 
     /**
     * Return the xml representation of the packet.
@@ -108,20 +75,18 @@ private:
 * Decodes an XMLRPC message from a server into a set of QVariants.
 @author Ian Reinhart Geiser <geiseri@kde.org>
 */
-class ResponseMessage : public MessageBase
+class ResponseMessage
 {
 public:
     /**
-    * Create a new recive packet with an xml packet
-    */
-    ResponseMessage( const QDomElement &element );
-
-    /**
      * Create a new response message with data.
      */
-    ResponseMessage( const QList< QVariant >& theValue );
+    ResponseMessage(const QList<QVariant> &theValue = QList<QVariant>());
 
-    virtual ~ResponseMessage() {;}
+    /**
+    * Parse an xml packet.
+    */
+    bool parse(const QDomElement &element);
 
     /**
     * Return the xml representation of the packet.