Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

1 files changed, 618 insertions, 0 deletions

diff --git a/src/corelib/kernel/qvariant.h b/src/corelib/kernel/qvariant.h
new file mode 100644
index 0000000000..1b8cb7fd0b
--- /dev/null
+++ b/src/corelib/kernel/qvariant.h
@@ -0,0 +1,618 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtCore 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 QVARIANT_H
+#define QVARIANT_H
+
+#include <QtCore/qatomic.h>
+#include <QtCore/qbytearray.h>
+#include <QtCore/qlist.h>
+#include <QtCore/qmetatype.h>
+#include <QtCore/qmap.h>
+#include <QtCore/qhash.h>
+#include <QtCore/qstring.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(Core)
+
+class QBitArray;
+class QDataStream;
+class QDate;
+class QDateTime;
+class QEasingCurve;
+class QLine;
+class QLineF;
+class QLocale;
+class QMatrix;
+class QTransform;
+class QStringList;
+class QTime;
+class QPoint;
+class QPointF;
+class QSize;
+class QSizeF;
+class QRect;
+class QRectF;
+#ifndef QT_NO_REGEXP
+class QRegExp;
+#endif
+class QTextFormat;
+class QTextLength;
+class QUrl;
+class QVariant;
+class QVariantComparisonHelper;
+
+template <typename T>
+inline QVariant qVariantFromValue(const T &);
+
+template<typename T>
+inline T qvariant_cast(const QVariant &);
+
+class Q_CORE_EXPORT QVariant
+{
+ public:
+    enum Type {
+        Invalid = 0,
+
+        Bool = 1,
+        Int = 2,
+        UInt = 3,
+        LongLong = 4,
+        ULongLong = 5,
+        Double = 6,
+        Char = 7,
+        Map = 8,
+        List = 9,
+        String = 10,
+        StringList = 11,
+        ByteArray = 12,
+        BitArray = 13,
+        Date = 14,
+        Time = 15,
+        DateTime = 16,
+        Url = 17,
+        Locale = 18,
+        Rect = 19,
+        RectF = 20,
+        Size = 21,
+        SizeF = 22,
+        Line = 23,
+        LineF = 24,
+        Point = 25,
+        PointF = 26,
+        RegExp = 27,
+        Hash = 28,
+        EasingCurve = 29,
+        LastCoreType = EasingCurve,
+
+        // value 62 is internally reserved
+#ifdef QT3_SUPPORT
+        ColorGroup = 63,
+#endif
+        Font = 64,
+        Pixmap = 65,
+        Brush = 66,
+        Color = 67,
+        Palette = 68,
+        Icon = 69,
+        Image = 70,
+        Polygon = 71,
+        Region = 72,
+        Bitmap = 73,
+        Cursor = 74,
+        SizePolicy = 75,
+        KeySequence = 76,
+        Pen = 77,
+        TextLength = 78,
+        TextFormat = 79,
+        Matrix = 80,
+        Transform = 81,
+        Matrix4x4 = 82,
+        Vector2D = 83,
+        Vector3D = 84,
+        Vector4D = 85,
+        Quaternion = 86,
+        LastGuiType = Quaternion,
+
+        UserType = 127,
+#ifdef QT3_SUPPORT
+        IconSet = Icon,
+        CString = ByteArray,
+        PointArray = Polygon,
+#endif
+        LastType = 0xffffffff // need this so that gcc >= 3.4 allocates 32 bits for Type
+    };
+
+    inline QVariant();
+    ~QVariant();
+    QVariant(Type type);
+    QVariant(int typeOrUserType, const void *copy);
+    QVariant(int typeOrUserType, const void *copy, uint flags);
+    QVariant(const QVariant &other);
+
+#ifndef QT_NO_DATASTREAM
+    QVariant(QDataStream &s);
+#endif
+
+    QVariant(int i);
+    QVariant(uint ui);
+    QVariant(qlonglong ll);
+    QVariant(qulonglong ull);
+    QVariant(bool b);
+    QVariant(double d);
+    QVariant(float f) { d.is_null = false; d.type = QMetaType::Float; d.data.f = f; }
+#ifndef QT_NO_CAST_FROM_ASCII
+    QT_ASCII_CAST_WARN_CONSTRUCTOR QVariant(const char *str);
+#endif
+
+    QVariant(const QByteArray &bytearray);
+    QVariant(const QBitArray &bitarray);
+    QVariant(const QString &string);
+    QVariant(const QLatin1String &string);
+    QVariant(const QStringList &stringlist);
+    QVariant(const QChar &qchar);
+    QVariant(const QDate &date);
+    QVariant(const QTime &time);
+    QVariant(const QDateTime &datetime);
+    QVariant(const QList<QVariant> &list);
+    QVariant(const QMap<QString,QVariant> &map);
+    QVariant(const QHash<QString,QVariant> &hash);
+#ifndef QT_NO_GEOM_VARIANT
+    QVariant(const QSize &size);
+    QVariant(const QSizeF &size);
+    QVariant(const QPoint &pt);
+    QVariant(const QPointF &pt);
+    QVariant(const QLine &line);
+    QVariant(const QLineF &line);
+    QVariant(const QRect &rect);
+    QVariant(const QRectF &rect);
+#endif
+    QVariant(const QUrl &url);
+    QVariant(const QLocale &locale);
+#ifndef QT_NO_REGEXP
+    QVariant(const QRegExp &regExp);
+#endif
+#ifndef QT_BOOTSTRAPPED
+    QVariant(const QEasingCurve &easing);
+#endif
+    QVariant(Qt::GlobalColor color);
+
+    QVariant& operator=(const QVariant &other);
+#ifdef Q_COMPILER_RVALUE_REFS
+    inline QVariant &operator=(QVariant &&other)
+    { qSwap(d, other.d); return *this; }
+#endif
+
+    inline void swap(QVariant &other) { qSwap(d, other.d); }
+
+    Type type() const;
+    int userType() const;
+    const char *typeName() const;
+
+    bool canConvert(Type t) const;
+    bool convert(Type t);
+
+#ifdef QT3_SUPPORT
+    inline QT3_SUPPORT bool canCast(Type t) const
+    { return canConvert(t); }
+    inline QT3_SUPPORT bool cast(Type t)
+    { return convert(t); }
+#endif
+
+    inline bool isValid() const;
+    bool isNull() const;
+
+    void clear();
+
+    void detach();
+    inline bool isDetached() const;
+
+    int toInt(bool *ok = 0) const;
+    uint toUInt(bool *ok = 0) const;
+    qlonglong toLongLong(bool *ok = 0) const;
+    qulonglong toULongLong(bool *ok = 0) const;
+    bool toBool() const;
+    double toDouble(bool *ok = 0) const;
+    float toFloat(bool *ok = 0) const;
+    qreal toReal(bool *ok = 0) const;
+    QByteArray toByteArray() const;
+    QBitArray toBitArray() const;
+    QString toString() const;
+    QStringList toStringList() const;
+    QChar toChar() const;
+    QDate toDate() const;
+    QTime toTime() const;
+    QDateTime toDateTime() const;
+    QList<QVariant> toList() const;
+    QMap<QString, QVariant> toMap() const;
+    QHash<QString, QVariant> toHash() const;
+
+#ifndef QT_NO_GEOM_VARIANT
+    QPoint toPoint() const;
+    QPointF toPointF() const;
+    QRect toRect() const;
+    QSize toSize() const;
+    QSizeF toSizeF() const;
+    QLine toLine() const;
+    QLineF toLineF() const;
+    QRectF toRectF() const;
+#endif
+    QUrl toUrl() const;
+    QLocale toLocale() const;
+#ifndef QT_NO_REGEXP
+    QRegExp toRegExp() const;
+#endif
+#ifndef QT_BOOTSTRAPPED
+    QEasingCurve toEasingCurve() const;
+#endif
+
+#ifdef QT3_SUPPORT
+    inline QT3_SUPPORT int &asInt();
+    inline QT3_SUPPORT uint &asUInt();
+    inline QT3_SUPPORT qlonglong &asLongLong();
+    inline QT3_SUPPORT qulonglong &asULongLong();
+    inline QT3_SUPPORT bool &asBool();
+    inline QT3_SUPPORT double &asDouble();
+    inline QT3_SUPPORT QByteArray &asByteArray();
+    inline QT3_SUPPORT QBitArray &asBitArray();
+    inline QT3_SUPPORT QString &asString();
+    inline QT3_SUPPORT QStringList &asStringList();
+    inline QT3_SUPPORT QDate &asDate();
+    inline QT3_SUPPORT QTime &asTime();
+    inline QT3_SUPPORT QDateTime &asDateTime();
+    inline QT3_SUPPORT QList<QVariant> &asList();
+    inline QT3_SUPPORT QMap<QString,QVariant> &asMap();
+    inline QT3_SUPPORT QPoint &asPoint();
+    inline QT3_SUPPORT QRect &asRect();
+    inline QT3_SUPPORT QSize &asSize();
+#endif //QT3_SUPPORT
+
+#ifndef QT_NO_DATASTREAM
+    void load(QDataStream &ds);
+    void save(QDataStream &ds) const;
+#endif
+    static const char *typeToName(Type type);
+    static Type nameToType(const char *name);
+
+#ifdef QT3_SUPPORT
+    inline QT3_SUPPORT_CONSTRUCTOR QVariant(bool val, int) { create(Bool, &val); }
+    inline QT3_SUPPORT const QByteArray toCString() const { return toByteArray(); }
+    inline QT3_SUPPORT QByteArray &asCString() { return *reinterpret_cast<QByteArray *>(castOrDetach(ByteArray)); }
+#endif
+
+    void *data();
+    const void *constData() const;
+    inline const void *data() const { return constData(); }
+
+    template<typename T>
+    inline void setValue(const T &value);
+
+    template<typename T>
+    inline T value() const
+    { return qvariant_cast<T>(*this); }
+
+    template<typename T>
+    static inline QVariant fromValue(const T &value)
+    { return qVariantFromValue(value); }
+
+    template<typename T>
+    bool canConvert() const
+    { return canConvert(Type(qMetaTypeId<T>())); }
+
+ public:
+#ifndef qdoc
+    struct PrivateShared
+    {
+        inline PrivateShared(void *v) : ptr(v), ref(1) { }
+        void *ptr;
+        QAtomicInt ref;
+    };
+    struct Private
+    {
+        inline Private(): type(Invalid), is_shared(false), is_null(true) { data.ptr = 0; }
+        inline Private(const Private &other)
+            : data(other.data), type(other.type),
+              is_shared(other.is_shared), is_null(other.is_null)
+        {}
+        union Data
+        {
+            char c;
+            int i;
+            uint u;
+            bool b;
+            double d;
+            float f;
+            qreal real;
+            qlonglong ll;
+            qulonglong ull;
+            QObject *o;
+            void *ptr;
+            PrivateShared *shared;
+        } data;
+        uint type : 30;
+        uint is_shared : 1;
+        uint is_null : 1;
+    };
+ public:
+    typedef void (*f_construct)(Private *, const void *);
+    typedef void (*f_clear)(Private *);
+    typedef bool (*f_null)(const Private *);
+#ifndef QT_NO_DATASTREAM
+    typedef void (*f_load)(Private *, QDataStream &);
+    typedef void (*f_save)(const Private *, QDataStream &);
+#endif
+    typedef bool (*f_compare)(const Private *, const Private *);
+    typedef bool (*f_convert)(const QVariant::Private *d, Type t, void *, bool *);
+    typedef bool (*f_canConvert)(const QVariant::Private *d, Type t);
+    typedef void (*f_debugStream)(QDebug, const QVariant &);
+    struct Handler {
+        f_construct construct;
+        f_clear clear;
+        f_null isNull;
+#ifndef QT_NO_DATASTREAM
+        f_load load;
+        f_save save;
+#endif
+        f_compare compare;
+        f_convert convert;
+        f_canConvert canConvert;
+        f_debugStream debugStream;
+    };
+#endif
+
+    inline bool operator==(const QVariant &v) const
+    { return cmp(v); }
+    inline bool operator!=(const QVariant &v) const
+    { return !cmp(v); }
+
+protected:
+    friend inline bool qvariant_cast_helper(const QVariant &, QVariant::Type, void *);
+    friend int qRegisterGuiVariant();
+    friend int qUnregisterGuiVariant();
+    friend inline bool operator==(const QVariant &, const QVariantComparisonHelper &);
+#ifndef QT_NO_DEBUG_STREAM
+    friend Q_CORE_EXPORT QDebug operator<<(QDebug, const QVariant &);
+#endif
+    Private d;
+
+    static const Handler *handler;
+
+    void create(int type, const void *copy);
+#ifdef QT3_SUPPORT
+    void *castOrDetach(Type t);
+#endif
+    bool cmp(const QVariant &other) const;
+
+private:
+    // force compile error, prevent QVariant(bool) to be called
+    inline QVariant(void *) { Q_ASSERT(false); }
+#ifdef QT_NO_CAST_FROM_ASCII
+    // force compile error when implicit conversion is not wanted
+    inline QVariant(const char *) { Q_ASSERT(false); }
+#endif
+#ifndef QT3_SUPPORT
+    // force compile error, prevent QVariant(QVariant::Type, int) to be called
+    inline QVariant(bool, int) { Q_ASSERT(false); }
+#endif
+public:
+    typedef Private DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+
+typedef QList<QVariant> QVariantList;
+typedef QMap<QString, QVariant> QVariantMap;
+typedef QHash<QString, QVariant> QVariantHash;
+
+inline bool qvariant_cast_helper(const QVariant &v, QVariant::Type tp, void *ptr)
+{ return QVariant::handler->convert(&v.d, tp, ptr, 0); }
+
+template <typename T>
+inline QVariant qVariantFromValue(const T &t)
+{
+    return QVariant(qMetaTypeId<T>(reinterpret_cast<T *>(0)), &t, QTypeInfo<T>::isPointer);
+}
+
+template <>
+inline QVariant qVariantFromValue(const QVariant &t) { return t; }
+
+template <typename T>
+inline void qVariantSetValue(QVariant &v, const T &t)
+{
+    //if possible we reuse the current QVariant private
+    const uint type = qMetaTypeId<T>(reinterpret_cast<T *>(0));
+    QVariant::Private &d = v.data_ptr();
+    if (v.isDetached() && (type == d.type || (type <= uint(QVariant::Char) && d.type <= uint(QVariant::Char)))) {
+        d.type = type;
+        d.is_null = false;
+        T *old = reinterpret_cast<T*>(d.is_shared ? d.data.shared->ptr : &d.data.ptr);
+        if (QTypeInfo<T>::isComplex)
+            old->~T();
+        new (old) T(t); //call the copy constructor
+    } else {
+        v = QVariant(type, &t, QTypeInfo<T>::isPointer);
+    }
+}
+
+template <>
+inline void qVariantSetValue<QVariant>(QVariant &v, const QVariant &t)
+{
+    v = t;
+}
+
+
+inline QVariant::QVariant() {}
+inline bool QVariant::isValid() const { return d.type != Invalid; }
+
+#ifdef QT3_SUPPORT
+inline int &QVariant::asInt()
+{ return *reinterpret_cast<int *>(castOrDetach(Int)); }
+inline uint &QVariant::asUInt()
+{ return *reinterpret_cast<uint *>(castOrDetach(UInt)); }
+inline qlonglong &QVariant::asLongLong()
+{ return *reinterpret_cast<qlonglong *>(castOrDetach(LongLong)); }
+inline qulonglong &QVariant::asULongLong()
+{ return *reinterpret_cast<qulonglong *>(castOrDetach(ULongLong)); }
+inline bool &QVariant::asBool()
+{ return *reinterpret_cast<bool *>(castOrDetach(Bool)); }
+inline double &QVariant::asDouble()
+{ return *reinterpret_cast<double *>(castOrDetach(Double)); }
+inline QByteArray& QVariant::asByteArray()
+{ return *reinterpret_cast<QByteArray *>(castOrDetach(ByteArray)); }
+inline QBitArray& QVariant::asBitArray()
+{ return *reinterpret_cast<QBitArray *>(castOrDetach(BitArray)); }
+inline QString& QVariant::asString()
+{ return *reinterpret_cast<QString *>(castOrDetach(String)); }
+inline QStringList& QVariant::asStringList()
+{ return *reinterpret_cast<QStringList *>(castOrDetach(StringList)); }
+inline QDate& QVariant::asDate()
+{ return *reinterpret_cast<QDate *>(castOrDetach(Date)); }
+inline QTime& QVariant::asTime()
+{ return *reinterpret_cast<QTime *>(castOrDetach(Time)); }
+inline QDateTime& QVariant::asDateTime()
+{ return *reinterpret_cast<QDateTime *>(castOrDetach(DateTime)); }
+inline QList<QVariant>& QVariant::asList()
+{ return *reinterpret_cast<QList<QVariant> *>(castOrDetach(List)); }
+inline QMap<QString, QVariant>& QVariant::asMap()
+{ return *reinterpret_cast<QMap<QString, QVariant> *>(castOrDetach(Map)); }
+inline QPoint &QVariant::asPoint()
+{ return *reinterpret_cast<QPoint *>(castOrDetach(Point)); }
+inline QRect &QVariant::asRect()
+{ return *reinterpret_cast<QRect *>(castOrDetach(Rect)); }
+inline QSize &QVariant::asSize()
+{ return *reinterpret_cast<QSize *>(castOrDetach(Size)); }
+#endif //QT3_SUPPORT
+
+template<typename T>
+inline void QVariant::setValue(const T &avalue)
+{ qVariantSetValue(*this, avalue); }
+
+#ifndef QT_NO_DATASTREAM
+Q_CORE_EXPORT QDataStream& operator>> (QDataStream& s, QVariant& p);
+Q_CORE_EXPORT QDataStream& operator<< (QDataStream& s, const QVariant& p);
+Q_CORE_EXPORT QDataStream& operator>> (QDataStream& s, QVariant::Type& p);
+Q_CORE_EXPORT QDataStream& operator<< (QDataStream& s, const QVariant::Type p);
+#endif
+
+inline bool QVariant::isDetached() const
+{ return !d.is_shared || d.data.shared->ref == 1; }
+
+
+#ifdef qdoc
+    inline bool operator==(const QVariant &v1, const QVariant &v2);
+    inline bool operator!=(const QVariant &v1, const QVariant &v2);
+#else
+
+/* Helper class to add one more level of indirection to prevent
+   implicit casts.
+*/
+class QVariantComparisonHelper
+{
+public:
+    inline QVariantComparisonHelper(const QVariant &var)
+        : v(&var) {}
+private:
+    friend inline bool operator==(const QVariant &, const QVariantComparisonHelper &);
+    const QVariant *v;
+};
+
+inline bool operator==(const QVariant &v1, const QVariantComparisonHelper &v2)
+{
+    return v1.cmp(*v2.v);
+}
+
+inline bool operator!=(const QVariant &v1, const QVariantComparisonHelper &v2)
+{
+    return !operator==(v1, v2);
+}
+#endif
+
+#ifndef QT_MOC
+template<typename T> inline T qvariant_cast(const QVariant &v)
+{
+    const int vid = qMetaTypeId<T>(static_cast<T *>(0));
+    if (vid == v.userType())
+        return *reinterpret_cast<const T *>(v.constData());
+    if (vid < int(QMetaType::User)) {
+        T t;
+        if (qvariant_cast_helper(v, QVariant::Type(vid), &t))
+            return t;
+    }
+    return T();
+}
+
+template<> inline QVariant qvariant_cast<QVariant>(const QVariant &v)
+{
+    if (v.userType() == QMetaType::QVariant)
+        return *reinterpret_cast<const QVariant *>(v.constData());
+    return v;
+}
+
+#ifdef QT_DEPRECATED
+template<typename T>
+inline QT_DEPRECATED T qVariantValue(const QVariant &variant)
+{ return qvariant_cast<T>(variant); }
+
+template<typename T>
+inline QT_DEPRECATED bool qVariantCanConvert(const QVariant &variant)
+{ return variant.template canConvert<T>(); }
+#endif
+
+#endif
+Q_DECLARE_SHARED(QVariant)
+Q_DECLARE_TYPEINFO(QVariant, Q_MOVABLE_TYPE);
+
+#ifndef QT_NO_DEBUG_STREAM
+Q_CORE_EXPORT QDebug operator<<(QDebug, const QVariant &);
+Q_CORE_EXPORT QDebug operator<<(QDebug, const QVariant::Type);
+#endif
+
+QT_END_NAMESPACE
+
+Q_DECLARE_BUILTIN_METATYPE(QVariantList, QVariantList)
+Q_DECLARE_BUILTIN_METATYPE(QVariantMap, QVariantMap)
+Q_DECLARE_BUILTIN_METATYPE(QVariantHash, QVariantHash)
+
+QT_END_HEADER
+
+#endif // QVARIANT_H