[Telepathy-commits] [telepathy-qt4/master] Added ReadinessHelper and PendingReady classes.
Andre Moreira Magalhaes (andrunko)
andre.magalhaes at collabora.co.uk
Wed Feb 18 14:42:01 PST 2009
ReadinessHelper is a helper class that should be used by all classes that wants
to implement isReady/becomeReady mechanisms.
PendingReady is a class used by ReadinessHelper::becomeReady.
---
TelepathyQt4/Client/PendingReady | 13 +
TelepathyQt4/Client/ReadinessHelper | 13 +
TelepathyQt4/Client/pending-ready.cpp | 106 +++++++++
TelepathyQt4/Client/pending-ready.h | 62 ++++++
TelepathyQt4/Client/readiness-helper.cpp | 350 ++++++++++++++++++++++++++++++
TelepathyQt4/Client/readiness-helper.h | 113 ++++++++++
TelepathyQt4/Makefile.am | 8 +
7 files changed, 665 insertions(+), 0 deletions(-)
create mode 100644 TelepathyQt4/Client/PendingReady
create mode 100644 TelepathyQt4/Client/ReadinessHelper
create mode 100644 TelepathyQt4/Client/pending-ready.cpp
create mode 100644 TelepathyQt4/Client/pending-ready.h
create mode 100644 TelepathyQt4/Client/readiness-helper.cpp
create mode 100644 TelepathyQt4/Client/readiness-helper.h
diff --git a/TelepathyQt4/Client/PendingReady b/TelepathyQt4/Client/PendingReady
new file mode 100644
index 0000000..135ea8b
--- /dev/null
+++ b/TelepathyQt4/Client/PendingReady
@@ -0,0 +1,13 @@
+#ifndef _TelepathyQt4_Client_PendingReady_HEADER_GUARD_
+#define _TelepathyQt4_Client_PendingReady_HEADER_GUARD_
+
+#ifndef IN_TELEPATHY_QT4_HEADER
+#define IN_TELEPATHY_QT4_HEADER
+#endif
+
+#include <TelepathyQt4/Client/pending-ready.h>
+
+#undef IN_TELEPATHY_QT4_HEADER
+
+#endif
+// vim:set ft=cpp:
diff --git a/TelepathyQt4/Client/ReadinessHelper b/TelepathyQt4/Client/ReadinessHelper
new file mode 100644
index 0000000..e779b28
--- /dev/null
+++ b/TelepathyQt4/Client/ReadinessHelper
@@ -0,0 +1,13 @@
+#ifndef _TelepathyQt4_Client_ReadinessHelper_HEADER_GUARD_
+#define _TelepathyQt4_Client_ReadinessHelper_HEADER_GUARD_
+
+#ifndef IN_TELEPATHY_QT4_HEADER
+#define IN_TELEPATHY_QT4_HEADER
+#endif
+
+#include <TelepathyQt4/Client/readiness-helper.h>
+
+#undef IN_TELEPATHY_QT4_HEADER
+
+#endif
+// vim:set ft=cpp:
diff --git a/TelepathyQt4/Client/pending-ready.cpp b/TelepathyQt4/Client/pending-ready.cpp
new file mode 100644
index 0000000..825e82c
--- /dev/null
+++ b/TelepathyQt4/Client/pending-ready.cpp
@@ -0,0 +1,106 @@
+/*
+ * This file is part of TelepathyQt4
+ *
+ * Copyright (C) 2009 Collabora Ltd. <http://www.collabora.co.uk/>
+ * Copyright (C) 2009 Nokia Corporation
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <TelepathyQt4/Client/PendingReady>
+
+#include "TelepathyQt4/Client/_gen/pending-ready.moc.hpp"
+
+#include "TelepathyQt4/debug-internal.h"
+
+/**
+ * \addtogroup clientsideproxies Client-side proxies
+ *
+ * Proxy objects representing remote service objects accessed via D-Bus.
+ *
+ * In addition to providing direct access to methods, signals and properties
+ * exported by the remote objects, some of these proxies offer features like
+ * automatic inspection of remote object capabilities, property tracking,
+ * backwards compatibility helpers for older services and other utilities.
+ */
+
+namespace Telepathy
+{
+namespace Client
+{
+
+struct PendingReady::Private
+{
+ Private(const QSet<uint> &requestedFeatures, QObject *object) :
+ requestedFeatures(requestedFeatures),
+ object(object)
+ {
+ }
+
+ QSet<uint> requestedFeatures;
+ QObject *object;
+};
+
+/**
+ * \class PendingReady
+ * \headerfile <TelepathyQt4/Client/pending-ready.h> <TelepathyQt4/Client/PendingReady>
+ *
+ * Class containing the features requested and the reply to a request
+ * for an object to become ready. Instances of this class cannot be
+ * constructed directly; the only way to get one is via Object::becomeReady().
+ */
+
+/**
+ * Construct a PendingReady object.
+ *
+ * \param object The object that will become ready.
+ */
+PendingReady::PendingReady(const QSet<uint> &requestedFeatures, QObject *object)
+ : PendingOperation(object),
+ mPriv(new Private(requestedFeatures, object))
+{
+}
+
+/**
+ * Class destructor.
+ */
+PendingReady::~PendingReady()
+{
+ delete mPriv;
+}
+
+/**
+ * Return the object through which the request was made.
+ *
+ * \return QObject representing the object through which the request was made.
+ */
+QObject *PendingReady::object() const
+{
+ return mPriv->object;
+}
+
+/**
+ * Return the Features that were requested to become ready on the
+ * object.
+ *
+ * \return Features.
+ */
+QSet<uint> PendingReady::requestedFeatures() const
+{
+ return mPriv->requestedFeatures;
+}
+
+} // Telepathy::Client
+} // Telepathy
diff --git a/TelepathyQt4/Client/pending-ready.h b/TelepathyQt4/Client/pending-ready.h
new file mode 100644
index 0000000..92bda3f
--- /dev/null
+++ b/TelepathyQt4/Client/pending-ready.h
@@ -0,0 +1,62 @@
+/*
+ * This file is part of TelepathyQt4
+ *
+ * Copyright (C) 2009 Collabora Ltd. <http://www.collabora.co.uk/>
+ * Copyright (C) 2009 Nokia Corporation
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _TelepathyQt4_cli_pending_ready_h_HEADER_GUARD_
+#define _TelepathyQt4_cli_pending_ready_h_HEADER_GUARD_
+
+#ifndef IN_TELEPATHY_QT4_HEADER
+#error IN_TELEPATHY_QT4_HEADER
+#endif
+
+#include <TelepathyQt4/Client/PendingOperation>
+#include <TelepathyQt4/Client/ReadinessHelper>
+
+#include <QSet>
+
+namespace Telepathy
+{
+namespace Client
+{
+
+class PendingReady: public PendingOperation
+{
+ Q_OBJECT
+
+public:
+ ~PendingReady();
+
+ QObject *object() const;
+ QSet<uint> requestedFeatures() const;
+
+private:
+ Q_DISABLE_COPY(PendingReady);
+ PendingReady(const QSet<uint> &requestedFeatures, QObject *object);
+
+ struct Private;
+ friend struct Private;
+ friend class ReadinessHelper;
+ Private *mPriv;
+};
+
+} // Telepathy::Client
+} // Telepathy
+
+#endif
diff --git a/TelepathyQt4/Client/readiness-helper.cpp b/TelepathyQt4/Client/readiness-helper.cpp
new file mode 100644
index 0000000..1392691
--- /dev/null
+++ b/TelepathyQt4/Client/readiness-helper.cpp
@@ -0,0 +1,350 @@
+/*
+ * This file is part of TelepathyQt4
+ *
+ * Copyright (C) 2008 Collabora Ltd. <http://www.collabora.co.uk/>
+ * Copyright (C) 2008 Nokia Corporation
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <TelepathyQt4/Client/ReadinessHelper>
+
+#include "TelepathyQt4/Client/_gen/readiness-helper.moc.hpp"
+
+#include "TelepathyQt4/debug-internal.h"
+
+#include <TelepathyQt4/Client/PendingReady>
+
+#include <QTimer>
+
+namespace Telepathy
+{
+namespace Client
+{
+
+struct ReadinessHelper::Private
+{
+ Private(ReadinessHelper *parent,
+ uint currentStatus,
+ const QMap<uint, Introspectable> &introspectables);
+ ~Private();
+
+ void setCurrentStatus(uint newStatus);
+ void introspectCore();
+ void setIntrospectCompleted(uint feature, bool success);
+ void iterateIntrospection();
+
+ ReadinessHelper *parent;
+ uint currentStatus;
+ QStringList interfaces;
+ QMap<uint, Introspectable> introspectables;
+ QSet<uint> supportedStatuses;
+ QSet<uint> satisfiedFeatures;
+ QSet<uint> requestedFeatures;
+ QSet<uint> missingFeatures;
+ QSet<uint> pendingFeatures;
+ QSet<uint> inFlightFeatures;
+ QList<PendingReady *> pendingOperations;
+
+ bool pendingStatusChange;
+ uint pendingStatus;
+};
+
+ReadinessHelper::Private::Private(
+ ReadinessHelper *parent,
+ uint currentStatus,
+ const QMap<uint, Introspectable> &introspectables)
+ : parent(parent),
+ currentStatus(currentStatus),
+ introspectables(introspectables),
+ pendingStatusChange(false),
+ pendingStatus(-1)
+{
+ // we must have an introspectable for core
+ Q_ASSERT(introspectables.contains(0));
+
+ foreach (const ReadinessHelper::Introspectable &introspectable, introspectables) {
+ Q_ASSERT(introspectable.introspectFunc != 0);
+ supportedStatuses += introspectable.makesSenseForStatuses;
+ }
+
+ if (supportedStatuses.contains(currentStatus)) {
+ introspectCore();
+ }
+}
+
+ReadinessHelper::Private::~Private()
+{
+ // TODO finish all pending operations
+}
+
+void ReadinessHelper::Private::setCurrentStatus(uint newStatus)
+{
+ if (inFlightFeatures.isEmpty()) {
+ currentStatus = newStatus;
+ satisfiedFeatures.clear();
+ missingFeatures.clear();
+
+ // retrieve all features that were requested for the new status
+ pendingFeatures = requestedFeatures;
+
+ if (supportedStatuses.contains(currentStatus)) {
+ introspectCore();
+ } else {
+ emit parent->statusReady(currentStatus);
+ }
+ } else {
+ debug() << "status changed while introspection process was running";
+ pendingStatusChange = true;
+ pendingStatus = newStatus;
+ }
+}
+
+void ReadinessHelper::Private::introspectCore()
+{
+ debug() << "Status changed to" << currentStatus << "- introspecting core";
+ requestedFeatures += 0;
+ pendingFeatures += 0;
+ QTimer::singleShot(0, parent, SLOT(iterateIntrospection()));
+}
+
+void ReadinessHelper::Private::setIntrospectCompleted(uint feature, bool success)
+{
+ debug() << "ReadinessHelper::setIntrospectCompleted: feature:" << feature <<
+ "- success:" << success;
+ if (pendingStatusChange) {
+ debug() << "ReadinessHelper::setIntrospectCompleted called while there is "
+ "a pending status change - ignoring";
+
+ inFlightFeatures.remove(feature);
+
+ // ignore all introspection completed as the state changed
+ if (!inFlightFeatures.isEmpty()) {
+ return;
+ }
+ pendingStatusChange = false;
+ setCurrentStatus(pendingStatus);
+ return;
+ }
+
+ Q_ASSERT(pendingFeatures.contains(feature));
+ Q_ASSERT(inFlightFeatures.contains(feature));
+
+ if (success) {
+ satisfiedFeatures.insert(feature);
+ }
+ else {
+ missingFeatures.insert(feature);
+ }
+
+ pendingFeatures.remove(feature);
+ inFlightFeatures.remove(feature);
+
+ QTimer::singleShot(0, parent, SLOT(iterateIntrospection()));
+}
+
+void ReadinessHelper::Private::iterateIntrospection()
+{
+ if (!supportedStatuses.contains(currentStatus)) {
+ debug() << "ignoring iterate introspection for status" << currentStatus;
+ // don't do anything just now to avoid spurious becomeReady finishes
+ return;
+ }
+
+ // take care to flag anything with dependencies in missing, and the
+ // stuff depending on them, as missing
+ QMap<uint, Introspectable>::const_iterator i = introspectables.constBegin();
+ while (i != introspectables.constEnd()) {
+ uint feature = i.key();
+ Introspectable introspectable = i.value();
+ if (!introspectable.dependsOnFeatures.intersect(missingFeatures).isEmpty()) {
+ missingFeatures += feature;
+ }
+ ++i;
+ }
+
+ // check if any pending operations for becomeReady should finish now
+ // based on their requested features having nothing more than what
+ // satisfiedFeatures + missingFeatures has
+ foreach (PendingReady *operation, pendingOperations) {
+ if ((operation->requestedFeatures() - (satisfiedFeatures + missingFeatures)).isEmpty()) {
+ // TODO should we finish with error if requestedFeatures is on missingFeatures?
+ operation->setFinished();
+ pendingOperations.removeOne(operation);
+ }
+ }
+
+ if ((requestedFeatures - (satisfiedFeatures + missingFeatures)).isEmpty()) {
+ // all requested features satisfied or missing
+ emit parent->statusReady(currentStatus);
+ return;
+ }
+
+ // update pendingFeatures with the difference of requested and
+ // satisfied + missing
+ pendingFeatures -= (satisfiedFeatures + missingFeatures);
+
+ // find out which features don't have dependencies that are still pending
+ QSet<uint> readyToIntrospect;
+ foreach (uint feature, pendingFeatures) {
+ // missing doesn't have to be considered here anymore
+ if ((introspectables[feature].dependsOnFeatures - satisfiedFeatures).isEmpty()) {
+ readyToIntrospect.insert(feature);
+ }
+ }
+
+ // now readyToIntrospect should contain all the features which have
+ // all their feature dependencies satisfied
+ foreach (uint feature, readyToIntrospect) {
+ if (inFlightFeatures.contains(feature)) {
+ continue;
+ }
+
+ inFlightFeatures.insert(feature);
+
+ Introspectable introspectable = introspectables[feature];
+
+ if (!introspectable.makesSenseForStatuses.contains(currentStatus)) {
+ // No-op satisfy features for which nothing has to be done in
+ // the current state
+ setIntrospectCompleted(feature, true);
+ return; // will be called with a single-shot soon again
+ }
+
+ if (feature != 0) {
+ foreach (const QString &interface, introspectable.dependsOnInterfaces) {
+ if (!interfaces.contains(interface)) {
+ // Core is a dependency for everything, so interfaces are
+ // introspected - if not all of them are present, the feature can't
+ // possibly be satisfied
+ debug() << "feature" << feature << "depends on interfaces" <<
+ introspectable.dependsOnInterfaces << ", but interface" << interface <<
+ "is not present";
+ setIntrospectCompleted(feature, false);
+ return; // will be called with a single-shot soon again
+ }
+ }
+ }
+
+ // yes, with the dependency info, we can even parallelize
+ // introspection of several features at once, reducing total round trip
+ // time considerably with many independent features!
+ (*(introspectable.introspectFunc))(introspectable.introspectFuncData);
+ }
+}
+
+ReadinessHelper::ReadinessHelper(uint currentStatus,
+ const QMap<uint, Introspectable> &introspectables,
+ QObject *parent)
+ : QObject(parent),
+ mPriv(new Private(this, currentStatus, introspectables))
+{
+}
+
+ReadinessHelper::~ReadinessHelper()
+{
+ delete mPriv;
+}
+
+uint ReadinessHelper::currentStatus() const
+{
+ return mPriv->currentStatus;
+}
+
+void ReadinessHelper::setCurrentStatus(uint currentStatus)
+{
+ mPriv->setCurrentStatus(currentStatus);
+}
+
+QStringList ReadinessHelper::interfaces() const
+{
+ return mPriv->interfaces;
+}
+
+void ReadinessHelper::setInterfaces(const QStringList &interfaces)
+{
+ mPriv->interfaces = interfaces;
+}
+
+QSet<uint> ReadinessHelper::requestedFeatures() const
+{
+ return mPriv->requestedFeatures;
+}
+
+QSet<uint> ReadinessHelper::actualFeatures() const
+{
+ return mPriv->satisfiedFeatures;
+}
+
+QSet<uint> ReadinessHelper::missingFeatures() const
+{
+ return mPriv->missingFeatures;
+}
+
+bool ReadinessHelper::isReady(QSet<uint> features) const
+{
+ if (features.isEmpty()) {
+ features << 0; // it is empty, consider core
+ }
+
+ // if we ask if core is ready, core should be on satisfiedFeatures
+ if (features.contains(0)) {
+ return (features - mPriv->satisfiedFeatures).isEmpty();
+ } else {
+ return (features - (mPriv->satisfiedFeatures + mPriv->missingFeatures)).isEmpty();
+ }
+}
+
+PendingReady *ReadinessHelper::becomeReady(QSet<uint> requestedFeatures)
+{
+ // TODO check if requestedFeatures does not contain any invalid feature
+ // check if parent object is valid - this would need the parent object
+ // to be of type DBusProxy
+
+ if (requestedFeatures.isEmpty()) {
+ requestedFeatures << 0; // it is empty, consider core
+ }
+
+ PendingReady *operation;
+ foreach (operation, mPriv->pendingOperations) {
+ if (operation->requestedFeatures() == requestedFeatures) {
+ return operation;
+ }
+ }
+
+ mPriv->requestedFeatures += requestedFeatures;
+ // it will be updated on iterateIntrospection
+ mPriv->pendingFeatures += requestedFeatures;
+
+ operation = new PendingReady(requestedFeatures, parent());
+ mPriv->pendingOperations.append(operation);
+
+ QTimer::singleShot(0, this, SLOT(iterateIntrospection()));
+
+ return operation;
+}
+
+void ReadinessHelper::setIntrospectCompleted(uint feature, bool success)
+{
+ mPriv->setIntrospectCompleted(feature, success);
+}
+
+void ReadinessHelper::iterateIntrospection()
+{
+ mPriv->iterateIntrospection();
+}
+
+}
+}
diff --git a/TelepathyQt4/Client/readiness-helper.h b/TelepathyQt4/Client/readiness-helper.h
new file mode 100644
index 0000000..49ad36c
--- /dev/null
+++ b/TelepathyQt4/Client/readiness-helper.h
@@ -0,0 +1,113 @@
+/*
+ * This file is part of TelepathyQt4
+ *
+ * Copyright (C) 2008 Collabora Ltd. <http://www.collabora.co.uk/>
+ * Copyright (C) 2008 Nokia Corporation
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _TelepathyQt4_cli_readiness_helper_h_HEADER_GUARD_
+#define _TelepathyQt4_cli_readiness_helper_h_HEADER_GUARD_
+
+#ifndef IN_TELEPATHY_QT4_HEADER
+#error IN_TELEPATHY_QT4_HEADER
+#endif
+
+#include <QMap>
+#include <QSet>
+#include <QStringList>
+
+namespace Telepathy
+{
+namespace Client
+{
+
+class PendingReady;
+
+class ReadinessHelper : public QObject
+{
+ Q_OBJECT
+
+public:
+ typedef void (*IntrospectFunc)(void *data);
+
+ struct Introspectable {
+ public:
+ Introspectable()
+ : introspectFunc(0),
+ introspectFuncData(0)
+ {
+ }
+
+ Introspectable(const QSet<uint> &makesSenseForStatuses,
+ const QSet<uint> &dependsOnFeatures,
+ const QStringList &dependsOnInterfaces,
+ IntrospectFunc introspectFunc,
+ void *introspectFuncData)
+ : makesSenseForStatuses(makesSenseForStatuses),
+ dependsOnFeatures(dependsOnFeatures),
+ dependsOnInterfaces(dependsOnInterfaces),
+ introspectFunc(introspectFunc),
+ introspectFuncData(introspectFuncData)
+ {
+ }
+
+ private:
+ friend class ReadinessHelper;
+
+ QSet<uint> makesSenseForStatuses;
+ QSet<uint> dependsOnFeatures;
+ QStringList dependsOnInterfaces;
+ IntrospectFunc introspectFunc;
+ void *introspectFuncData;
+ };
+
+ ReadinessHelper(uint currentStatus,
+ const QMap<uint, Introspectable> &introspectables,
+ QObject *parent = 0);
+ ~ReadinessHelper();
+
+ uint currentStatus() const;
+ void setCurrentStatus(uint currentStatus);
+
+ QStringList interfaces() const;
+ void setInterfaces(const QStringList &interfaces);
+
+ QSet<uint> requestedFeatures() const;
+ QSet<uint> actualFeatures() const;
+ QSet<uint> missingFeatures() const;
+
+ bool isReady(QSet<uint> features) const;
+ PendingReady *becomeReady(QSet<uint> requestedFeatures);
+
+ void setIntrospectCompleted(uint feature, bool success);
+
+Q_SIGNALS:
+ void statusReady(uint status);
+
+private Q_SLOTS:
+ void iterateIntrospection();
+
+private:
+ struct Private;
+ friend struct Private;
+ Private *mPriv;
+};
+
+} // Telepathy::Client
+} // Telepathy
+
+#endif
diff --git a/TelepathyQt4/Makefile.am b/TelepathyQt4/Makefile.am
index 74e1923..54ec1f0 100644
--- a/TelepathyQt4/Makefile.am
+++ b/TelepathyQt4/Makefile.am
@@ -58,6 +58,7 @@ libtelepathy_qt4_la_SOURCES = \
Client/pending-contacts.cpp \
Client/pending-handles.cpp \
Client/pending-operation.cpp \
+ Client/pending-ready.cpp \
Client/pending-ready-account.cpp \
Client/pending-ready-account-manager.cpp \
Client/pending-ready-channel.cpp \
@@ -65,6 +66,7 @@ libtelepathy_qt4_la_SOURCES = \
Client/pending-ready-connection-manager.cpp \
Client/pending-string-list.cpp \
Client/properties.cpp \
+ Client/readiness-helper.cpp \
Client/referenced-handles.cpp \
Client/room-list.cpp \
Client/streamed-media-channel.cpp \
@@ -115,12 +117,14 @@ nodist_libtelepathy_qt4_la_SOURCES = \
Client/_gen/pending-contacts.moc.hpp \
Client/_gen/pending-handles.moc.hpp \
Client/_gen/pending-operation.moc.hpp \
+ Client/_gen/pending-ready.moc.hpp \
Client/_gen/pending-ready-account.moc.hpp \
Client/_gen/pending-ready-account-manager.moc.hpp \
Client/_gen/pending-ready-channel.moc.hpp \
Client/_gen/pending-ready-connection.moc.hpp \
Client/_gen/pending-ready-connection-manager.moc.hpp \
Client/_gen/pending-string-list.moc.hpp \
+ Client/_gen/readiness-helper.moc.hpp \
Client/_gen/room-list.moc.hpp \
Client/_gen/simple-pending-operations.moc.hpp \
Client/_gen/streamed-media-channel.moc.hpp \
@@ -160,6 +164,7 @@ tpqt4clientinclude_HEADERS = \
Client/PendingContactAttributes \
Client/PendingFailure \
Client/PendingOperation \
+ Client/PendingReady \
Client/PendingReadyAccount \
Client/PendingReadyAccountManager \
Client/PendingReadyChannel \
@@ -169,6 +174,7 @@ tpqt4clientinclude_HEADERS = \
Client/PendingStringList \
Client/PendingVoidMethodCall \
Client/Properties \
+ Client/ReadinessHelper \
Client/ReferencedHandles \
Client/ReferencedHandlesIterator \
Client/RoomList \
@@ -228,6 +234,7 @@ tpqt4clientinclude_HEADERS = \
Client/pending-contacts.h \
Client/pending-handles.h \
Client/pending-operation.h \
+ Client/pending-ready.h \
Client/pending-ready-account.h \
Client/pending-ready-account-manager.h \
Client/pending-ready-channel.h \
@@ -235,6 +242,7 @@ tpqt4clientinclude_HEADERS = \
Client/pending-ready-connection-manager.h \
Client/pending-string-list.h \
Client/properties.h \
+ Client/readiness-helper.h \
Client/referenced-handles.h \
Client/room-list.h \
Client/simple-pending-operations.h \
--
1.5.6.5
More information about the telepathy-commits
mailing list