1 files changed, 555 insertions, 0 deletions
diff --git a/qt4/TelepathyQt4/channel-class-spec.cpp b/qt4/TelepathyQt4/channel-class-spec.cpp
new file mode 100644
index 000000000..9e91c8390
--- /dev/null
+++ b/qt4/TelepathyQt4/channel-class-spec.cpp
@@ -0,0 +1,555 @@
+/**
+ * This file is part of TelepathyQt4
+ *
+ * @copyright Copyright (C) 2010 Collabora Ltd. <http://www.collabora.co.uk/>
+ * @copyright Copyright (C) 2010 Nokia Corporation
+ * @license LGPL 2.1
+ *
+ * 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/ChannelClassSpec>
+
+#include "TelepathyQt4/_gen/future-constants.h"
+
+#include "TelepathyQt4/debug-internal.h"
+
+namespace Tp
+{
+
+struct TELEPATHY_QT4_NO_EXPORT ChannelClassSpec::Private : public QSharedData
+{
+    QVariantMap props;
+};
+
+/**
+ * \class ChannelClassSpec
+ * \ingroup wrappers
+ * \headerfile TelepathyQt4/channel-class-spec.h <TelepathyQt4/ChannelClassSpec>
+ *
+ * \brief The ChannelClassSpec class represents a Telepathy channel class.
+ */
+
+ChannelClassSpec::ChannelClassSpec()
+{
+}
+
+ChannelClassSpec::ChannelClassSpec(const ChannelClass &cc)
+    : mPriv(new Private)
+{
+    foreach (QString key, cc.keys()) {
+        setProperty(key, cc.value(key).variant());
+    }
+}
+
+ChannelClassSpec::ChannelClassSpec(const QVariantMap &props)
+    : mPriv(new Private)
+{
+    setChannelType(qdbus_cast<QString>(
+                props.value(TP_QT4_IFACE_CHANNEL + QLatin1String(".ChannelType"))));
+    setTargetHandleType((HandleType) qdbus_cast<uint>(
+                props.value(TP_QT4_IFACE_CHANNEL + QLatin1String(".TargetHandleType"))));
+
+    foreach (QString propName, props.keys()) {
+        setProperty(propName, props.value(propName));
+    }
+}
+
+ChannelClassSpec::ChannelClassSpec(const QString &channelType, HandleType targetHandleType,
+        const QVariantMap &otherProperties)
+    : mPriv(new Private)
+{
+    setChannelType(channelType);
+    setTargetHandleType(targetHandleType);
+    foreach (QString key, otherProperties.keys()) {
+        setProperty(key, otherProperties.value(key));
+    }
+}
+
+ChannelClassSpec::ChannelClassSpec(const QString &channelType, HandleType targetHandleType,
+        bool requested, const QVariantMap &otherProperties)
+    : mPriv(new Private)
+{
+    setChannelType(channelType);
+    setTargetHandleType(targetHandleType);
+    setRequested(requested);
+    foreach (QString key, otherProperties.keys()) {
+        setProperty(key, otherProperties.value(key));
+    }
+}
+
+ChannelClassSpec::ChannelClassSpec(const ChannelClassSpec &other,
+        const QVariantMap &additionalProperties)
+    : mPriv(other.mPriv)
+{
+    if (!additionalProperties.isEmpty()) {
+        foreach (QString key, additionalProperties.keys()) {
+            setProperty(key, additionalProperties.value(key));
+        }
+    }
+}
+
+ChannelClassSpec::~ChannelClassSpec()
+{
+}
+
+bool ChannelClassSpec::isValid() const
+{
+    return mPriv.constData() != 0 && 
+        !(qdbus_cast<QString>(
+                    mPriv->props.value(QLatin1String(TELEPATHY_INTERFACE_CHANNEL ".ChannelType")))
+                .isEmpty()) &&
+        mPriv->props.contains(QLatin1String(TELEPATHY_INTERFACE_CHANNEL ".TargetHandleType"));
+}
+
+ChannelClassSpec &ChannelClassSpec::operator=(const ChannelClassSpec &other)
+{
+    if (this == &other) {
+        return *this;
+    }
+
+    this->mPriv = other.mPriv;
+    return *this;
+}
+
+bool ChannelClassSpec::isSubsetOf(const ChannelClassSpec &other) const
+{
+    if (!mPriv) {
+        // Invalid instances have no properties - hence they're subset of anything
+        return true;
+    }
+
+    foreach (QString propName, mPriv->props.keys()) {
+        if (!other.hasProperty(propName)) {
+            return false;
+        } else if (property(propName) != other.property(propName)) {
+            return false;
+        }
+    }
+
+    // other had all of the properties we have and they all had the same values
+
+    return true;
+}
+
+bool ChannelClassSpec::matches(const QVariantMap &immutableProperties) const
+{
+    // We construct a ChannelClassSpec for comparison so the StreamedMedia props are normalized
+    // consistently etc
+    return this->isSubsetOf(ChannelClassSpec(immutableProperties));
+}
+
+bool ChannelClassSpec::hasProperty(const QString &qualifiedName) const
+{
+    return mPriv.constData() != 0 ? mPriv->props.contains(qualifiedName) : false;
+}
+
+QVariant ChannelClassSpec::property(const QString &qualifiedName) const
+{
+    return mPriv.constData() != 0 ? mPriv->props.value(qualifiedName) : QVariant();
+}
+
+void ChannelClassSpec::setProperty(const QString &qualifiedName, const QVariant &value)
+{
+    if (mPriv.constData() == 0) {
+        mPriv = new Private;
+    }
+
+    mPriv->props.insert(qualifiedName, value);
+}
+
+void ChannelClassSpec::unsetProperty(const QString &qualifiedName)
+{
+    if (mPriv.constData() == 0) {
+        // No properties set for sure, so don't have to unset any
+        return;
+    }
+
+    mPriv->props.remove(qualifiedName);
+}
+
+QVariantMap ChannelClassSpec::allProperties() const
+{
+    return mPriv.constData() != 0 ? mPriv->props : QVariantMap();
+}
+
+ChannelClass ChannelClassSpec::bareClass() const
+{
+    ChannelClass cc;
+
+    if (!isValid()) {
+        warning() << "Tried to convert an invalid ChannelClassSpec to a ChannelClass";
+        return ChannelClass();
+    }
+
+    QVariantMap props = mPriv->props;
+    foreach (QString propName, props.keys()) {
+        QVariant value = props.value(propName);
+
+        cc.insert(propName, QDBusVariant(value));
+    }
+
+    return cc;
+}
+
+ChannelClassSpec ChannelClassSpec::textChat(const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_TEXT),
+                HandleTypeContact);
+    }
+
+    if (additionalProperties.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, additionalProperties);
+    }
+}
+
+ChannelClassSpec ChannelClassSpec::textChatroom(const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_TEXT),
+                HandleTypeRoom);
+    }
+
+    if (additionalProperties.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, additionalProperties);
+    }
+}
+
+ChannelClassSpec ChannelClassSpec::unnamedTextChat(const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_TEXT),
+                HandleTypeNone);
+    }
+
+    if (additionalProperties.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, additionalProperties);
+    }
+}
+
+ChannelClassSpec ChannelClassSpec::streamedMediaCall(const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_STREAMED_MEDIA),
+                HandleTypeContact);
+    }
+
+    if (additionalProperties.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, additionalProperties);
+    }
+}
+
+ChannelClassSpec ChannelClassSpec::streamedMediaAudioCall(const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_STREAMED_MEDIA),
+                HandleTypeContact);
+        spec.setStreamedMediaInitialAudioFlag();
+    }
+
+    if (additionalProperties.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, additionalProperties);
+    }
+}
+
+ChannelClassSpec ChannelClassSpec::streamedMediaVideoCall(const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_STREAMED_MEDIA),
+                HandleTypeContact);
+        spec.setStreamedMediaInitialVideoFlag();
+    }
+
+    if (additionalProperties.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, additionalProperties);
+    }
+}
+
+ChannelClassSpec ChannelClassSpec::streamedMediaVideoCallWithAudio(const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_STREAMED_MEDIA),
+                HandleTypeContact);
+        spec.setStreamedMediaInitialAudioFlag();
+        spec.setStreamedMediaInitialVideoFlag();
+    }
+
+    if (additionalProperties.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, additionalProperties);
+    }
+}
+
+ChannelClassSpec ChannelClassSpec::unnamedStreamedMediaCall(const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_STREAMED_MEDIA),
+                HandleTypeNone);
+    }
+
+    if (additionalProperties.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, additionalProperties);
+    }
+}
+
+ChannelClassSpec ChannelClassSpec::unnamedStreamedMediaAudioCall(const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_STREAMED_MEDIA),
+                HandleTypeNone);
+        spec.setStreamedMediaInitialAudioFlag();
+    }
+
+    if (additionalProperties.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, additionalProperties);
+    }
+}
+
+ChannelClassSpec ChannelClassSpec::unnamedStreamedMediaVideoCall(const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_STREAMED_MEDIA),
+                HandleTypeNone);
+        spec.setStreamedMediaInitialVideoFlag();
+    }
+
+    if (additionalProperties.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, additionalProperties);
+    }
+}
+
+ChannelClassSpec ChannelClassSpec::unnamedStreamedMediaVideoCallWithAudio(const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_STREAMED_MEDIA),
+                HandleTypeNone);
+        spec.setStreamedMediaInitialAudioFlag();
+        spec.setStreamedMediaInitialVideoFlag();
+    }
+
+    if (additionalProperties.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, additionalProperties);
+    }
+}
+
+ChannelClassSpec ChannelClassSpec::roomList(const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_ROOM_LIST),
+                HandleTypeNone);
+    }
+
+    if (additionalProperties.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, additionalProperties);
+    }
+}
+
+ChannelClassSpec ChannelClassSpec::outgoingFileTransfer(const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_FILE_TRANSFER),
+                HandleTypeContact, true);
+    }
+
+    if (additionalProperties.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, additionalProperties);
+    }
+}
+
+ChannelClassSpec ChannelClassSpec::incomingFileTransfer(const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_FILE_TRANSFER),
+                HandleTypeContact, false);
+    }
+
+    if (additionalProperties.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, additionalProperties);
+    }
+}
+
+ChannelClassSpec ChannelClassSpec::outgoingStreamTube(const QString &service,
+                                                      const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_STREAM_TUBE),
+                HandleTypeContact, true);
+    }
+
+    QVariantMap props = additionalProperties;
+    if (!service.isEmpty()) {
+        props.insert(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_STREAM_TUBE ".Service"),
+                service);
+    }
+
+    if (props.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, props);
+    }
+}
+
+ChannelClassSpec ChannelClassSpec::incomingStreamTube(const QString &service,
+                                                      const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_STREAM_TUBE),
+                HandleTypeContact, false);
+    }
+
+    QVariantMap props = additionalProperties;
+    if (!service.isEmpty()) {
+        props.insert(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_STREAM_TUBE ".Service"),
+                service);
+    }
+
+    if (props.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, props);
+    }
+}
+
+ChannelClassSpec ChannelClassSpec::outgoingRoomStreamTube(const QString &service,
+                                                          const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_STREAM_TUBE),
+                HandleTypeRoom, true);
+    }
+
+    QVariantMap props = additionalProperties;
+    if (!service.isEmpty()) {
+        props.insert(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_STREAM_TUBE ".Service"),
+                service);
+    }
+
+    if (props.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, props);
+    }
+}
+
+ChannelClassSpec ChannelClassSpec::incomingRoomStreamTube(const QString &service,
+                                                          const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_STREAM_TUBE),
+                HandleTypeRoom, false);
+    }
+
+    QVariantMap props = additionalProperties;
+    if (!service.isEmpty()) {
+        props.insert(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_STREAM_TUBE ".Service"),
+                service);
+    }
+
+    if (props.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, props);
+    }
+}
+
+ChannelClassSpec ChannelClassSpec::contactSearch(const QVariantMap &additionalProperties)
+{
+    static ChannelClassSpec spec;
+
+    if (!spec.mPriv.constData()) {
+        spec = ChannelClassSpec(QLatin1String(TELEPATHY_INTERFACE_CHANNEL_TYPE_CONTACT_SEARCH),
+                HandleTypeNone);
+    }
+
+    if (additionalProperties.isEmpty()) {
+        return spec;
+    } else {
+        return ChannelClassSpec(spec, additionalProperties);
+    }
+}
+
+/**
+ * \class ChannelClassSpecList
+ * \ingroup wrappers
+ * \headerfile TelepathyQt4/channel-class-spec.h <TelepathyQt4/ChannelClassSpecList>
+ *
+ * \brief The ChannelClassSpecList class represents a list of ChannelClassSpec.
+ */
+
+} // Tp