/****************************************************************************

**

** Copyright (C) 2010 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$

**

****************************************************************************/

#ifndef QDBUSARGUMENT_H

#define QDBUSARGUMENT_H

#include <QtCore/qbytearray.h>

#include <QtCore/qhash.h>

#include <QtCore/qglobal.h>

#include <QtCore/qlist.h>

#include <QtCore/qmap.h>

#include <QtCore/qstring.h>

#include <QtCore/qstringlist.h>

#include <QtCore/qvariant.h>

#include <QtDBus/qdbusextratypes.h>

#include <QtDBus/qdbusmacros.h>

#ifndef QT_NO_DBUS

QT_BEGIN_HEADER

QT_BEGIN_NAMESPACE

QT_MODULE(DBus)

class QDBusArgumentPrivate;

class QDBusDemarshaller;

class QDBusMarshaller;

{

public:

    enum ElementType {

        BasicType,

        VariantType,

        ArrayType,

        StructureType,

        MapType,

        MapEntryType,

        UnknownType = -1

    };

    QDBusArgument();

    QDBusArgument(const QDBusArgument &other);

    QDBusArgument &operator=(const QDBusArgument &other);

    ~QDBusArgument();

    // used for marshalling (Qt -> D-BUS)

    QDBusArgument &operator<<(uchar arg);

    QDBusArgument &operator<<(bool arg);

    QDBusArgument &operator<<(short arg);

    QDBusArgument &operator<<(ushort arg);

    QDBusArgument &operator<<(int arg);

    QDBusArgument &operator<<(uint arg);

    QDBusArgument &operator<<(qlonglong arg);

    QDBusArgument &operator<<(qulonglong arg);

    QDBusArgument &operator<<(double arg);

    QDBusArgument &operator<<(const QString &arg);

    QDBusArgument &operator<<(const QDBusVariant &arg);

    QDBusArgument &operator<<(const QDBusObjectPath &arg);

    QDBusArgument &operator<<(const QDBusSignature &arg);

    QDBusArgument &operator<<(const QStringList &arg);

    QDBusArgument &operator<<(const QByteArray &arg);

    void beginStructure();

    void endStructure();

    void beginArray(int elementMetaTypeId);

    void endArray();

    void beginMap(int keyMetaTypeId, int valueMetaTypeId);

    void endMap();

    void beginMapEntry();

    void endMapEntry();

    void appendVariant(const QVariant &v);

    // used for de-marshalling (D-BUS -> Qt)

    QString currentSignature() const;

    ElementType currentType() const;

    const QDBusArgument &operator>>(uchar &arg) const;

    const QDBusArgument &operator>>(bool &arg) const;

    const QDBusArgument &operator>>(short &arg) const;

    const QDBusArgument &operator>>(ushort &arg) const;

    const QDBusArgument &operator>>(int &arg) const;

    const QDBusArgument &operator>>(uint &arg) const;

    const QDBusArgument &operator>>(qlonglong &arg) const;

    const QDBusArgument &operator>>(qulonglong &arg) const;

    const QDBusArgument &operator>>(double &arg) const;

    const QDBusArgument &operator>>(QString &arg) const;

    const QDBusArgument &operator>>(QDBusVariant &arg) const;

    const QDBusArgument &operator>>(QDBusObjectPath &arg) const;

    const QDBusArgument &operator>>(QDBusSignature &arg) const;

    const QDBusArgument &operator>>(QStringList &arg) const;

    const QDBusArgument &operator>>(QByteArray &arg) const;

    void beginStructure() const;

    void endStructure() const;

    void beginArray() const;

    void endArray() const;

    void beginMap() const;

    void endMap() const;

    void beginMapEntry() const;

    void endMapEntry() const;

    bool atEnd() const;

    QVariant asVariant() const;

protected:

    QDBusArgument(QDBusArgumentPrivate *d);

    friend class QDBusArgumentPrivate;

    mutable QDBusArgumentPrivate *d;

};

template<typename T> inline T qdbus_cast(const QDBusArgument &arg

#ifndef Q_QDOC

, T * = 0

#endif

    )

{

    T item;

    arg >> item;

    return item;

}

template<typename T> inline T qdbus_cast(const QVariant &v

#ifndef Q_QDOC

, T * = 0

#endif

    )

{

    int id = v.userType();

    if (id == qMetaTypeId<QDBusArgument>())

        return qdbus_cast<T>(qvariant_cast<QDBusArgument>(v));

    else

        return qvariant_cast<T>(v);

}

// specialise for QVariant, allowing it to be used in place of QDBusVariant

template<> inline QVariant qdbus_cast<QVariant>(const QDBusArgument &arg, QVariant *)

{

    QDBusVariant item;

    arg >> item;

    return item.variant();

}

template<> inline QVariant qdbus_cast<QVariant>(const QVariant &v, QVariant *)

{

    return qdbus_cast<QDBusVariant>(v).variant();

}

// QVariant types

#ifndef QDBUS_NO_SPECIALTYPES

#endif

template<template <typename> class Container, typename T>

inline QDBusArgument &operator<<(QDBusArgument &arg, const Container<T> &list)

{

    int id = qMetaTypeId<T>();

    arg.beginArray(id);

    typename Container<T>::const_iterator it = list.begin();

    typename Container<T>::const_iterator end = list.end();

    for ( ; it != end; ++it)

        arg << *it;

    arg.endArray();

    return arg;

}

template<template <typename> class Container, typename T>

inline const QDBusArgument &operator>>(const QDBusArgument &arg, Container<T> &list)

{

    arg.beginArray();

    list.clear();

    while (!arg.atEnd()) {

        T item;

        arg >> item;

        list.push_back(item);

    }

    arg.endArray();

    return arg;

}

// QList specializations

template<typename T>

inline QDBusArgument &operator<<(QDBusArgument &arg, const QList<T> &list)

{

    int id = qMetaTypeId<T>();

    arg.beginArray(id);

    typename QList<T>::ConstIterator it = list.constBegin();

    typename QList<T>::ConstIterator end = list.constEnd();

    for ( ; it != end; ++it)

        arg << *it;

    arg.endArray();

    return arg;

}

template<typename T>

inline const QDBusArgument &operator>>(const QDBusArgument &arg, QList<T> &list)

{

    arg.beginArray();

    list.clear();

    while (!arg.atEnd()) {

        T item;

        arg >> item;

        list.push_back(item);

    }

    arg.endArray();

    return arg;

}

inline QDBusArgument &operator<<(QDBusArgument &arg, const QVariantList &list)

{

    int id = qMetaTypeId<QDBusVariant>();

    arg.beginArray(id);

    QVariantList::ConstIterator it = list.constBegin();

    QVariantList::ConstIterator end = list.constEnd();

    for ( ; it != end; ++it)

        arg << QDBusVariant(*it);

    arg.endArray();

    return arg;

}

// QMap specializations

template<typename Key, typename T>

inline QDBusArgument &operator<<(QDBusArgument &arg, const QMap<Key, T> &map)

{

    int kid = qMetaTypeId<Key>();

    int vid = qMetaTypeId<T>();

    arg.beginMap(kid, vid);

    typename QMap<Key, T>::ConstIterator it = map.constBegin();

    typename QMap<Key, T>::ConstIterator end = map.constEnd();

    for ( ; it != end; ++it) {

        arg.beginMapEntry();

        arg << it.key() << it.value();

        arg.endMapEntry();

    }

    arg.endMap();

    return arg;

}

template<typename Key, typename T>

inline const QDBusArgument &operator>>(const QDBusArgument &arg, QMap<Key, T> &map)

{

    arg.beginMap();

    map.clear();

    while (!arg.atEnd()) {

        Key key;

        T value;

        arg.beginMapEntry();

        arg >> key >> value;

        map.insertMulti(key, value);

        arg.endMapEntry();

    }

    arg.endMap();

    return arg;

}

inline QDBusArgument &operator<<(QDBusArgument &arg, const QVariantMap &map)

{

    arg.beginMap(QVariant::String, qMetaTypeId<QDBusVariant>());

    QVariantMap::ConstIterator it = map.constBegin();

    QVariantMap::ConstIterator end = map.constEnd();

    for ( ; it != end; ++it) {

        arg.beginMapEntry();

        arg << it.key() << QDBusVariant(it.value());

        arg.endMapEntry();

    }

    arg.endMap();

    return arg;

}

// QHash specializations

template<typename Key, typename T>

inline QDBusArgument &operator<<(QDBusArgument &arg, const QHash<Key, T> &map)

{

    int kid = qMetaTypeId<Key>();

    int vid = qMetaTypeId<T>();

    arg.beginMap(kid, vid);

    typename QHash<Key, T>::ConstIterator it = map.constBegin();

    typename QHash<Key, T>::ConstIterator end = map.constEnd();

    for ( ; it != end; ++it) {

        arg.beginMapEntry();

        arg << it.key() << it.value();

        arg.endMapEntry();

    }

    arg.endMap();

    return arg;

}

template<typename Key, typename T>

inline const QDBusArgument &operator>>(const QDBusArgument &arg, QHash<Key, T> &map)

{

    arg.beginMap();

    map.clear();

    while (!arg.atEnd()) {

        Key key;

        T value;

        arg.beginMapEntry();

        arg >> key >> value;

        map.insertMulti(key, value);

        arg.endMapEntry();

    }

    arg.endMap();

    return arg;

}

QT_END_NAMESPACE

Q_DECLARE_METATYPE(QDBusArgument)

QT_END_HEADER

#endif // QT_NO_DBUS

#endif