variant.hpp

/* Copyright (c) 2014, The Nuria Project
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *    1. The origin of this software must not be misrepresented; you must not
 *       claim that you wrote the original software. If you use this software
 *       in a product, an acknowledgment in the product documentation would be
 *       appreciated but is not required.
 *    2. Altered source versions must be plainly marked as such, and must not be
 *       misrepresented as being the original software.
 *    3. This notice may not be removed or altered from any source
 *       distribution.
 */

#ifndef NURIA_VARIANT_HPP
#define NURIA_VARIANT_HPP

#include "essentials.hpp"
#include <QStringList>
#include <QMetaType>
#include <QVariant>

namespace Nuria {
class VariantIteratorPrivate;

class NURIA_CORE_EXPORT Variant {
public:
    
    typedef bool (*Comparison)(const void *, const void *);
    
    typedef void *(*Conversion)(const void *);
    
    // Destructor
    typedef void (*IteratorDtorFunc)(void *);
    
    // Copy constructor
    typedef void *(*IteratorCopyFunc)(void *);
    
    // For value() and key()
    typedef QVariant (*IteratorValueFunc)(void *, int);
    
    // For operator++ and operator--
    typedef void (*IteratorIncFunc)(void *);
    
    // For operator+ and operator-
    typedef void *(*IteratorMoveFunc)(void *, int);
    
    // For operator-(Iterator)
    typedef int (*IteratorDistanceFunc)(void *, void *);
    
    // For begin and end
    typedef void *(*IteratorStartEndFunc)(void *);
    
    // For operator==
    typedef bool (*IteratorComparisonFunc)(void *, void *);
    
    // For count()
    typedef int (*IteratorCountFunc)(void *);
    
    // For find()
    typedef void *(*IteratorFindFunc)(void *, const QVariant &);
    
    static bool equal (const QVariant &left, const QVariant &right);
    static bool notEqual (const QVariant &left, const QVariant &right);
    
    static bool lessThan (const QVariant &left, const QVariant &right);
    static bool greaterThan (const QVariant &left, const QVariant &right);
    
    static bool lessEqualThan (const QVariant &left, const QVariant &right);
    static bool greaterEqualThan (const QVariant &left, const QVariant &right);
    
    inline static bool canCompare (const QVariant &left, const QVariant &right)
    { return canCompare (left.userType (), right.userType ()); }
    
    inline static bool canCompare (const QVariant &left, int rightType)
    { return canCompare (left.userType (), rightType); }
    
    template< typename Right > inline static bool canCompare (const QVariant &left)
    { return canCompare (left.userType (), qMetaTypeId< Right > ()); }
    
    template< typename Left, typename Right > inline static bool canCompare ()
    { return canCompare (qMetaTypeId< Left > (), qMetaTypeId< Right > ()); }
    
    static bool canCompare (int leftType, int rightType);
    
    static QVariant convert (const QVariant &variant, int type);
    
    template< typename T > static QVariant convert (const QVariant &variant)
    { return convert (variant, qMetaTypeId< T > ()); }
    
    template< typename T > inline static bool canConvert (const QVariant &variant)
    { return canConvert (variant.userType (), qMetaTypeId< T > ()); }
    
    inline static bool canConvert (const QVariant &variant, int toType)
    { return canConvert (variant.userType (), toType); }
    
    static bool canConvert (int fromType, int toType);
    
    template< typename T > static T toValue (const QVariant &variant) {
        QVariant result = convert (variant, qMetaTypeId< T > ());
        
        if (result.isValid ()) {
            return result.value< T > ();
        }
        
        return T ();
    }
    
    template< typename T > inline static void registerType ()
    { registerType< T, T > (); }
    
    template< typename T, typename Right > inline static void registerType () {
        typedef bool(T::*Func)(const Right &) const;
        Func equal = &T::operator==;
        Func less = &T::operator<;
        registerType (qMetaTypeId< T > (), qMetaTypeId< Right > (),
                  (Comparison)equal, (Comparison)less);
    }
    
    static void registerType (int type, int rightType, Comparison equal, Comparison lessThan);
    
    static void registerType (int type, int rightType, Comparison equal, Comparison notEqual,
                  Comparison less, Comparison greater, Comparison lessEqual,
                  Comparison greaterEqual);
    
    template< typename From, typename To >
    static void registerConversion (To *(*func)(const From &))
    { registerConversion (qMetaTypeId< From > (), qMetaTypeId< To > (), (Conversion)func); }
    
    template< typename From, typename To >
    static void registerConversion () {
        auto func = &autoConvTempl< From, To >;
        registerConversion (qMetaTypeId< From > (), qMetaTypeId< To > (), (Conversion)func);
    }
    
    static void registerConversion (int from, int to, Conversion func);
    
    template< typename T >
    static void registerIterators (typename T::mapped_type *a = (typename T::mapped_type *)0) {
        Q_UNUSED(a)
        int keyType = qMetaTypeId< typename T::key_type > ();
        int valueType = qMetaTypeId< typename T::mapped_type > ();
        
        registerIterator (qMetaTypeId< T > (), valueType, keyType,
                  (IteratorDtorFunc)&iteratorDtor< T >,
                  (IteratorCopyFunc)&iteratorCopy< T >,
                  (IteratorStartEndFunc)&iteratorBegin< T >,
                  (IteratorStartEndFunc)&iteratorEnd< T >,
                  (IteratorIncFunc)&iteratorNext< T >,
                  (IteratorIncFunc)&iteratorPrev< T >,
                  (IteratorMoveFunc)&iteratorMove< T >,
                  (IteratorDistanceFunc)&iteratorDistance< T >,
                  (IteratorValueFunc)&iteratorValue< T >,
                  (IteratorValueFunc)&iteratorKey< T >,
                  (IteratorComparisonFunc)&iteratorEqual< T >,
                  (IteratorCountFunc)&iteratorCount< T >,
                  (IteratorFindFunc)&iteratorFindMap< T, typename T::key_type >);
        
    }
    
    template< typename T > 
    static void registerIterators (typename T::value_type *a = (typename T::value_type *)0) {
        Q_UNUSED(a)
        int valueType = qMetaTypeId< typename T::value_type > ();
        
        registerIterator (qMetaTypeId< T > (), valueType, 0,
                  (IteratorDtorFunc)&iteratorDtor< T >,
                  (IteratorCopyFunc)&iteratorCopy< T >,
                  (IteratorStartEndFunc)&iteratorBegin< T >,
                  (IteratorStartEndFunc)&iteratorEnd< T >,
                  (IteratorIncFunc)&iteratorNext< T >,
                  (IteratorIncFunc)&iteratorPrev< T >,
                  (IteratorMoveFunc)&iteratorMove< T >,
                  (IteratorDistanceFunc)&iteratorDistance< T >,
                  (IteratorValueFunc)&iteratorValue< T >,
                  0,
                  (IteratorComparisonFunc)&iteratorEqual< T >,
                  (IteratorCountFunc)&iteratorCount< T >,
                  (IteratorFindFunc)&iteratorFindList< T, typename T::value_type >);
        
    }
    
    class NURIA_CORE_EXPORT Iterator {
    public:
        
        Iterator ();
        Iterator (const Iterator &other);
        ~Iterator ();
        
        bool isValid () const;
        
        const Iterator &operator= (const Iterator &other);
        
        bool operator== (const Iterator &other) const;
        inline bool operator!= (const Iterator &other) const
        { return !(*this == other); }
        
        Iterator &operator++ ();
        inline Iterator &operator++ (int) { return operator++ (); }
        
        Iterator &operator-- ();
        inline Iterator &operator-- (int) { return operator--(); }
        const Iterator &operator+= (int n);
        const Iterator &operator-= (int n);
        Iterator operator+ (int n) const;
        Iterator operator- (int n) const;
        int operator- (const Iterator &other) const;
        
        QVariant key () const;
        QVariant value () const;
        
        inline QVariant operator* () const
        { return value (); }
        
    private:
        friend class Nuria::Variant;
        Iterator (const QVariant &variant, void *iter, void *info, int pos);
        VariantIteratorPrivate *d_ptr;
        
    };
    
    static Iterator begin (QVariant &variant);
    
    static Iterator end (QVariant &variant);
    
    static Iterator find (QVariant &variant, QVariant ident);
    
    static int itemCount (const QVariant &variant);
    
    static bool isList (const QVariant &variant);
    
    static bool isList (int typeId);
    
    static bool isMap (const QVariant &variant);
    
    static bool isMap (int typeId);
    
    static bool isGeneric (const QVariant &variant);
    
    static bool isGeneric (int typeId);
    
    static QVariantList toList (QVariant variant);
    
    static QVariantMap toMap (QVariant variant);
    
    template< typename ... Items >
    static QVariantList buildList (const Items &... items) {
        QVariantList list;
        buildListImpl (list, items ...);
        return list;
    }
    
    static void *stealPointer (QVariant &variant);
    
private:
    
    // We use C-style casts here so this code doesn't get more unreadable...
    template< typename T > inline static void iteratorDtor (void *t)
    { delete (typename T::const_iterator *)t; }
    
    template< typename T > inline static void *iteratorCopy (void *t)
    { return (void *)(new typename T::const_iterator (*(typename T::const_iterator *)t)); }
    
    template< typename T > inline static void *iteratorBegin (void *t)
    { return (void *)(new typename T::const_iterator (((T *)t)->constBegin ())); }
    
    template< typename T > inline static void *iteratorEnd (void *t)
    { return (void *)(new typename T::const_iterator (((T *)t)->constEnd ())); }
    
    template< typename T > inline static void iteratorMove (void *t, int n)
    { (*static_cast< typename T::const_iterator * > (t)) += n; }
    
    template< typename T > inline static int iteratorDistance (void *t, void *o) {
        typename T::const_iterator *l = static_cast< typename T::const_iterator * > (t);
        typename T::const_iterator *r = static_cast< typename T::const_iterator * > (o);
        return std::distance (*l, *r);
    }
    
    template< typename T > inline static void iteratorNext (void *t)
    { ++(*static_cast< typename T::const_iterator * > (t)); }
    
    template< typename T > inline static void iteratorPrev (void *t)
    { --(*static_cast< typename T::const_iterator * > (t)); }
    
    template< typename T > inline static QVariant iteratorKey (void *t, int type)
    { return QVariant::fromValue (static_cast< typename T::const_iterator * > (t)->key ()); }
    
    template< typename T > inline static QVariant iteratorValue (void *t, int) {
        return QVariant::fromValue (*(*static_cast< typename T::const_iterator * > (t)));
    }
    
    template< typename T > inline static bool iteratorEqual (void *t, void *r) {
        typename T::const_iterator &left = *static_cast< typename T::const_iterator * > (t);
        typename T::const_iterator &right = *static_cast< typename T::const_iterator * > (r);
        return (left == right);
    }
    
    template< typename T > inline static int iteratorCount (void *t)
    { return static_cast< T * > (t)->count (); }
    
    template< typename T, typename Key > inline static void *iteratorFindMap (void *t, const QVariant &what) {
        typename T::const_iterator it = static_cast< T * > (t)
                        ->find (*static_cast< const Key * >(what.constData ()));
        if (it == static_cast< T * > (t)->end ())
            return 0;
        return (void *)(new typename T::const_iterator (it));
    }
    
    template< typename T, typename Key > inline static void *iteratorFindList (void *t, const QVariant &what) {
        T *list = static_cast< T * > (t);
        const Key *item = static_cast< const Key * > (qMetaTypeId< Key > () == QMetaType::QVariant
                                  ? &what : what.constData ());
        
        typename T::const_iterator it = list->begin ();
        typename T::const_iterator end = list->end ();
        
        if (qMetaTypeId< Key > () != QMetaType::QVariant) {
            for (; it != end; ++it) {
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
                if (equal (*it, what))
#else
                if ((*it).operator== (*item))
#endif
                    return new typename T::const_iterator (it);
            }
        } else {
            for (; it != end; ++it) {
                if (equal (*it, *item))
                    return new typename T::const_iterator (it);
            }
        }
        
        return 0;
    }
    
    template< typename From, typename To >
    static To *autoConvTempl (From *from)
    { return new To (*from); }
    
    static void registerIterator (int type, int valueType, int keyType,
                      IteratorDtorFunc dtor, IteratorCopyFunc copy,
                      IteratorStartEndFunc start, IteratorStartEndFunc end,
                      IteratorIncFunc increment, IteratorIncFunc decrement,
                      IteratorMoveFunc move, IteratorDistanceFunc distance,
                      IteratorValueFunc value, IteratorValueFunc key,
                      IteratorComparisonFunc equal,
                      IteratorCountFunc count, IteratorFindFunc find);
    
    template< typename T > static inline const T &passThrough (const T &t) { return t; }
    
    // Simplifies usage for buildList.
#ifndef NURIA_NO_CHAR_ARRAY_TO_QSTRING
    static inline QString passThrough (const char *str) { return QString (str); }
#endif
    
    static inline void buildListImpl (QVariantList &) { }
    
    // 
    template< typename T, typename ... Items >
    static inline void buildListImpl (QVariantList &list, const T &cur, const Items & ... items) {
        list.append (QVariant::fromValue (passThrough (cur)));
        buildListImpl (list, items ...);
    }
    
    Variant ();
    
};

}

#ifdef NURIA_VARIANT_COMPARISON
inline bool operator== (const QVariant &left, const QVariant &right)
{ return Nuria::Variant::equal (left, right); }

inline bool operator!= (const QVariant &left, const QVariant &right)
{ return Nuria::Variant::notEqual (left, right); }

inline bool operator< (const QVariant &left, const QVariant &right)
{ return Nuria::Variant::lessThan (left, right); }

inline bool operator> (const QVariant &left, const QVariant &right)
{ return Nuria::Variant::greaterThan (left, right); }

inline bool operator<= (const QVariant &left, const QVariant &right)
{ return Nuria::Variant::lessEqualThan (left, right); }

inline bool operator>= (const QVariant &left, const QVariant &right)
{ return Nuria::Variant::greaterEqualThan (left, right); }
#endif

#define VARIANT_FOREACH(variable, variant) \
    for (Nuria::Variant::Iterator _niter_ = Nuria::Variant::begin (variant), \
    _nend_ = Nuria::Variant::end (variant); \
    _niter_ != _nend_; ++_niter_) \
    if (!(variable = _niter_.value()).isNull ())

#endif // NURIA_VARIANT_HPP