diff -r 000000000000 -r 1918ee327afb src/dbus/qdbuspendingreply.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/dbus/qdbuspendingreply.cpp	Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,277 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDBus module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qdbuspendingreply.h"
+#include "qdbuspendingcall_p.h"
+#include "qdbusmetatype.h"
+
+/*!
+    \class QDBusPendingReply
+    \inmodule QtDBus
+    \since 4.5
+
+    \brief The QDBusPendingReply class contains the reply to an asynchronous method call
+
+    The QDBusPendingReply is a template class with up to 8 template
+    parameters. Those parameters are the types that will be used to
+    extract the contents of the reply's data.
+
+    This class is similar in functionality to QDBusReply, but with two
+    important differences:
+
+    \list
+      \o QDBusReply accepts exactly one return type, whereas
+         QDBusPendingReply can have from 1 to 8 types
+      \o QDBusReply only works on already completed replies, whereas
+         QDBusPendingReply allows one to wait for replies from pending
+         calls
+    \endlist
+
+    Where with QDBusReply you would write:
+
+    \snippet doc/src/snippets/code/src_qdbus_qdbusreply.cpp 0
+
+    with QDBusPendingReply, the equivalent code (including the blocking
+    wait for the reply) would be:
+
+    \snippet doc/src/snippets/code/src.qdbus.qdbuspendingreply.cpp 0
+
+    For method calls that have more than one output argument, with
+    QDBusReply, you would write:
+
+    \snippet doc/src/snippets/code/src_qdbus_qdbusreply.cpp 1
+
+    whereas with QDBusPendingReply, all of the output arguments should
+    be template parameters:
+
+    \snippet doc/src/snippets/code/src.qdbus.qdbuspendingreply.cpp 2
+
+    QDBusPendingReply objects can be associated with
+    QDBusPendingCallWatcher objects, which emit signals when the reply
+    arrives.
+
+    \sa QDBusPendingCallWatcher, QDBusReply,
+        QDBusAbstractInterface::asyncCall()
+*/
+
+/*!
+    \fn QDBusPendingReply::QDBusPendingReply()
+
+    Creates an empty QDBusPendingReply object. Without assigning a
+    QDBusPendingCall object to this reply, QDBusPendingReply cannot do
+    anything. All functions return their failure values.
+*/
+
+/*!
+    \fn QDBusPendingReply::QDBusPendingReply(const QDBusPendingReply &other)
+
+    Creates a copy of the \a other QDBusPendingReply object. Just like
+    QDBusPendingCall and QDBusPendingCallWatcher, this QDBusPendingReply
+    object will share the same pending call reference. All copies
+    share the same return values.
+*/
+
+/*!
+    \fn QDBusPendingReply::QDBusPendingReply(const QDBusPendingCall &call)
+
+    Creates a QDBusPendingReply object that will take its contents from
+    the \a call pending asynchronous call. This QDBusPendingReply object
+    will share the same pending call reference as \a call.
+*/
+
+/*!
+    \fn QDBusPendingReply::QDBusPendingReply(const QDBusMessage &message)
+
+    Creates a QDBusPendingReply object that will take its contents from
+    the message \a message. In this case, this object will be already
+    in its finished state and the reply's contents will be accessible.
+
+    \sa isFinished()
+*/
+
+/*!
+    \fn QDBusPendingReply &QDBusPendingReply::operator=(const QDBusPendingReply &other)
+
+    Makes a copy of \a other and drops the reference to the current
+    pending call. If the current reference is to an unfinished pending
+    call and this is the last reference, the pending call will be
+    canceled and there will be no way of retrieving the reply's
+    contents, when they arrive.
+*/
+
+/*!
+    \fn QDBusPendingReply &QDBusPendingReply::operator=(const QDBusPendingCall &call)
+
+    Makes this object take its contents from the \a call pending call
+    and drops the reference to the current pending call. If the
+    current reference is to an unfinished pending call and this is the
+    last reference, the pending call will be canceled and there will
+    be no way of retrieving the reply's contents, when they arrive.
+*/
+
+/*!
+    \fn QDBusPendingReply &QDBusPendingReply::operator=(const QDBusMessage &message)
+
+    Makes this object take its contents from the \a message message
+    and drops the reference to the current pending call. If the
+    current reference is to an unfinished pending call and this is the
+    last reference, the pending call will be canceled and there will
+    be no way of retrieving the reply's contents, when they arrive.
+
+    After this function is finished, the QDBusPendingReply object will
+    be in its "finished" state and the \a message contents will be
+    accessible.
+
+    \sa isFinished()
+*/
+
+/*!
+    \fn int QDBusPendingReply::count() const
+
+    Return the number of arguments the reply is supposed to have. This
+    number matches the number of non-void template parameters in this
+    class.
+
+    If the reply arrives with a different number of arguments (or with
+    different types), it will be transformed into an error reply
+    indicating a bad signature.
+*/
+
+/*!
+    \fn QVariant QDBusPendingReply::argumentAt(int index) const
+
+    Returns the argument at position \a index in the reply's
+    contents. If the reply doesn't have that many elements, this
+    function's return value is undefined (will probably cause an
+    assertion failure), so it is important to verify that the
+    processing is finished and the reply is valid.
+*/
+
+/*!
+    \fn Type QDBusPendingReply::argumentAt() const
+
+    Returns the argument at position \c Index (which is a template
+    parameter) cast to type \c Type. This function uses template code
+    to determine the proper \c Type type, according to the type list
+    used in the construction of this object.
+
+    Note that, if the reply hasn't arrived, this function causes the
+    calling thread to block until the reply is processed.
+*/
+
+/*!
+    \fn T1 QDBusPendingReply::value() const
+
+    Returns the first argument in this reply, cast to type \c T1 (the
+    first template parameter of this class). This is equivalent to
+    calling argumentAt<0>().
+
+    This function is provided as a convenience, matching the
+    QDBusReply::value() function.
+
+    Note that, if the reply hasn't arrived, this function causes the
+    calling thread to block until the reply is processed.
+*/
+
+/*!
+    \fn QDBusPendingReply::operator T1() const
+
+    Returns the first argument in this reply, cast to type \c T1 (the
+    first template parameter of this class). This is equivalent to
+    calling argumentAt<0>().
+
+    This function is provided as a convenience, matching the
+    QDBusReply::value() function.
+
+    Note that, if the reply hasn't arrived, this function causes the
+    calling thread to block until the reply is processed.
+*/
+
+/*!
+    \fn void QDBusPendingReply::waitForFinished()
+
+    Suspends the execution of the calling thread until the reply is
+    received and processed. After this function returns, isFinished()
+    should return true, indicating the reply's contents are ready to
+    be processed.
+
+    \sa QDBusPendingCallWatcher::waitForFinished()
+*/
+
+QDBusPendingReplyData::QDBusPendingReplyData()
+    : QDBusPendingCall(0)         // initialize base class empty
+{
+}
+
+QDBusPendingReplyData::~QDBusPendingReplyData()
+{
+}
+
+void QDBusPendingReplyData::assign(const QDBusPendingCall &other)
+{
+    QDBusPendingCall::operator=(other);
+}
+
+void QDBusPendingReplyData::assign(const QDBusMessage &message)
+{
+    d = new QDBusPendingCallPrivate; // drops the reference to the old one
+    d->replyMessage = message;
+}
+
+QVariant QDBusPendingReplyData::argumentAt(int index) const
+{
+    if (d)
+        d->waitForFinished();   // bypasses "const"
+
+    Q_ASSERT_X(d && index >= 0 && index < d->replyMessage.arguments().count(),
+               "QDBusPendingReply::argumentAt",
+               "Index out of bounds");
+
+    return d->replyMessage.arguments().at(index);
+}
+
+void QDBusPendingReplyData::setMetaTypes(int count, const int *types)
+{
+    Q_ASSERT(d);
+    d->setMetaTypes(count, types);
+    d->checkReceivedSignature();
+}
+