/data/store/work/kde/3.5/dbus-qt4-qt3backport/dbus/qdbusdatamap.h

/* qdbusdatamap.h DBUS data mapping transport type
 *
 * Copyright (C) 2007 Kevin Krammer <kevin.krammer@gmx.at>
 *
 * Licensed under the Academic Free License version 2.1
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
 * USA.
 *
 */

#ifndef QDBUSDATAMAP_H
#define QDBUSDATAMAP_H

#include "dbus/qdbusmacros.h"
#include <qmap.h>

class QDBusData;
class QDBusObjectPath;
class QDBusVariant;

template <typename T>
class QDBUS_EXPORT QDBusDataMap : private QMap<T, QDBusData>
{
    friend class QDBusData;

public:
    typedef QMapConstIterator<T, QDBusData> const_iterator;

    QDBusDataMap<T>()
        : QMap<T, QDBusData>(), m_valueType(QDBusData::Invalid) {}

    explicit QDBusDataMap<T>(QDBusData::Type simpleValueType)
        : QMap<T, QDBusData>(), m_valueType(simpleValueType) {}

    explicit QDBusDataMap<T>(const QDBusData& containerValueType)
        : QMap<T, QDBusData>(), m_valueType(containerValueType.type())
    {
        if (hasContainerValueType()) m_containerValueType = containerValueType;
    }

    QDBusDataMap<T>(const QDBusDataMap<T>& other)
        : QMap<T, QDBusData>(other), m_valueType(other.m_valueType),
          m_containerValueType(other.m_containerValueType) {}

    QDBusDataMap<T>(const QMap<T, QDBusData>& other)
        : QMap<T, QDBusData>(other), m_valueType(QDBusData::Invalid)
    {
        const_iterator it = begin();
        if (it == end()) return;

        m_valueType = (*it).type();

        QCString containerSignature;
        if (hasContainerValueType())
        {
            m_containerValueType = it.data();
            containerSignature = m_containerValueType.buildDBusSignature();
        }

        for (++it; it != end(); ++it)
        {
            if ((*it).type() != m_valueType)
            {
                m_valueType = QDBusData::Invalid;
                m_containerValueType = QDBusData();

                clear();
                return;
            }
            else if (hasContainerValueType())
            {
                if (it.data().buildDBusSignature() != containerSignature)
                {
                    m_valueType = QDBusData::Invalid;
                    m_containerValueType = QDBusData();

                    clear();
                    return;
                }
            }
        }
    }

    QDBusDataMap<T>(const QMap<T, bool>& other)
        : QMap<T, QDBusData>(), m_valueType(QDBusData::Bool)
    {
        typename QMap<T, bool>::const_iterator it    = other.begin();
        typename QMap<T, bool>::const_iterator endIt = other.end();
        for (; it != endIt; ++it)
        {
            insert(it.key(), QDBusData::fromBool(it.data()));
        }
    }

    QDBusDataMap<T>(const QMap<T, Q_UINT8>& other)
        : QMap<T, QDBusData>(), m_valueType(QDBusData::Byte)
    {
        typename QMap<T, Q_UINT8>::const_iterator it    = other.begin();
        typename QMap<T, Q_UINT8>::const_iterator endIt = other.end();
        for (; it != endIt; ++it)
        {
            insert(it.key(), QDBusData::fromByte(it.data()));
        }
    }

    QDBusDataMap<T>(const QMap<T, Q_INT16>& other)
        : QMap<T, QDBusData>(), m_valueType(QDBusData::Int16)
    {
        typename QMap<T, Q_INT16>::const_iterator it    = other.begin();
        typename QMap<T, Q_INT16>::const_iterator endIt = other.end();
        for (; it != endIt; ++it)
        {
            insert(it.key(), QDBusData::fromInt16(it.data()));
        }
    }

    QDBusDataMap<T>(const QMap<T, Q_UINT16>& other)
        : QMap<T, QDBusData>(), m_valueType(QDBusData::UInt16)
    {
        typename QMap<T, Q_UINT16>::const_iterator it    = other.begin();
        typename QMap<T, Q_UINT16>::const_iterator endIt = other.end();
        for (; it != endIt; ++it)
        {
            insert(it.key(), QDBusData::fromUInt16(it.data()));
        }
    }

    QDBusDataMap<T>(const QMap<T, Q_INT32>& other)
        : QMap<T, QDBusData>(), m_valueType(QDBusData::Int32)
    {
        typename QMap<T, Q_INT32>::const_iterator it    = other.begin();
        typename QMap<T, Q_INT32>::const_iterator endIt = other.end();
        for (; it != endIt; ++it)
        {
            insert(it.key(), QDBusData::fromInt32(it.data()));
        }
    }

    QDBusDataMap<T>(const QMap<T, Q_UINT32>& other)
        : QMap<T, QDBusData>(), m_valueType(QDBusData::UInt32)
    {
        typename QMap<T, Q_UINT32>::const_iterator it    = other.begin();
        typename QMap<T, Q_UINT32>::const_iterator endIt = other.end();
        for (; it != endIt; ++it)
        {
            insert(it.key(), QDBusData::fromUInt32(it.data()));
        }
    }

    QDBusDataMap<T>(const QMap<T, Q_INT64>& other)
        : QMap<T, QDBusData>(), m_valueType(QDBusData::Int64)
    {
        typename QMap<T, Q_INT64>::const_iterator it    = other.begin();
        typename QMap<T, Q_INT64>::const_iterator endIt = other.end();
        for (; it != endIt; ++it)
        {
            insert(it.key(), QDBusData::fromInt64(it.data()));
        }
    }

    QDBusDataMap<T>(const QMap<T, Q_UINT64>& other)
        : QMap<T, QDBusData>(), m_valueType(QDBusData::UInt64)
    {
        typename QMap<T, Q_UINT64>::const_iterator it    = other.begin();
        typename QMap<T, Q_UINT64>::const_iterator endIt = other.end();
        for (; it != endIt; ++it)
        {
            insert(it.key(), QDBusData::fromUInt64(it.data()));
        }
    }

    QDBusDataMap<T>(const QMap<T, double>& other)
        : QMap<T, QDBusData>(), m_valueType(QDBusData::Double)
    {
        typename QMap<T, double>::const_iterator it    = other.begin();
        typename QMap<T, double>::const_iterator endIt = other.end();
        for (; it != endIt; ++it)
        {
            insert(it.key(), QDBusData::fromDouble(it.data()));
        }
    }

    QDBusDataMap<T>(const QMap<T, QString>& other)
        : QMap<T, QDBusData>(), m_valueType(QDBusData::String)
    {
        typename QMap<T, QString>::const_iterator it    = other.begin();
        typename QMap<T, QString>::const_iterator endIt = other.end();
        for (; it != endIt; ++it)
        {
            insert(it.key(), QDBusData::fromString(it.data()));
        }
    }

    QDBusDataMap<T>(const QMap<T, QDBusObjectPath>& other)
        : QMap<T, QDBusData>(), m_valueType(QDBusData::ObjectPath)
    {
        typename QMap<T, QDBusObjectPath>::const_iterator it    = other.begin();
        typename QMap<T, QDBusObjectPath>::const_iterator endIt = other.end();
        for (; it != endIt; ++it)
        {
            insert(it.key(), QDBusData::fromObjectPath(it.data()));
        }
    }

    QDBusDataMap<T>(const QMap<T, QDBusVariant>& other)
        : QMap<T, QDBusData>(), m_valueType(QDBusData::Variant)
    {
        typename QMap<T, QDBusVariant>::const_iterator it    = other.begin();
        typename QMap<T, QDBusVariant>::const_iterator endIt = other.end();
        for (; it != endIt; ++it)
        {
            insert(it.key(), QDBusData::fromVariant(it.data()));
        }
    }

    QDBusDataMap<T>& operator=(const QDBusDataMap<T>& other)
    {
        QMap<T, QDBusData>::operator=(other);

        m_valueType = other.m_valueType;
        m_containerValueType = other.m_containerValueType;

        return *this;
    }

    QDBusDataMap<T>& operator=(const QMap<T, QDBusData>& other)
    {
        QMap<T, QDBusData>::operator=(other);

        m_valueType = QDBusData::Invalid;
        m_containerValueType = QDBusData();

        const_iterator it = begin();
        if (it == end()) return *this;

        m_valueType = (*it).type();

        QCString containerSignature;
        if (hasContainerValueType())
        {
            m_containerValueType = it.data();
            containerSignature = m_containerValueType.buildDBusSignature();
        }

        for (++it; it != end(); ++it)
        {
            if ((*it).type() != m_valueType)
            {
                m_valueType = QDBusData::Invalid;
                m_containerValueType = QDBusData();

                clear();
                return *this;
            }
            else if (hasContainerValueType())
            {
                if (it.data()->buildSignature() != containerSignature)
                {
                    m_valueType = QDBusData::Invalid;
                    m_containerValueType = QDBusData();

                    clear();
                    return *this;
                }
            }
        }

        return *this;
    }

    QDBusData::Type keyType() const { return m_keyType; }

    QDBusData::Type valueType() const { return m_valueType; }

    bool hasContainerValueType() const
    {
        return m_valueType == QDBusData::List || m_valueType == QDBusData::Struct
                                              || m_valueType == QDBusData::Map;
    }

    QDBusData containerValueType() const { return m_containerValueType; }

    inline bool isValid() const { return valueType() != QDBusData::Invalid; }

    bool isEmpty() const { return QMap<T, QDBusData>::empty(); }

    uint count() const { return QMap<T, QDBusData>::count(); }

    bool operator==(const QDBusDataMap<T>& other) const
    {
        if (m_valueType != other.m_valueType) return false;

        if (count() != other.count()) return false;

        if (hasContainerValueType() != other.hasContainerValueType()) return false;

        if (hasContainerValueType())
        {
            if (m_containerValueType.buildDBusSignature() !=
                other.m_containerValueType.buildDBusSignature()) return false;
        }

        const_iterator it = begin();
        const_iterator otherIt = other.begin();
        for (; it != end() && otherIt != other.end(); ++it, ++otherIt)
        {
            if (it.key() != otherIt.key()) return false;

            if (!(it.data() == otherIt.data())) return false;
        }

        return true;
    }

    void clear() { QMap<T, QDBusData>::clear(); }

    const_iterator begin() const
    {
        return QMap<T, QDBusData>::begin();
    }

    const_iterator end() const
    {
        return QMap<T, QDBusData>::end();
    }

    bool insert(const T& key, const QDBusData& data)
    {
        if (data.type() == QDBusData::Invalid) return false;

        if (m_valueType == QDBusData::Invalid)
        {
            m_valueType = data.type();

            // TODO: create empty copy of container
            if (hasContainerValueType()) m_containerValueType = data;

            QMap<T, QDBusData>::insert(key, data);
        }
        else if (data.type() != m_valueType)
        {
            qWarning("QDBusDataMap: trying to add data of type %s to map of type %s",
                     data.typeName(), QDBusData::typeName(m_valueType));
        }
        else if (hasContainerValueType())
        {
            QCString ourSignature  = m_containerValueType.buildDBusSignature();
            QCString dataSignature = data.buildDBusSignature();

            if (ourSignature != dataSignature)
            {
                qWarning("QDBusDataMap: trying to add data with signature %s "
                        "to map with value signature %s",
                        dataSignature.data(), ourSignature.data());
            }
            else
                QMap<T, QDBusData>::insert(key, data);
        }
        else
            QMap<T, QDBusData>::insert(key, data);

        return true;
    }

    QMap<T, QDBusData> toQMap() const { return *this; }

    QMap<T, bool> toBoolMap(bool* ok = 0) const
    {
        if (m_valueType != QDBusData::Bool)
        {
            if (ok != 0) *ok = false;
            return QMap<T, bool>();
        }

        QMap<T, bool> result;

        const_iterator it    = begin();
        const_iterator endIt = end();
        for (; it != endIt; ++it)
        {
            result.insert(it.key(), (*it).toBool());
        }

        if (ok != 0) *ok = true;

        return result;
    }

    QMap<T, Q_UINT8> toByteMap(bool* ok = 0) const
    {
        if (m_valueType != QDBusData::Byte)
        {
            if (ok != 0) *ok = false;
            return QMap<T, Q_UINT8>();
        }

        QMap<T, Q_UINT8> result;

        const_iterator it    = begin();
        const_iterator endIt = end();
        for (; it != endIt; ++it)
        {
            result.insert(it.key(), (*it).toByte());
        }

        if (ok != 0) *ok = true;

        return result;
    }

    QMap<T, Q_INT16> toInt16Map(bool* ok = 0) const
    {
        if (m_valueType != QDBusData::Int16)
        {
            if (ok != 0) *ok = false;
            return QMap<T, Q_INT16>();
        }

        QMap<T, Q_INT16> result;

        const_iterator it    = begin();
        const_iterator endIt = end();
        for (; it != endIt; ++it)
        {
            result.insert(it.key(), (*it).toInt16());
        }

        if (ok != 0) *ok = true;

        return result;
    }

    QMap<T, Q_UINT16> toUInt16Map(bool* ok = 0) const
    {
        if (m_valueType != QDBusData::UInt16)
        {
            if (ok != 0) *ok = false;
            return QMap<T, Q_UINT16>();
        }

        QMap<T, Q_UINT16> result;

        const_iterator it    = begin();
        const_iterator endIt = end();
        for (; it != endIt; ++it)
        {
            result.insert(it.key(), (*it).toUInt16());
        }

        if (ok != 0) *ok = true;

        return result;
    }

    QMap<T, Q_INT32> toInt32Map(bool* ok = 0) const
    {
        if (m_valueType != QDBusData::Int32)
        {
            if (ok != 0) *ok = false;
            return QMap<T, Q_INT32>();
        }

        QMap<T, Q_INT32> result;

        const_iterator it    = begin();
        const_iterator endIt = end();
        for (; it != endIt; ++it)
        {
            result.insert(it.key(), (*it).toInt32());
        }

        if (ok != 0) *ok = true;

        return result;
    }

    QMap<T, Q_UINT32> toUInt32Map(bool* ok = 0) const
    {
        if (m_valueType != QDBusData::UInt32)
        {
            if (ok != 0) *ok = false;
            return QMap<T, Q_UINT32>();
        }

        QMap<T, Q_UINT32> result;

        const_iterator it    = begin();
        const_iterator endIt = end();
        for (; it != endIt; ++it)
        {
            result.insert(it.key(), (*it).toUInt32());
        }

        if (ok != 0) *ok = true;

        return result;
    }

    QMap<T, Q_INT64> toInt64Map(bool* ok = 0) const
    {
        if (m_valueType != QDBusData::Int64)
        {
            if (ok != 0) *ok = false;
            return QMap<T, Q_INT64>();
        }

        QMap<T, Q_INT64> result;

        const_iterator it    = begin();
        const_iterator endIt = end();
        for (; it != endIt; ++it)
        {
            result.insert(it.key(), (*it).toInt64());
        }

        if (ok != 0) *ok = true;

        return result;
    }

    QMap<T, Q_UINT64> toUInt64Map(bool* ok = 0) const
    {
        if (m_valueType != QDBusData::UInt64)
        {
            if (ok != 0) *ok = false;
            return QMap<T, Q_UINT64>();
        }

        QMap<T, Q_UINT64> result;

        const_iterator it    = begin();
        const_iterator endIt = end();
        for (; it != endIt; ++it)
        {
            result.insert(it.key(), (*it).toUInt64());
        }

        if (ok != 0) *ok = true;

        return result;
    }

    QMap<T, double> toDoubleMap(bool* ok = 0) const
    {
        if (m_valueType != QDBusData::Double)
        {
            if (ok != 0) *ok = false;
            return QMap<T, double>();
        }

        QMap<T, double> result;

        const_iterator it    = begin();
        const_iterator endIt = end();
        for (; it != endIt; ++it)
        {
            result.insert(it.key(), (*it).toDouble());
        }

        if (ok != 0) *ok = true;

        return result;
    }

    QMap<T, QString> toStringMap(bool* ok = 0) const
    {
        if (m_valueType != QDBusData::String)
        {
            if (ok != 0) *ok = false;
            return QMap<T, QString>();
        }

        QMap<T, QString> result;

        const_iterator it    = begin();
        const_iterator endIt = end();
        for (; it != endIt; ++it)
        {
            result.insert(it.key(), (*it).toString());
        }

        if (ok != 0) *ok = true;

        return result;
    }

    QMap<T, QDBusObjectPath> toObjectPathMap(bool* ok = 0) const
    {
        if (m_valueType != QDBusData::ObjectPath)
        {
            if (ok != 0) *ok = false;
            return QMap<T, QDBusObjectPath>();
        }

        QMap<T, QDBusObjectPath> result;

        const_iterator it    = begin();
        const_iterator endIt = end();
        for (; it != endIt; ++it)
        {
            result.insert(it.key(), (*it).toObjectPath());
        }

        if (ok != 0) *ok = true;

        return result;
    }

    QMap<T, QDBusVariant> toVariantMap(bool* ok = 0) const
    {
        if (m_valueType != QDBusData::Variant)
        {
            if (ok != 0) *ok = false;
            return QMap<T, QDBusVariant>();
        }

        QMap<T, QDBusVariant> result;

        const_iterator it    = begin();
        const_iterator endIt = end();
        for (; it != endIt; ++it)
        {
            result.insert(it.key(), (*it).toVariant());
        }

        if (ok != 0) *ok = true;

        return result;
    }

private:
    QDBusData::Type m_valueType;
    QDBusData m_containerValueType;

    static const QDBusData::Type m_keyType;
};

#endif

---