diff -r 885c2596c964 -r 5d007b20cfd0 qthighway/xqserviceutil/src/xqservicemetadata/xqaiwinterfacedescriptor.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/qthighway/xqserviceutil/src/xqservicemetadata/xqaiwinterfacedescriptor.cpp	Tue Aug 31 16:02:37 2010 +0300
@@ -0,0 +1,455 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+*
+* This program 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, version 2.1 of the License.
+* 
+* This program 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 program.  If not, 
+* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".
+*
+* Description:
+*
+*/
+
+#include "xqservicelog.h"
+#include <xqaiwinterfacedescriptor_p.h>
+#include <xqaiwinterfacedescriptor.h>
+#ifndef QT_NO_DATASTREAM
+#include <qdatastream.h>
+#endif
+
+#include <QDebug>
+
+//QT_BEGIN_NAMESPACE
+
+/*!
+    \class XQAiwInterfaceDescriptor
+    \brief The XQAiwInterfaceDescriptor class identifies a service implementation.
+
+    A service can implement multiple interfaces and each interface can have multiple implementations. 
+    The XQAiwInterfaceDescriptor class enscapsulates this information, as illustrated
+    by the diagram below.
+
+    \image XQAiwInterfaceDescriptor.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 XQAiwInterfaceDescriptor (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 XQAiwInterfaceDescriptor::PropertyKey
+
+    This enum describes the possible property types which can be attached
+    to a XQAiwInterfaceDescriptor.
+*/
+
+/*! \var XQAiwInterfaceDescriptor::PropertyKey  XQAiwInterfaceDescriptor::Capabilities
+    
+    The capabilities property is a QStringList and
+    describes the capabilities that a service client
+    would require to use the service if capability 
+    checks are enforced.
+*/
+
+/*! \var XQAiwInterfaceDescriptor::PropertyKey  XQAiwInterfaceDescriptor::Location
+    
+    This property 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.
+*/
+
+/*! \var XQAiwInterfaceDescriptor::PropertyKey  XQAiwInterfaceDescriptor::ServiceDescription
+    
+    This property provides a general description for
+    the service.
+*/
+
+/*! \var XQAiwInterfaceDescriptor::PropertyKey  XQAiwInterfaceDescriptor::InterfaceDescription
+    
+    This property provides a description for the interface 
+    implementation.
+*/
+
+/*! \var XQAiwInterfaceDescriptor::PropertyKey  XQAiwInterfaceDescriptor::ImplementationId
+
+    Extension: settable property, contains implementation id
+*/
+
+/*!
+    Creates a new XQAiwInterfaceDescriptor.
+*/
+XQAiwInterfaceDescriptor::XQAiwInterfaceDescriptor()
+    :  d(0)
+{
+  XQSERVICE_DEBUG_PRINT("XQAiwInterfaceDescriptor");
+  // Memory allocated in assigment operator !!!
+}
+
+/*!
+    Destroys the XQAiwInterfaceDescriptor object.
+*/
+XQAiwInterfaceDescriptor::~XQAiwInterfaceDescriptor()
+{
+    XQSERVICE_DEBUG_PRINT("~XQAiwInterfaceDescriptor");
+    if (d)
+        delete d;
+}
+
+/*!
+    Creates a copy of XQAiwInterfaceDescriptor contained in \a other.
+    \param other Reference to the other XQAiwInterfaceDescriptor object, from
+                 which new object will be created
+*/
+XQAiwInterfaceDescriptor::XQAiwInterfaceDescriptor(const XQAiwInterfaceDescriptor& other)
+    : d(0)
+{
+    (*this) = other; //use assignment operator
+}
+
+
+/*!
+    Copies the content of the XQAiwInterfaceDescriptor object contained 
+    in \a other into this one.
+    \param other Reference to XQAiwInterfaceDescriptor object, from which content will be copied
+*/
+XQAiwInterfaceDescriptor& XQAiwInterfaceDescriptor::operator=(const XQAiwInterfaceDescriptor& other)
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwInterfaceDescriptor: operator=");
+    if ( !other.isValid() ) {
+        XQSERVICE_DEBUG_PRINT("other is invalid !!!");
+        if (d) 
+            delete d;
+        d = 0;
+        return *this;  // Create empty descriptor
+    }
+    if (!d)
+        d = new XQAiwInterfaceDescriptorPrivate;
+    (*d) = *(other.d);
+    XQSERVICE_DEBUG_PRINT("XQAiwInterfaceDescriptor: operator= done");
+    return *this;
+}
+
+/*!
+    Compares a XQAiwInterfaceDescriptor to \a other.
+    \param other Reference to XQAiwInterfaceDescriptor object, which will be compared
+                 to this one.
+    \return True if both instances are equal, false otherwise.
+*/
+bool XQAiwInterfaceDescriptor::operator==(const XQAiwInterfaceDescriptor& other) const
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwInterfaceDescriptor: operator==");
+    
+    if (! (isValid() && other.isValid()) )
+        return false;
+
+    if (!d)
+        return false;
+
+    if ((*d) == *(other.d))
+    {
+        XQSERVICE_DEBUG_PRINT("== true");
+        return true;
+    }
+    
+    XQSERVICE_DEBUG_PRINT("== false");
+    return false;
+}
+
+/*!
+    \fn bool XQAiwInterfaceDescriptor::operator!=(const XQAiwInterfaceDescriptor& other) const
+
+    Compares a XQAiwInterfaceDescriptor to \a other. Returns true
+    if they are not equal and false otherwise.
+    \param other Reference to XQAiwInterfaceDescriptor object, which will be compared
+                 to this one.
+    \return False if both instances are equal, true otherwise.
+*/
+
+/*!
+    Checks if the descriptor is valid.
+    \return True if this descriptor is valid, false otherwise
+*/
+bool XQAiwInterfaceDescriptor::isValid() const
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwInterfaceDescriptor:isValid");
+    if (d)
+    {
+        XQSERVICE_DEBUG_PRINT("isValid=yes");
+        return true;
+    }
+    XQSERVICE_DEBUG_PRINT("isValid=false");
+    return false;
+}
+
+/*!
+    Checks if this implementation is provided for all users on the system.
+    \return True if this implementation is provided for all users on the system,
+            false otherwise
+
+    \sa QServiceManager::Scope
+*/
+bool XQAiwInterfaceDescriptor::inSystemScope() const
+{
+    return d ? d->systemScope : false;
+}
+
+/*!
+    Gets the name of service that provides this implementation.
+    \return Name of service
+*/
+QString XQAiwInterfaceDescriptor::serviceName() const
+{
+    return d ? d->serviceName : QString();
+}
+
+/*!
+    Gets the name of the interface that is implemented.
+    \return Name of the interface
+*/
+QString XQAiwInterfaceDescriptor::interfaceName() const
+{
+    return d ? d->interfaceName : QString();
+}
+
+
+/*!
+    Gets the version of the interface. 
+    Subsequent versions of an interface are binary compatible 
+    to previous versions of the same interface. If an intcerface 
+    is broken it must use a new interface name.
+    \return Interface version as integer value
+*/
+int XQAiwInterfaceDescriptor::majorVersion() const
+{
+    return d ? d->major : -1;
+}
+
+/*!
+    Gets the version of the implementation.
+    \return Implementation version as integer value
+*/
+int XQAiwInterfaceDescriptor::minorVersion() const
+{
+    return d ? d->minor : -1;
+}
+
+/*!
+    Gets the value for the property.
+    \param key Key of the property
+    \return Value of the property, invalid QVariant if does not exist
+*/
+QVariant XQAiwInterfaceDescriptor::property(XQAiwInterfaceDescriptor::PropertyKey key) const
+{
+    if (d)
+    {
+        return d->properties.value(key);
+    }
+    return QVariant();
+}
+
+/*!
+    Extension:
+    Sets given property. To be used by service management only.
+*/
+bool XQAiwInterfaceDescriptor::setProperty(XQAiwInterfaceDescriptor::PropertyKey key, const QVariant value )
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwInterfaceDescriptor::setPropery %d", key);
+    if (key < ImplementationId)
+    {
+        return false;  // Do not allow changing other properties
+    }
+    
+    if (!d)
+        d = new XQAiwInterfaceDescriptorPrivate;  // Ensure allocation
+    
+    if (d)
+    {
+        d->properties[key] = value;
+        return true;
+    }
+    return false;
+}
+
+
+/*!
+    Gets the value for the property.
+    \param key Key of the custom property
+    \return Value of the custom property, invalid null if does not exist
+*/
+QString XQAiwInterfaceDescriptor::customProperty(const QString& key) const
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwInterfaceDescriptor::customProperty %s", qPrintable(key));
+    QString val;
+    if (d)
+    {
+        val = d->customProperties[key];
+    }
+    XQSERVICE_DEBUG_PRINT("XQAiwInterfaceDescriptor::customProperty value %s", qPrintable(val));
+    
+    return val;
+}
+
+/*!
+    Gets list of custom property keys.
+    \return list of custom property keys
+*/
+QStringList XQAiwInterfaceDescriptor::customPropertyKeys() const
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwInterfaceDescriptor::customPropertyKeys");
+    if (d)
+    {
+        return d->customProperties.keys();
+    }
+
+    return QStringList();
+}
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug dbg, const XQAiwInterfaceDescriptor &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() << "XQAiwInterfaceDescriptor(";
+        dbg.nospace() << "service=" << desc.serviceName() << ", ";
+        dbg.nospace() << "interface=" << interface;
+        dbg.nospace() << ")";
+    } else {
+        dbg.nospace() << "XQAiwInterfaceDescriptor(invalid)";
+    }
+    return dbg.space();
+}
+#endif
+
+#ifndef QT_NO_DATASTREAM
+
+QDataStream &operator<<(QDataStream &out, const XQAiwInterfaceDescriptor::PropertyKey &k)
+{
+    out << qint8(k);
+    return out;
+}
+
+QDataStream &operator>>(QDataStream &in, XQAiwInterfaceDescriptor::PropertyKey &k)
+{
+    quint8 key;
+    in >> key;
+    k = (XQAiwInterfaceDescriptor::PropertyKey)key;
+    return in;
+}
+/*! 
+    \fn QDataStream &operator<<(QDataStream &out, const XQAiwInterfaceDescriptor &dc)
+    \relates XQAiwInterfaceDescriptor
+
+    Writes service interface descriptor \a dc to the stream \a out and returns a reference
+    to the stream.
+    \param out Stream to write to
+    \param dc Interface descriptor written to stream
+    \return Reference to the stream
+*/
+
+QDataStream &operator<<(QDataStream &out, const XQAiwInterfaceDescriptor &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->properties;
+       out << dc.d->customProperties;
+       out << dc.d->systemScope;
+    }
+    return out;
+}
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &in, XQAiwInterfaceDescriptor &dc)
+    \relates XQAiwInterfaceDescriptor
+
+    Reads a service interface descriptor into \a dc from the stream \a in and returns a
+    reference to the stream.
+    \param in Stream to read from
+    \param dc Interface descriptor read from stream
+    \return Reference to the stream
+*/
+QDataStream &operator>>(QDataStream &in, XQAiwInterfaceDescriptor &dc)
+{
+    const quint32 magicNumber = 0x77AFAFA;
+    quint32 storedMagicNumber;
+    in >> storedMagicNumber;
+    if (storedMagicNumber != magicNumber) {
+        qWarning() << "Datastream doesn't provide searialized XQAiwInterfaceDescriptor";
+        return in;
+    }
+    
+    const quint16 currentMajorVersion = 1;
+    quint16 majorVersion = 0;
+    quint16 minorVersion = 0;
+
+    in >> majorVersion >> minorVersion;
+    if (majorVersion != currentMajorVersion) {
+        qWarning() << "Unknown serialization format for XQAiwInterfaceDescriptor.";
+        return in;
+    }
+    //Allow all minor versions.
+
+    qint8 valid;
+    in >> valid;
+    if (valid) {
+        if (!dc.isValid())
+            dc.d = new XQAiwInterfaceDescriptorPrivate;
+        in >> dc.d->serviceName;
+        in >> dc.d->interfaceName;
+        in >> dc.d->major;
+        in >> dc.d->minor;
+        in >> dc.d->properties;
+        in >> dc.d->customProperties;
+        in >> dc.d->systemScope;
+    } else { //input stream contains invalid descriptor
+        //use assignment operator
+        dc = XQAiwInterfaceDescriptor();
+    }
+
+    return in;
+}
+#endif //QT_NO_DATASTREAM
+
+
+
+//QT_END_NAMESPACE
+