diff -r cfcbf08528c4 -r 2b40d63a9c3d qtmobility/src/serviceframework/qserviceinterfacedescriptor.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/qtmobility/src/serviceframework/qserviceinterfacedescriptor.cpp	Fri Apr 16 15:51:22 2010 +0300
@@ -0,0 +1,397 @@
+/****************************************************************************
+**
+** 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 Qt Mobility Components.
+**
+** $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 "qserviceinterfacedescriptor_p.h"
+#ifndef QT_NO_DATASTREAM
+#include <qdatastream.h>
+#endif
+
+#include <QDebug>
+#include <QStringList>
+
+QTM_BEGIN_NAMESPACE
+
+/*!
+    \class QServiceInterfaceDescriptor
+    \ingroup servicefw
+    \brief The QServiceInterfaceDescriptor class identifies a service implementation.
+
+    A service can implement multiple interfaces and each interface can have multiple implementations. 
+    The QServiceInterfaceDescriptor class enscapsulates this information, as illustrated
+    by the diagram below.
+
+    \image qserviceinterfacedescriptor.png Service-Interface-Implementation
+
+    The major version tag indicates the interface version and the minor version tag identifies the implementation
+    version. Subsequent versions of the same interface must be binary compatible to previous versions 
+    of the same interface. 
+
+    In the above example service A and B implement the interface \i com.nokia.qt.x.
+    In fact Service A provides two different implementations for the very same interface. 
+    This is indicated by the changed minor version number. Although Service B is 
+    using the same interface it's implementation actually utilizes the second version of
+    the interface \i com.nokia.qt.x. Binary compatibility guarantees that clients 
+    who know version 1 can utilize version 2. If an existing interface has to be changed
+    in a non-compatible way a new interface (name) is required.
+
+    \section1 Namespaces
+
+    A QServiceInterfaceDescriptor (the quadruble of service name, 
+    interface name, interface version and implementation version) uniquely 
+    identifies a service implementation on a device. Interface names follow 
+    the java namespace convention.
+    
+    The namespace \i com.nokia.qt.* is reserved for future Qt development.
+
+    \sa QServiceFilter, QServiceManager
+*/
+
+/*!
+    \enum QServiceInterfaceDescriptor::Attribute
+
+    This enum describes the possible attribute types which can be attached
+    to a QServiceInterfaceDescriptor.
+
+    \value      Capabilities            The capabilities attribute is a QStringList and
+                                        describes the capabilities that a service client
+                                        would require to use the service if capability 
+                                        checks are enforced.
+    \value      Location                This attribute points to the location
+                                        where the plug-in providing this service is stored.
+                                        If the service is plug-in based the location is the
+                                        name and/or path of the plugin.
+    \value      ServiceDescription      This attribute provides a general description for
+                                        the service.
+    \value      InterfaceDescription    This attribute provides a description for the interface 
+                                        implementation.
+*/
+
+/*!
+    Creates a new QServiceInterfaceDescriptor.
+*/
+QServiceInterfaceDescriptor::QServiceInterfaceDescriptor()
+    :  d(0)
+{
+}
+
+/*!
+    Destroys the QServiceInterfaceDescriptor object.
+*/
+QServiceInterfaceDescriptor::~QServiceInterfaceDescriptor()
+{
+    if (d)
+        delete d;
+}
+
+/*!
+    Creates a copy of QServiceInterfaceDescriptor contained in \a other.
+*/
+QServiceInterfaceDescriptor::QServiceInterfaceDescriptor(const QServiceInterfaceDescriptor& other)
+    : d(0)
+{
+    (*this) = other; //use assignment operator
+}
+
+/*!
+    \fn  QServiceInterfaceDescriptor& QServiceInterfaceDescriptor::operator=(const QServiceInterfaceDescriptor& other)
+    
+    Copies the content of the QServiceInterfaceDescriptor object contained 
+    in \a other into this one.
+*/
+QServiceInterfaceDescriptor& QServiceInterfaceDescriptor::operator=(const QServiceInterfaceDescriptor& other)
+{
+    if ( !other.isValid() ) {
+        if (d) 
+            delete d;
+        d = 0;
+        return *this;
+    }
+
+    if (!d)
+        d = new QServiceInterfaceDescriptorPrivate;
+
+    (*d) = *(other.d);
+    return *this;
+}
+
+/*!
+    \fn bool QServiceInterfaceDescriptor::operator==(const QServiceInterfaceDescriptor& other) const
+    
+    Compares a QServiceInterfaceDescriptor to \a other. Returns true if they 
+    are equal and false otherwise.
+*/
+bool QServiceInterfaceDescriptor::operator==(const QServiceInterfaceDescriptor& other) const
+{
+    if (isValid() ^ other.isValid())
+        return false;
+
+    if (!d)
+        return true;
+
+    if ((*d) == *(other.d))
+        return true;
+    return false;
+}
+
+/*!
+    \fn bool QServiceInterfaceDescriptor::operator!=(const QServiceInterfaceDescriptor& other) const
+
+    Compares a QServiceInterfaceDescriptor to \a other. Returns true
+    if they are not equal and false otherwise.
+*/
+
+/*!
+    \fn bool QServiceInterfaceDescriptor::isValid() const
+    
+    Returns true if this descriptor is valid; otherwise returns false.
+*/
+bool QServiceInterfaceDescriptor::isValid() const
+{
+    return d ? true : false;
+}
+
+/*!
+    \fn  bool QServiceInterfaceDescriptor::scope() const
+    
+    Returns true if this implementation is provided for all users on the system.
+
+    \sa QService::Scope
+*/
+QService::Scope QServiceInterfaceDescriptor::scope() const
+{
+    return d ? d->scope : QService::UserScope;
+}
+
+/*!
+    \fn  QString QServiceInterfaceDescriptor::serviceName() const
+    
+    Returns the name of service that provides this implementation.
+*/
+QString QServiceInterfaceDescriptor::serviceName() const
+{
+    return d ? d->serviceName : QString();
+}
+
+/*!
+    \fn  QString QServiceInterfaceDescriptor::interfaceName() const
+    
+    Returns the name of the interface that is implemented.
+*/
+QString QServiceInterfaceDescriptor::interfaceName() const
+{
+    return d ? d->interfaceName : QString();
+}
+
+/*!
+    \fn  int QServiceInterfaceDescriptor::majorVersion() const
+    
+    Returns the version of the interface. 
+    
+    Subsequent versions of an interface are binary compatible 
+    to previous versions of the same interface. If an interface
+    is broken it must use a new interface name.
+*/
+int QServiceInterfaceDescriptor::majorVersion() const
+{
+    return d ? d->major : -1;
+}
+
+/*!
+    \fn  int QServiceInterfaceDescriptor::minorVersion() const
+    
+    Returns the version of the implementation. 
+*/
+int QServiceInterfaceDescriptor::minorVersion() const
+{
+    return d ? d->minor : -1;
+}
+
+/*!
+    \fn  QVariant QServiceInterfaceDescriptor::attribute(QServiceInterfaceDescriptor::Attribute which) const
+    
+    Returns the value for the attribute \a which; otherwise returns 
+    an invalid QVariant.
+*/
+QVariant QServiceInterfaceDescriptor::attribute(QServiceInterfaceDescriptor::Attribute which) const
+{
+    if (d)
+        return d->attributes.value(which);
+    return QVariant();
+}
+
+/*!
+    \fn  QString QServiceInterfaceDescriptor::customAttribute(const QString& which) const
+    
+    Returns the value for the custom attribute \a which; otherwise 
+    returns a null string.
+*/
+QString QServiceInterfaceDescriptor::customAttribute(const QString& which) const
+{
+    if (d)
+        return d->customAttributes[which];
+    return QString();
+}
+
+/*!
+  Returns a list of custom attributes attached to the service.
+ */
+QStringList QServiceInterfaceDescriptor::customAttributes() const
+{
+    if (d)
+        return d->customAttributes.keys();
+    return QStringList();
+}
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug dbg, const QServiceInterfaceDescriptor &desc)
+{
+    if (desc.isValid()) {
+        QString interface = QString("%1 %2.%3").arg(desc.interfaceName())
+                .arg(desc.majorVersion() < 0 ? '?' : desc.majorVersion())
+                .arg(desc.minorVersion() < 0 ? '?' : desc.minorVersion());
+        dbg.nospace() << "QServiceInterfaceDescriptor(";
+        dbg.nospace() << "service=" << desc.serviceName() << ", ";
+        dbg.nospace() << "interface=" << interface;
+        dbg.nospace() << ")";
+    } else {
+        dbg.nospace() << "QServiceInterfaceDescriptor(invalid)";
+    }
+    return dbg.space();
+}
+#endif
+
+#ifndef QT_NO_DATASTREAM
+
+QDataStream &operator<<(QDataStream &out, const QServiceInterfaceDescriptor::Attribute &k)
+{
+    out << qint8(k);
+    return out;
+}
+
+QDataStream &operator>>(QDataStream &in, QServiceInterfaceDescriptor::Attribute &k)
+{
+    quint8 key;
+    in >> key;
+    k = (QServiceInterfaceDescriptor::Attribute)key;
+    return in;
+}
+/*! 
+    \fn QDataStream &operator<<(QDataStream &out, const QServiceInterfaceDescriptor &dc)
+    \relates QServiceInterfaceDescriptor
+
+    Writes service interface descriptor \a dc to the stream \a out and returns a reference
+    to the stream.
+*/
+
+QDataStream &operator<<(QDataStream &out, const QServiceInterfaceDescriptor &dc)
+{
+    const quint32 magicNumber = 0x77AFAFA;
+    const quint16 majorVersion = 1;
+    const quint16 minorVersion = 0;
+    const qint8 valid = dc.isValid();
+    out << magicNumber << majorVersion << minorVersion;
+    out << valid;
+    if (valid) {
+       out << dc.d->serviceName; 
+       out << dc.d->interfaceName;
+       out << dc.d->major;
+       out << dc.d->minor;
+       out << dc.d->attributes;
+       out << dc.d->customAttributes;
+       out << (qint8)dc.d->scope;
+    }
+    return out;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &in, QServiceInterfaceDescriptor &dc)
+    \relates QServiceInterfaceDescriptor
+
+    Reads a service interface descriptor into \a dc from the stream \a in and returns a
+    reference to the stream.
+*/
+QDataStream &operator>>(QDataStream &in, QServiceInterfaceDescriptor &dc)
+{
+    const quint32 magicNumber = 0x77AFAFA;
+    quint32 storedMagicNumber;
+    in >> storedMagicNumber;
+    if (storedMagicNumber != magicNumber) {
+        qWarning() << "Datastream doesn't provide searialized QServiceInterfaceDescriptor";
+        return in;
+    }
+    
+    const quint16 currentMajorVersion = 1;
+    quint16 majorVersion = 0;
+    quint16 minorVersion = 0;
+
+    in >> majorVersion >> minorVersion;
+    if (majorVersion != currentMajorVersion) {
+        qWarning() << "Unknown serialization format for QServiceInterfaceDescriptor.";
+        return in;
+    }
+    //Allow all minor versions.
+
+    qint8 valid;
+    in >> valid;
+    if (valid) {
+        if (!dc.isValid())
+            dc.d = new QServiceInterfaceDescriptorPrivate;
+        in >> dc.d->serviceName;
+        in >> dc.d->interfaceName;
+        in >> dc.d->major;
+        in >> dc.d->minor;
+        in >> dc.d->attributes;
+        in >> dc.d->customAttributes;
+        in >> valid;
+        dc.d->scope = (QService::Scope) valid;
+    } else { //input stream contains invalid descriptor
+        //use assignment operator
+        dc = QServiceInterfaceDescriptor();
+    }
+
+    return in;
+}
+#endif //QT_NO_DATASTREAM
+
+
+
+QTM_END_NAMESPACE
+