inline T value() const    { return qVariantValue<T>(*this); }    template<typename T>    static inline QVariant fromValue(const T &value)    { return qVariantFromValue(value); }    template<typename T>    bool canConvert() const    { return qVariantCanConvert<T>(*this); }#endif public:#ifndef qdoc    struct PrivateShared    {        inline PrivateShared() : ref(1) { }        inline PrivateShared(void *v) : ptr(v), ref(1) { }        void *ptr;        QAtomic 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;            qlonglong ll;            qulonglong ull;            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 inline bool operator==(const QVariant &, const QVariantComparisonHelper &);#ifndef QT_NO_DEBUG_STREAM    friend Q_CORE_EXPORT QDebug operator<<(QDebug, const QVariant &);#endif    Private d;#ifndef QT_MOC    static const Handler *handler;#endif    void create(int type, const void *copy);#ifdef QT3_SUPPORT    void *castOrDetach(Type t);#endif    bool cmp(const QVariant &other) const;private:#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};#ifndef QT_MOCtypedef QList<QVariant> QVariantList;typedef QMap<QString, QVariant> QVariantMap;Q_DECLARE_BUILTIN_METATYPE(QVariantList, QVariantList)Q_DECLARE_BUILTIN_METATYPE(QVariantMap, QVariantMap)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);}template <>inline QVariant qVariantFromValue(const QVariant &t) { return t; }template <typename T>inline void qVariantSetValue(QVariant &v, const T &t){    v = QVariant(qMetaTypeId<T>(reinterpret_cast<T *>(0)), &t);}#endifinline QVariant::QVariant() {}inline bool QVariant::isValid() const { return d.type != Invalid; }#ifdef QT3_SUPPORTinline 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#ifndef QT_NO_MEMBER_TEMPLATEStemplate<typename T>inline void QVariant::setValue(const T &avalue){ qVariantSetValue(*this, avalue); }#endif#ifndef QT_NO_DATASTREAMQ_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);#endifinline 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#if !defined qdoc && defined Q_CC_MSVC && _MSC_VER < 1300template<typename T> T qvariant_cast(const QVariant &v, T * = 0){    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;        qvariant_cast_helper(v, QVariant::Type(vid), &t);        return t;    }    return T();}template<typename T>inline T qVariantValue(const QVariant &variant, T *t = 0){ return qvariant_cast<T>(variant, t); }template<typename T>inline bool qVariantCanConvert(const QVariant &variant, T *t = 0){    return variant.canConvert(static_cast<QVariant::Type>(qMetaTypeId<T>(t)));}#elsetemplate<typename T> 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;        qvariant_cast_helper(v, QVariant::Type(vid), &t);        return t;    }    return T();}template<typename T>inline T qVariantValue(const QVariant &variant){ return qvariant_cast<T>(variant); }template<typename T>inline bool qVariantCanConvert(const QVariant &variant){    return variant.canConvert(static_cast<QVariant::Type>(                qMetaTypeId<T>(static_cast<T *>(0))));}#endif#endifQ_DECLARE_SHARED(QVariant)Q_DECLARE_TYPEINFO(QVariant, Q_MOVABLE_TYPE);#ifndef QT_NO_DEBUG_STREAMQ_CORE_EXPORT QDebug operator<<(QDebug, const QVariant &);Q_CORE_EXPORT QDebug operator<<(QDebug, const QVariant::Type);#endifQT_END_HEADER#endif // QVARIANT_H