whitespace cleanup

2 files changed, 320 insertions, 317 deletions

diff --git a/source/xmlrpc.cpp b/source/xmlrpc.cpp
index 30af930d..5f650559 100644
--- a/source/xmlrpc.cpp
+++ b/source/xmlrpc.cpp
@@ -8,15 +8,15 @@
 XMLRPC::RequestMessage::RequestMessage( const QByteArray &method, const QList<QVariant> &args )
 : MessageBase()
 {
-     m_method = method;
-     m_args = args;
+    m_method = method;
+    m_args = args;
 }
 
 XMLRPC::RequestMessage::RequestMessage( const QByteArray &method, const QVariant &arg )
 : MessageBase()
 {
-     m_method = method;
-     m_args.append(arg);
+    m_method = method;
+    m_args.append(arg);
 }
 
 void XMLRPC::RequestMessage::writeXml( QXmlStreamWriter *writer ) const
@@ -40,88 +40,88 @@ void XMLRPC::RequestMessage::writeXml( QXmlStreamWriter *writer ) const
 
 QByteArray XMLRPC::RequestMessage::xml() const
 {
-     if( m_method.isEmpty() )
-          return QByteArray();
-
-        QByteArray returnXML;
-        QXmlStreamWriter writer( &returnXML );
-        writer.writeStartDocument();
-        writeXml(&writer );
-        writer.writeEndDocument();
-     return returnXML;
+    if( m_method.isEmpty() )
+        return QByteArray();
+
+    QByteArray returnXML;
+    QXmlStreamWriter writer( &returnXML );
+    writer.writeStartDocument();
+    writeXml(&writer );
+    writer.writeEndDocument();
+    return returnXML;
 }
 
 void XMLRPC::MessageBase::marshall( QXmlStreamWriter *writer, const QVariant &value ) const
 {
         writer->writeStartElement("value");
-     switch( value.type() )
-     {
-          case QVariant::Int:
-          case QVariant::UInt:
-          case QVariant::LongLong:
-          case QVariant::ULongLong:
+    switch( value.type() )
+    {
+        case QVariant::Int:
+        case QVariant::UInt:
+        case QVariant::LongLong:
+        case QVariant::ULongLong:
                         writer->writeTextElement("i4", value.toString());
-               break;
-          case QVariant::Double:
+            break;
+        case QVariant::Double:
                         writer->writeTextElement("double", value.toString());
-               break;
-          case QVariant::Bool:
+            break;
+        case QVariant::Bool:
                         writer->writeTextElement("boolean", (value.toBool()?"true":"false") );
-               break;
-          case QVariant::Date:
+            break;
+        case QVariant::Date:
                         writer->writeTextElement("dateTime.iso8601", value.toDate().toString( Qt::ISODate ) );
-               break;
-          case QVariant::DateTime:
+            break;
+        case QVariant::DateTime:
                         writer->writeTextElement("dateTime.iso8601", value.toDateTime().toString( Qt::ISODate ) );
                         break;
-          case QVariant::Time:
+        case QVariant::Time:
                         writer->writeTextElement("dateTime.iso8601", value.toTime().toString( Qt::ISODate ) );
                         break;
-          case QVariant::StringList:
-          case QVariant::List:
-          {
+        case QVariant::StringList:
+        case QVariant::List:
+        {
                         writer->writeStartElement("array");
                         writer->writeStartElement("data");
-               foreach( QVariant item, value.toList() )
+            foreach( QVariant item, value.toList() )
                                 marshall( writer, item );
                         writer->writeEndElement();
                         writer->writeEndElement();
-               break;
-          }
-          case QVariant::Map:
-          {
+            break;
+        }
+        case QVariant::Map:
+        {
                         writer->writeStartElement("struct");
-               QMap<QString, QVariant> map = value.toMap();
-               QMap<QString, QVariant>::ConstIterator index = map.begin();
-               while( index != map.end() )
-               {
+            QMap<QString, QVariant> map = value.toMap();
+            QMap<QString, QVariant>::ConstIterator index = map.begin();
+            while( index != map.end() )
+            {
                             writer->writeStartElement("member");
                             writer->writeTextElement("name", index.key());
                             marshall( writer, *index );
                             writer->writeEndElement();
                             ++index;
-               }
+            }
                         writer->writeEndElement();
-               break;
-          }
-          case QVariant::ByteArray:
-          {
+            break;
+        }
+        case QVariant::ByteArray:
+        {
                         writer->writeTextElement("base64", value.toByteArray().toBase64() );
-               break;
-          }
-          default:
-          {
-               if( value.canConvert(QVariant::String) )
-               {
+            break;
+        }
+        default:
+        {
+            if( value.canConvert(QVariant::String) )
+            {
                             writer->writeTextElement( "string", value.toString() );
-               }
-               else
-               {
-
-               }
-               break;
-          }
-     }
+            }
+            else
+            {
+
+            }
+            break;
+        }
+    }
         writer->writeEndElement();
     }
 XMLRPC::ResponseMessage::ResponseMessage( const QDomElement &element )
@@ -154,148 +154,148 @@ XMLRPC::ResponseMessage::ResponseMessage( const QDomElement &element )
 XMLRPC::ResponseMessage::ResponseMessage( const QByteArray &xml )
 : MessageBase()
 {
-     QDomDocument message;
-     QString xmlErrMsg;
-     int xmlErrLine;
-     int xmlErrCol;
-     if( message.setContent(xml, &xmlErrMsg, &xmlErrLine, &xmlErrCol) )
-     {
-          const QDomElement contents = message.documentElement().firstChild().toElement();
-          if( contents.tagName().toLower() == "params")
-          {
-               QDomNode param = contents.firstChild();
-               while( !param.isNull() && isValid() )
-               {
-                    m_values.append( demarshall( param.firstChild().toElement() ) );
-                    param = param.nextSibling();
-               }
-          }
-          else if( message.documentElement().firstChild().toElement().tagName().toLower() == "fault")
-          {
-               const QDomElement errElement = contents.firstChild().toElement();
-               const QVariant error = demarshall( errElement );
-
-               setError( QString("XMLRPC Fault %1: %2")
-                         .arg(error.toMap()["faultCode"].toString() )
-                         .arg(error.toMap()["faultString"].toString() ) );
-          }
-          else
-          {
-               setError("Bad XML response");
-          }
-     }
-     else
-     {
-     setError(QString( "XML Error: %1 at row %2 and col %3")
-              .arg(xmlErrMsg).arg(xmlErrLine).arg(xmlErrCol));
-     }
+    QDomDocument message;
+    QString xmlErrMsg;
+    int xmlErrLine;
+    int xmlErrCol;
+    if( message.setContent(xml, &xmlErrMsg, &xmlErrLine, &xmlErrCol) )
+    {
+        const QDomElement contents = message.documentElement().firstChild().toElement();
+        if( contents.tagName().toLower() == "params")
+        {
+            QDomNode param = contents.firstChild();
+            while( !param.isNull() && isValid() )
+            {
+                m_values.append( demarshall( param.firstChild().toElement() ) );
+                param = param.nextSibling();
+            }
+        }
+        else if( message.documentElement().firstChild().toElement().tagName().toLower() == "fault")
+        {
+            const QDomElement errElement = contents.firstChild().toElement();
+            const QVariant error = demarshall( errElement );
+
+            setError( QString("XMLRPC Fault %1: %2")
+                    .arg(error.toMap()["faultCode"].toString() )
+                    .arg(error.toMap()["faultString"].toString() ) );
+        }
+        else
+        {
+            setError("Bad XML response");
+        }
+    }
+    else
+    {
+    setError(QString( "XML Error: %1 at row %2 and col %3")
+             .arg(xmlErrMsg).arg(xmlErrLine).arg(xmlErrCol));
+    }
 }
 
 int XMLRPC::ResponseMessage::count() const
 {
-     return m_values.count();
+    return m_values.count();
 }
 
 QVariant XMLRPC::ResponseMessage::value( int index) const
 {
-     return m_values[index];
+    return m_values[index];
 }
 
 bool XMLRPC::MessageBase::isValid() const
 {
-     return m_valid;
+    return m_valid;
 }
 
 QString XMLRPC::MessageBase::error() const
 {
-     return m_message;
+    return m_message;
 }
 
 QVariant XMLRPC::MessageBase::demarshall( const QDomElement &elem ) const
 {
-     if ( elem.tagName().toLower() != "value" )
-     {
-          m_valid = false;
-          m_message = "bad param value";
-          return QVariant();
-     }
-
-     if ( !elem.firstChild().isElement() )
-     {
-          return QVariant( elem.text() );
-     }
-
-     const QDomElement typeData = elem.firstChild().toElement();
-     const QString typeName = typeData.tagName().toLower();
-
-     if ( typeName == "string" )
+    if ( elem.tagName().toLower() != "value" )
+    {
+        m_valid = false;
+        m_message = "bad param value";
+        return QVariant();
+    }
+
+    if ( !elem.firstChild().isElement() )
+    {
+        return QVariant( elem.text() );
+    }
+
+    const QDomElement typeData = elem.firstChild().toElement();
+    const QString typeName = typeData.tagName().toLower();
+
+    if ( typeName == "string" )
                 return QVariant( typeData.text() );
-     else if (typeName == "int" || typeName == "i4" )
-     {
-          bool ok = false;
-          QVariant val( typeData.text().toInt( &ok ) );
-          if( ok )
-               return val;
-          m_message = "I was looking for an integer but data was courupt";
-     }
-     else if( typeName == "double" )
-     {
-          bool ok = false;
-          QVariant val( typeData.text().toDouble( &ok ) );
-          if( ok )
-               return val;
-          m_message = "I was looking for an double but data was courupt";
-     }
-     else if( typeName == "boolean" )
-          return QVariant( ( typeData.text().toLower() == "true" || typeData.text() == "1")?true:false );
-     else if( typeName == "datetime" || typeName == "dateTime.iso8601" )
-          return QVariant( QDateTime::fromString( typeData.text(), Qt::ISODate ) );
-     else if( typeName == "array" )
-     {
-          QList<QVariant> arr;
-          QDomNode valueNode = typeData.firstChild().firstChild();
-          while( !valueNode.isNull() && m_valid )
-          {
-               arr.append( demarshall( valueNode.toElement() ) );
-               valueNode = valueNode.nextSibling();
-          }
-          return QVariant( arr );
-     }
-     else if( typeName == "struct" )
-     {
-          QMap<QString,QVariant> stct;
-          QDomNode valueNode = typeData.firstChild();
-          while( !valueNode.isNull() && m_valid )
-          {
-               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 );
-               valueNode = valueNode.nextSibling();
-          }
-          return QVariant(stct);
-     }
-     else if( typeName == "base64" )
-     {
-          QVariant returnVariant;
-          QByteArray dest;
-          QByteArray src = typeData.text().toLatin1();
-          dest = QByteArray::fromBase64( src );
-          QDataStream ds(&dest, QIODevice::ReadOnly);
-          ds.setVersion(QDataStream::Qt_4_0);
-          ds >> returnVariant;
-          if( returnVariant.isValid() )
-               return returnVariant;
-          else
-               return QVariant( dest );
-     }
-     setError(QString( "Cannot handle type %1").arg(typeName));
-     return QVariant();
+    else if (typeName == "int" || typeName == "i4" )
+    {
+        bool ok = false;
+        QVariant val( typeData.text().toInt( &ok ) );
+        if( ok )
+            return val;
+        m_message = "I was looking for an integer but data was courupt";
+    }
+    else if( typeName == "double" )
+    {
+        bool ok = false;
+        QVariant val( typeData.text().toDouble( &ok ) );
+        if( ok )
+            return val;
+        m_message = "I was looking for an double but data was courupt";
+    }
+    else if( typeName == "boolean" )
+        return QVariant( ( typeData.text().toLower() == "true" || typeData.text() == "1")?true:false );
+    else if( typeName == "datetime" || typeName == "dateTime.iso8601" )
+        return QVariant( QDateTime::fromString( typeData.text(), Qt::ISODate ) );
+    else if( typeName == "array" )
+    {
+        QList<QVariant> arr;
+        QDomNode valueNode = typeData.firstChild().firstChild();
+        while( !valueNode.isNull() && m_valid )
+        {
+            arr.append( demarshall( valueNode.toElement() ) );
+            valueNode = valueNode.nextSibling();
+        }
+        return QVariant( arr );
+    }
+    else if( typeName == "struct" )
+    {
+        QMap<QString,QVariant> stct;
+        QDomNode valueNode = typeData.firstChild();
+        while( !valueNode.isNull() && m_valid )
+        {
+            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 );
+            valueNode = valueNode.nextSibling();
+        }
+        return QVariant(stct);
+    }
+    else if( typeName == "base64" )
+    {
+        QVariant returnVariant;
+        QByteArray dest;
+        QByteArray src = typeData.text().toLatin1();
+        dest = QByteArray::fromBase64( src );
+        QDataStream ds(&dest, QIODevice::ReadOnly);
+        ds.setVersion(QDataStream::Qt_4_0);
+        ds >> returnVariant;
+        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;
+    m_valid = false;
+    m_message = message;
 }
 
 XMLRPC::MessageBase::MessageBase( ) : m_valid(true)
@@ -309,17 +309,17 @@ XMLRPC::MessageBase::~MessageBase( )
 
 QList< QVariant > XMLRPC::ResponseMessage::values() const
 {
-     return m_values;
+    return m_values;
 }
 
 QList< QVariant > XMLRPC::RequestMessage::args() const
 {
-     return m_args;
+    return m_args;
 }
 
 QByteArray XMLRPC::RequestMessage::method() const
 {
-     return m_method;
+    return m_method;
 }
 
 XMLRPC::RequestMessage::RequestMessage( const QDomElement  &element )
@@ -352,48 +352,48 @@ XMLRPC::RequestMessage::RequestMessage( const QDomElement  &element )
 
 XMLRPC::RequestMessage::RequestMessage( const QByteArray & xml )
 {
-     QDomDocument message;
-     QString xmlErrMsg;
-     int xmlErrLine;
-     int xmlErrCol;
-     m_args.clear();
-     m_method.clear();
-
-     if( message.setContent(xml, &xmlErrMsg, &xmlErrLine, &xmlErrCol) )
-     {
-          const QDomElement methodCall = message.firstChildElement("methodCall");
-          if( !methodCall.isNull() )
-          {
-               const QDomElement methodName = methodCall.firstChildElement("methodName");
-               if( !methodName.isNull() )
-               {
-                    m_method = methodName.text().toLatin1();
-               }
-               else
-               {
-                    setError("Missing methodName property.");
-                    return;
-               }
-
-               const QDomElement methodParams = methodCall.firstChildElement("params");
-               if( !methodParams.isNull() )
-               {
-                    QDomNode param = methodParams.firstChild();
-                    while( !param.isNull() && isValid() )
-                    {
-                         m_args.append( demarshall( param.firstChild().toElement() ) );
-                         param = param.nextSibling();
-                    }
-               }
-          }
-          else
-               setError("Not a valid methodCall message.");
-     }
-     else
-     {
-          setError(QString( "XML Error: %1 at row %2 and col %3")
-              .arg(xmlErrMsg).arg(xmlErrLine).arg(xmlErrCol));
-     }
+    QDomDocument message;
+    QString xmlErrMsg;
+    int xmlErrLine;
+    int xmlErrCol;
+    m_args.clear();
+    m_method.clear();
+
+    if( message.setContent(xml, &xmlErrMsg, &xmlErrLine, &xmlErrCol) )
+    {
+        const QDomElement methodCall = message.firstChildElement("methodCall");
+        if( !methodCall.isNull() )
+        {
+            const QDomElement methodName = methodCall.firstChildElement("methodName");
+            if( !methodName.isNull() )
+            {
+                m_method = methodName.text().toLatin1();
+            }
+            else
+            {
+                setError("Missing methodName property.");
+                return;
+            }
+
+            const QDomElement methodParams = methodCall.firstChildElement("params");
+            if( !methodParams.isNull() )
+            {
+                QDomNode param = methodParams.firstChild();
+                while( !param.isNull() && isValid() )
+                {
+                    m_args.append( demarshall( param.firstChild().toElement() ) );
+                    param = param.nextSibling();
+                }
+            }
+        }
+        else
+            setError("Not a valid methodCall message.");
+    }
+    else
+    {
+        setError(QString( "XML Error: %1 at row %2 and col %3")
+             .arg(xmlErrMsg).arg(xmlErrLine).arg(xmlErrCol));
+    }
 }
 
 void XMLRPC::ResponseMessage::writeXml( QXmlStreamWriter *writer ) const
@@ -416,18 +416,18 @@ void XMLRPC::ResponseMessage::writeXml( QXmlStreamWriter *writer ) const
 
 QByteArray XMLRPC::ResponseMessage::xml( ) const
 {
-        QByteArray returnXML ;
-        QXmlStreamWriter writer(&returnXML);
-        writer.writeStartDocument();
-        writeXml( &writer );
-        writer.writeEndElement();
-        writer.writeEndDocument();
-     return returnXML;
+    QByteArray returnXML ;
+    QXmlStreamWriter writer(&returnXML);
+    writer.writeStartDocument();
+    writeXml( &writer );
+    writer.writeEndElement();
+    writer.writeEndDocument();
+    return returnXML;
 }
 
 void XMLRPC::ResponseMessage::setValues( const QList< QVariant > vals )
 {
-     m_values = vals;
+    m_values = vals;
 }
 
 XMLRPC::ResponseMessage::ResponseMessage( const QList< QVariant > & theValue  )
@@ -438,5 +438,5 @@ XMLRPC::ResponseMessage::ResponseMessage( const QList< QVariant > & theValue  )
 XMLRPC::ResponseMessage::ResponseMessage( const QVariant & theValue )
 : MessageBase()
 {
-     m_values << theValue;
+    m_values << theValue;
 }
diff --git a/source/xmlrpc.h b/source/xmlrpc.h
index fd59faf4..ec70864b 100644
--- a/source/xmlrpc.h
+++ b/source/xmlrpc.h
@@ -16,16 +16,16 @@
 *
 * An example of how to use the XML Packets is as follows:
 * @code
-*     QList<QVariant> args;
-*     args << m_db << m_username << m_password << dbQuery;
-*     RequestMessage msg( "data.query", args );
-*     ResponseMessage resp( SomeHttpDispatchObject( msg.xml() ) );
-*     if( resp.isValid() )
-*     {
-*          int rows = resp.value().toMap()["widgets"].toInt();
-*     }
-*     else
-*          qWarning("Error: %s", resp.error().latin1() );
+*    QList<QVariant> args;
+*    args << m_db << m_username << m_password << dbQuery;
+*    RequestMessage msg( "data.query", args );
+*    ResponseMessage resp( SomeHttpDispatchObject( msg.xml() ) );
+*    if( resp.isValid() )
+*    {
+*        int rows = resp.value().toMap()["widgets"].toInt();
+*    }
+*    else
+*        qWarning("Error: %s", resp.error().latin1() );
 * @endcode
 * This example will construct invoke the data.query() method on the XMLRPC
 * interface with the args.  It will then check for the response to see if
@@ -47,32 +47,32 @@ namespace XMLRPC
 class MessageBase
 {
 public:
-     MessageBase();
-     virtual ~MessageBase();
+    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 a human readable error that was recived from the server.
+    */
+    QString error() const;
 
-     /**
-     * Returns if the current message is valid.
+    /**
+     * Sets the human readable error message.
      */
-     bool isValid() const;
+    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;
+    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;
+    mutable QString m_message;
+    mutable bool m_valid;
 };
 
 /**
@@ -84,36 +84,36 @@ class RequestMessage : public MessageBase
 {
 public:
         RequestMessage( const QDomElement &element );
-     /**
+    /**
          * Creates an RequestMessage from an XML packet.
-      */
-     RequestMessage( const QByteArray &xml );
-     /**
-     * Creates a method packet that will call method with a list of args.
      */
-     RequestMessage( const QByteArray &method, const QList<QVariant> &args );
+    RequestMessage( const QByteArray &xml );
+    /**
+    * Creates a method packet that will call method with a list of args.
+    */
+    RequestMessage( const QByteArray &method, const QList<QVariant> &args );
 
-     /**
-     * Convinence ctor that creates a packet for a method with a single
-     * argument.
-     */
-     RequestMessage( const QByteArray &method, const QVariant &arg );
+    /**
+    * Convinence ctor that creates a packet for a method with a single
+    * argument.
+    */
+    RequestMessage( const QByteArray &method, const QVariant &arg );
 
-     virtual ~RequestMessage() {;}
+    virtual ~RequestMessage() {;}
 
-     /**
-     * Return the xml representation of the packet.
-     */
-     QByteArray xml() const;
-        void writeXml( QXmlStreamWriter *writer ) const;
+    /**
+    * Return the xml representation of the packet.
+    */
+    QByteArray xml() const;
+    void writeXml( QXmlStreamWriter *writer ) const;
 
-     QByteArray method() const;
-     QList< QVariant > args() const;
+    QByteArray method() const;
+    QList< QVariant > args() const;
 
 
 private:
-     QByteArray m_method;
-     QList<QVariant> m_args;
+    QByteArray m_method;
+    QList<QVariant> m_args;
 
 };
 
@@ -124,52 +124,55 @@ private:
 class ResponseMessage : public MessageBase
 {
 public:
-        /**
-        * Create a new recive packet with an xml packet
-        */
-        ResponseMessage( const QDomElement &element );
-
-     /**
-     * Create a new recive packet with an xml packet
+    /**
+    * Create a new recive packet with an xml packet
+    */
+    ResponseMessage( const QDomElement &element );
+
+    /**
+    * Create a new recive packet with an xml packet
+    */
+    ResponseMessage( const QByteArray &xml );
+
+    /**
+     * Create a new response message with data.
      */
-     ResponseMessage( const QByteArray &xml );
-     /**
-      * Create a new response message with data.
-      */
-     ResponseMessage( const QList< QVariant >& theValue );
-
-     /**
-      * Create a new response message with data. This is exactly like
-      * the above method save for it only takes a single QVariant.
-      */
-     explicit ResponseMessage( const QVariant& theValue );
-
-     virtual ~ResponseMessage() {;}
-     /**
-     * Returns the number of data elements.  Usually this is only
-     * 1 element, but some services will return mutiple messages in
-     * a single xmlrpc packet.
-     */
-     int count() const;
-     /**
-     * Returns the native value for an xmlrpc message at an offset.
-     * Usually this method can be called with no arguments.
-     */
-     QVariant value( int idx = 0 ) const;
+    ResponseMessage( const QList< QVariant >& theValue );
 
-     /**
-     * Return the xml representation of the packet.
+    /**
+     * Create a new response message with data. This is exactly like
+     * the above method save for it only takes a single QVariant.
      */
-     virtual QByteArray xml() const;
-        void writeXml( QXmlStreamWriter *writer ) const;
+    explicit ResponseMessage( const QVariant& theValue );
+
+    virtual ~ResponseMessage() {;}
+
+    /**
+    * Returns the number of data elements.  Usually this is only
+    * 1 element, but some services will return mutiple messages in
+    * a single xmlrpc packet.
+    */
+    int count() const;
+
+    /**
+    * Returns the native value for an xmlrpc message at an offset.
+    * Usually this method can be called with no arguments.
+    */
+    QVariant value( int idx = 0 ) const;
+
+    /**
+    * Return the xml representation of the packet.
+    */
+    virtual QByteArray xml() const;
+    void writeXml( QXmlStreamWriter *writer ) const;
 
 
-     QList< QVariant > values() const;
+    QList< QVariant > values() const;
 protected:
-     void setValues( const QList<QVariant> va2ls);
+    void setValues( const QList<QVariant> va2ls);
 
 private:
-     QList<QVariant> m_values;
+    QList<QVariant> m_values;
 };
 
 }