reorganise

2 files changed, 210 insertions, 0 deletions

diff --git a/src/client/QXmppInvokable.cpp b/src/client/QXmppInvokable.cpp
new file mode 100644
index 00000000..10815734
--- /dev/null
+++ b/src/client/QXmppInvokable.cpp
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2008-2011 The QXmpp developers
+ *
+ * Authors:
+ *  Ian Reinhart Geiser
+ *
+ * Source:
+ *  http://code.google.com/p/qxmpp
+ *
+ * This file is a part of QXmpp library.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ */
+
+#include "QXmppInvokable.h"
+
+#include <QVariant>
+#include <QMetaMethod>
+#include <QStringList>
+
+#include <qdebug.h>
+
+/// Constructs a QXmppInvokable with the specified \a parent.
+///
+/// \param parent
+
+QXmppInvokable::QXmppInvokable(QObject *parent)
+    : QObject(parent)
+{
+}
+
+/// Destroys a QXmppInvokable.
+
+QXmppInvokable::~QXmppInvokable()
+{
+}
+
+QVariant QXmppInvokable::dispatch( const QByteArray & method, const QList< QVariant > & args )
+{
+    buildMethodHash();
+
+    if( !m_methodHash.contains(method))
+        return QVariant();
+
+    int idx = m_methodHash[method];
+    if( paramTypes( args) != metaObject()->method(idx).parameterTypes ())
+        return QVariant();
+
+    const char *typeName = metaObject()->method(idx).typeName();
+    int resultType = QMetaType::type(typeName);
+    void *result = QMetaType::construct(resultType, 0);
+
+    QGenericReturnArgument ret( typeName, result );
+    QList<QGenericArgument> genericArgs;
+    QList<QVariant>::ConstIterator iter = args.begin();
+    while( iter != args.end())
+    {
+        const void *data = iter->data();
+        const char *name = iter->typeName();
+        genericArgs << QGenericArgument(name,data);
+        ++iter;
+    }
+
+    if( QMetaObject::invokeMethod ( this, method.constData(), ret,
+                                    genericArgs.value(0, QGenericArgument() ),
+                                    genericArgs.value(1, QGenericArgument() ),
+                                    genericArgs.value(2, QGenericArgument() ),
+                                    genericArgs.value(3, QGenericArgument() ),
+                                    genericArgs.value(4, QGenericArgument() ),
+                                    genericArgs.value(5, QGenericArgument() ),
+                                    genericArgs.value(6, QGenericArgument() ),
+                                    genericArgs.value(7, QGenericArgument() ),
+                                    genericArgs.value(8, QGenericArgument() ),
+                                    genericArgs.value(9, QGenericArgument() )) )
+    {
+        QVariant returnValue( resultType, result);
+        QMetaType::destroy(resultType, result);
+        return returnValue;
+    }
+    else
+    {
+        qDebug("No such method '%s'", method.constData() );
+        return QVariant();
+    }
+}
+
+QList< QByteArray > QXmppInvokable::paramTypes( const QList< QVariant > & params )
+{
+    QList<QByteArray> types;
+    foreach( QVariant variant, params)
+        types << variant.typeName();
+    return types;
+}
+
+void QXmppInvokable::buildMethodHash( )
+{
+    QWriteLocker locker(&m_lock);
+    if( m_methodHash.size() > 0 )
+        return;
+
+    int methodCount = metaObject()->methodCount ();
+    for( int idx = 0; idx < methodCount; ++idx)
+    {
+        QByteArray signature = metaObject()->method(idx).signature();
+        m_methodHash[signature.left(signature.indexOf('('))] = idx;
+//         qDebug() << metaObject()->method(idx).parameterTypes();
+    }
+}
+
+QStringList QXmppInvokable::interfaces( ) const
+{
+    QStringList results;
+    int methodCount = metaObject()->methodCount ();
+    for( int idx = 0; idx < methodCount; ++idx)
+    {
+        if( metaObject()->method(idx).methodType() == QMetaMethod::Slot )
+        {
+            QByteArray signature = metaObject()->method(idx).signature();
+            results << signature.left(signature.indexOf('('));
+        }
+    }
+    return results;
+}
+
diff --git a/src/client/QXmppInvokable.h b/src/client/QXmppInvokable.h
new file mode 100644
index 00000000..de245482
--- /dev/null
+++ b/src/client/QXmppInvokable.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2008-2011 The QXmpp developers
+ *
+ * Authors:
+ *  Ian Reinhart Geiser
+ *
+ * Source:
+ *  http://code.google.com/p/qxmpp
+ *
+ * This file is a part of QXmpp library.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ */
+
+#ifndef QXMPPINVOKABLE_H
+#define QXMPPINVOKABLE_H
+
+#include <QObject>
+#include <QHash>
+#include <QVariant>
+#include <QWriteLocker>
+#include <QStringList>
+
+/**
+This is the base class for all objects that will be invokable via RPC.  All public slots of objects derived from this class will be exposed to the RPC interface.  As a note for all methods, they can only understand types that QVariant knows about.
+
+        @author Ian Reinhart Geiser <geiseri@kde.org>
+*/
+class QXmppInvokable : public QObject
+{
+        Q_OBJECT
+public:
+        QXmppInvokable( QObject *parent = 0 );
+
+        ~QXmppInvokable();
+
+        /**
+         * Execute a method on an object. with a set of arguments. This method is reentrant, and the method
+         * that is invoked will be done in a thread safe manner.  It should be noted that while this method
+         * is threadsafe and reentrant the side affects of the methods invoked may not be.
+         */
+        QVariant dispatch( const QByteArray &method, const QList<QVariant> &args = QList<QVariant>() );
+
+        /**
+         * Utility method to convert a QList<QVariant> to a list of types for type
+         * checking.
+         */
+        static QList<QByteArray> paramTypes( const QList<QVariant> &params );
+
+        /**
+          * Reimplement this method to return a true if the invoking JID is allowed to execute the method.
+          */
+        virtual bool isAuthorized( const QString &jid ) const = 0;
+
+public slots:
+        /**
+          * This provides a list of interfaces for introspection of the presented interface.
+          */
+        QStringList interfaces() const;
+
+private:
+        void buildMethodHash();
+        QHash<QByteArray,int> m_methodHash;
+        QReadWriteLock m_lock;
+};
+
+
+#endif