callback.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_CALLBACK_HPP
#define NURIA_CALLBACK_HPP

#include <type_traits>
#include <functional>

#include <QSharedData>
#include <QMetaType>
#include <QVariant>
#include <QList>

#include "essentials.hpp"
#include "variant.hpp"

namespace Nuria {
class CallbackPrivate;

namespace CallbackHelper {
    template< int ... Index >
    struct IndexTuple {
        template< int N >
        using append = IndexTuple< Index ..., N >;
    };
    
    template< int Size >
    struct CreateIndexTuple {
        typedef typename CreateIndexTuple< Size - 1 >::type::template append< Size - 1 > type;
    };
    
    template< >
    struct CreateIndexTuple< 1 > {
        typedef IndexTuple< > type;
    };
    
    template< typename... Types >
    using buildIndexTuple = typename CreateIndexTuple< sizeof...(Types) + 1 >::type;
    
    // qMetaTypeId wrapper, which returns 0 for T = void.
    template< typename T >
    constexpr int typeId () { return qMetaTypeId< T > (); }
    
    template< >
    constexpr int typeId< void > () { return 0; }
    
    // Creates a raw list of type ids and values from 'args'
    template< typename T >
        void getArguments (void **list, int *types, int idx, T *cur) {
            list[idx] = cur;
            types[idx] = qMetaTypeId< typename std::remove_const< T >::type > ();
        }
    
    template< typename T, typename T2, typename ... Args >
    void getArguments (void **list, int *types, int idx,
               T *cur, T2 *next, Args * ... args) {
        getArguments (list, types, idx, cur);
        getArguments (list, types, idx + 1, next, args ...);
    }
    
}

class NURIA_CORE_EXPORT Callback {
    
    // Forward declare helper structures
    struct TrampolineBase;
    template< typename Ret, typename ... Args > struct MethodHelper;
    template< typename Class, typename Ret, typename ... Args > struct MemberMethodHelper;
    template< typename FullType, typename Ret, typename ... Args > struct LambdaHelper;
    
public:
    
    enum Type {
        Invalid = 0, 
        StaticMethod = 1, 
        MemberMethod = 2, 
        Slot = 3, 
        Lambda = 4 
    };
    
    enum Placeholder {
        _1 = 0,
        _2,
        _3,
        _4,
        _5,
        _6,
        _7,
        _8,
        _9,
        _10
    };
    
    Callback ();
    
    explicit Callback (QObject *receiver, const char *slot, bool variadic = false);
    
    Callback (const Callback &other);
    
    template< typename Ret, typename ... Args >
    Callback (Ret (*func)(Args ...), bool variadic = false)
        : d (0) { setCallback (func); setVariadic (variadic); }
    
    template< typename Class, typename Ret, typename ... Args >
    Callback (Class *instance, Ret (Class::*func)(Args ...), bool variadic = false)
        : d (0) { setCallback (instance, func); setVariadic (variadic); }
    
    template< typename Ret, typename ... Args >
    Callback (const std::function< Ret(Args ...) > &func, bool variadic = false)
        : d (0) { setCallback (func); setVariadic (variadic); }
    
    template< typename Lambda >
    static Callback fromLambda (Lambda l, bool variadic = false) {
        Callback cb = fromLambdaImpl (l, &Lambda::operator());
        cb.setVariadic (variadic);
        return cb;
    }
    
    ~Callback ();
    
    Callback &operator= (const Callback &other);
    
    bool operator== (const Callback &other) const;
    
    bool isValid () const;
    
    Type type () const;
    
    bool isVariadic () const;
    
    void setVariadic (bool variadic);
    
    int returnType () const;
    
    QList< int > argumentTypes () const;
    
    // 
    template< typename Ret, typename ... Args >
    bool setCallback (Ret (*func)(Args ...)) {
        QList< int > args;
        buildArgList< Args ... > (args);
        return initBase (new MethodHelper< Ret, Args ... > (func),
                 CallbackHelper::typeId< Ret > (), args);
    }
    
    // Member methods
    template< typename Class, typename Ret, typename ... Args >
    bool setCallback (Class *instance, Ret (Class::*func)(Args ...)) {
        QList< int > args;
        buildArgList< Args ... > (args);
        return initBase (new MemberMethodHelper< Class, Ret, Args ... > (instance, func),
                 CallbackHelper::typeId< Ret > (), args);
    }
    
    // std::function
    template< typename Ret, typename ... Args >
    bool setCallback (std::function< Ret(Args ...) > func) {
        QList< int > args;
        buildArgList< Args ... > (args);
        return initBase (new LambdaHelper< std::function< Ret(Args ...) >, Ret, Args ... > (func),
                 CallbackHelper::typeId< Ret > (), args);
    }
    
    // QObject slot
    bool setCallback (QObject *receiver, const char *slot);
    
    // Convenience assignment operators
    template< typename Ret, typename ... Args >
    Callback &operator= (Ret (*func)(Args ...)) { setCallback (func); return *this; }
    
    void bindList (const QVariantList &arguments = QVariantList());
    
    template< typename Lambda, typename ... Args >
    static Callback boundLambda (Lambda func, const Args &... args) {
        Callback cb = fromLambdaImpl (func, &Lambda::operator());
        cb.bind (args ...);
        return cb;
    }
    
    template< typename ... Args >
    inline Callback &bind (const Args &... args) {
        bindList (Variant::buildList (args ...));
        return *this;
    }
    
    QVariant invoke (const QVariantList &arguments) const;
    
    template< typename ... Args >
    QVariant operator() (const Args &... args) const {
        void *list[sizeof... (Args)];
        int types[sizeof... (Args)];
        CallbackHelper::getArguments (list, types, 0, const_cast< Args * > (&args) ...);
        return invoke (sizeof... (Args), list, types);
    }
    
    inline QVariant operator() () {
        return invoke (0, 0, 0);
    }
    
private:
    
    friend class CallbackPrivate;
    
    QVariant invoke (int count, void **args, int *types) const;
    QVariant invokePrepared (const QVariantList &arguments) const;
    
    QVariant invokeInternal (int count, void **args, int *types) const;
    
    // If you have a error on line struct removeRef< T & >:
    // T& is not allowed for values. Use const T & or just T instead.
    template< typename T > struct removeRef { typedef T type; };
        template< typename T > struct removeRef< T & >; // Not allowed!
    template< typename T > struct removeRef< const T & > { typedef T type; };
    
    template< typename Lambda, typename Ret, typename ... Args >
    inline static Callback fromLambdaImpl (Lambda l, Ret (Lambda::*)(Args ...) const) {
        return Callback (std::function< Ret(Args ...) > (l));
    }
    
    bool initBase (TrampolineBase *base, int retType, const QList< int > &args);
    
    template< typename T1, typename ... T2 >
    inline void buildArgListDo (QList< int > &list, T1 cur, T2 ... next) {
        list.append (cur);
        buildArgListDo (list, next ...);
    }
    
    template< typename T >
    inline void buildArgListDo (QList< int > &list, T cur)
    { list.append (cur); }
    
    inline void buildArgListDo (QList< int > &) { }
    
    template< typename ... Args >
    inline void buildArgList (QList< int > &list) {
        buildArgListDo (list, qMetaTypeId< typename removeRef< Args >::type > () ...);
    }
    
    struct TrampolineBase {
        Type type;
        TrampolineBase (Type t) : type (t) {}
        
        virtual ~TrampolineBase () {}
        virtual void trampoline (void **) = 0;
    };
    
    struct MemberTrampolineBase : TrampolineBase {
        MemberTrampolineBase (void *inst) : TrampolineBase (MemberMethod), instance (inst) {}
        void *instance;
    };
    
    // Static methods
    template< typename Ret, typename ... Args >
    struct MethodHelper : public TrampolineBase {
        typedef Ret (*Prototype)(Args ...);
        Prototype func;
        
        MethodHelper (Prototype f) : TrampolineBase (StaticMethod), func (f) {}
        
        template< int ... Index >
        inline void trampolineImpl (void **args, CallbackHelper::IndexTuple< Index... >) {
            (*reinterpret_cast< typename removeRef< Ret >::type * > (args[0])) =
                func (*reinterpret_cast< typename removeRef< Args >::type * >(args[Index]) ...);
        }
        
        void trampoline (void **args)
        { trampolineImpl (args, CallbackHelper::buildIndexTuple< Args ... > ()); }
        
    };
    
    template< typename ... Args >
    struct MethodHelper< void, Args ... > : public TrampolineBase {
        typedef void (*Prototype)(Args ...);
        Prototype func;
        
        MethodHelper (Prototype f) : TrampolineBase (StaticMethod), func (f) {}
        
        template< int ... Index >
        inline void trampolineImpl (void **args, CallbackHelper::IndexTuple< Index... >) {
            Q_UNUSED(args);
            func (*reinterpret_cast< typename removeRef< Args >::type * >(args[Index]) ...);
        }
        
        void trampoline (void **args)
        { trampolineImpl (args, CallbackHelper::buildIndexTuple< Args ... > ()); }
        
    };
    
    // Member methods
    template< typename Class, typename Ret, typename ... Args >
    struct MemberMethodHelper : public MemberTrampolineBase {
        typedef Ret (Class::*Prototype)(Args ...);
        Prototype func;
        
        MemberMethodHelper (Class *inst, Prototype f) : MemberTrampolineBase (inst), func (f) {}
        
        template< int ... Index >
        inline void trampolineImpl (void **args, CallbackHelper::IndexTuple< Index... >) {
            (*reinterpret_cast< typename removeRef< Ret >::type * > (args[0])) =
                    (reinterpret_cast< Class * > (instance)->*func)
                    (*reinterpret_cast< typename removeRef< Args >::type * >(args[Index]) ...);
        }
        
        void trampoline (void **args)
        { trampolineImpl (args, CallbackHelper::buildIndexTuple< Args ... > ()); }
        
    };
    
    template< typename Class, typename ... Args >
    struct MemberMethodHelper< Class, void, Args ... > : public MemberTrampolineBase {
        typedef void (Class::*Prototype)(Args ...);
        Prototype func;
        
        MemberMethodHelper (Class *inst, Prototype f) : MemberTrampolineBase (inst), func (f) {}
        
        template< int ... Index >
        inline void trampolineImpl (void **args, CallbackHelper::IndexTuple< Index... >) {
            Q_UNUSED(args);
            (reinterpret_cast< Class * > (instance)->*func)
                (*reinterpret_cast< typename removeRef< Args >::type * >(args[Index]) ...);
        }
        
        void trampoline (void **args)
        { trampolineImpl (args, CallbackHelper::buildIndexTuple< Args ... > ()); }
        
    };
    
    // std::function< ... >
    template< typename FullType, typename Ret, typename ... Args >
    struct LambdaHelper : public TrampolineBase {
        FullType func;
        
        LambdaHelper (const FullType &f) : TrampolineBase (Lambda), func (f) {}
        
        template< int ... Index >
        inline void trampolineImpl (void **args, CallbackHelper::IndexTuple< Index... >) {
            (*reinterpret_cast< typename removeRef< Ret >::type * > (args[0])) =
                func (*reinterpret_cast< typename removeRef< Args >::type * >(args[Index]) ...);
        }
        
        void trampoline (void **args)
        { trampolineImpl (args, CallbackHelper::buildIndexTuple< Args ... > ()); }
        
    };
    
    template< typename FullType, typename ... Args >
    struct LambdaHelper< FullType, void, Args ... > : public TrampolineBase {
        FullType func;
        
        LambdaHelper (const FullType &f) : TrampolineBase (Lambda), func (f) {}
        
        template< int ... Index >
        inline void trampolineImpl (void **args, CallbackHelper::IndexTuple< Index... >) {
            Q_UNUSED(args);
            func (*reinterpret_cast< typename removeRef< Args >::type * >(args[Index]) ...);
        }
        
        void trampoline (void **args)
        { trampolineImpl (args, CallbackHelper::buildIndexTuple< Args ... > ()); }
        
    };
    
    // d-ptr
    CallbackPrivate *d;
    
};
}

// 
Q_DECLARE_METATYPE(Nuria::Callback)
Q_DECLARE_METATYPE(Nuria::Callback::Placeholder)

#endif // NURIA_CALLBACK_HPP