LuaArguments.h

Go to the documentation of this file.

#pragma once
// QLua - Copyright (c) 2012, Ugo Varetto
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the <organization> nor the
//       names of its contributors may be used to endorse or promote products
//       derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL UGO VARETTO BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


extern "C" {
#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"
}

#include <QString>
#include <QVariantMap>
#include <QVariantList>
#include <QString>
#include <QList>
#include <QGenericArgument>
#include <QGenericReturnArgument>
#include <QVector>

#include "LuaQtTypes.h"

namespace qlua {

//------------------------------------------------------------------------------
struct QArgConstructor {
    virtual QGenericArgument Create( lua_State*, int ) const = 0;
    virtual ~QArgConstructor() {}
    virtual QArgConstructor* Clone() const = 0;

};
class IntQArgConstructor : public QArgConstructor {
public:
    QGenericArgument Create( lua_State* L, int idx ) const {
        i_ = luaL_checkint( L, idx );
        return Q_ARG( int, i_ );
    }
    IntQArgConstructor* Clone() const {
        return new IntQArgConstructor( *this );
    }
private:
    mutable int i_;
};
class FloatQArgConstructor : public QArgConstructor {
public:
    QGenericArgument Create( lua_State* L, int idx ) const {
        f_ = float( luaL_checknumber( L, idx ) );
        return Q_ARG( double, f_ );
    }
    FloatQArgConstructor* Clone() const {
        return new FloatQArgConstructor( *this );
    }
private:
    mutable float f_;
};
class DoubleQArgConstructor : public QArgConstructor {
public:
    QGenericArgument Create( lua_State* L, int idx ) const {
        d_ = luaL_checknumber( L, idx );
        return Q_ARG( double, d_ );
    }
    DoubleQArgConstructor* Clone() const {
        return new DoubleQArgConstructor( *this );
    }
private:
    mutable double d_;
};
class StringQArgConstructor : public QArgConstructor {
public:
    QGenericArgument Create( lua_State* L, int idx ) const {
        s_ = luaL_checkstring( L, idx ); 
        return Q_ARG( QString, s_ );
    }
    StringQArgConstructor* Clone() const {
        return new StringQArgConstructor( *this );
    }
private:
    mutable QString s_;
};
class VariantMapQArgConstructor : public QArgConstructor {
public:
    QGenericArgument Create( lua_State* L, int idx ) const {
        vm_ = ParseLuaTable( L, idx );
        return Q_ARG( QVariantMap, vm_ );
    }
    VariantMapQArgConstructor* Clone() const {
        return new VariantMapQArgConstructor( *this );
    }
private:
    mutable QVariantMap vm_;
};
class VariantListQArgConstructor : public QArgConstructor {
public:
    QGenericArgument Create( lua_State* L, int idx ) const {
        vl_ = ParseLuaTableAsVariantList( L, idx );
        return Q_ARG( QVariantList, vl_ );
    }
    VariantListQArgConstructor* Clone() const {
        return new VariantListQArgConstructor( *this );
    }
private:
    mutable QVariantList vl_;
};
class ObjectStarQArgConstructor : public QArgConstructor {
public:
    QGenericArgument Create( lua_State* L, int idx ) const {
        if( lua_istable( L, idx ) ) {
            lua_pushstring( L, "qobject__" );
            lua_gettable( L, idx );
            obj_ = *reinterpret_cast< QObject** >( lua_touserdata( L, -1 ) );
            lua_pop( L, 1 );
        } else if( lua_islightuserdata( L, idx ) ) {
            obj_ = reinterpret_cast< QObject* >( lua_touserdata( L, -1 ) );
        }
        return Q_ARG( QObject*, obj_ );
    }
    ObjectStarQArgConstructor* Clone() const {
        return new ObjectStarQArgConstructor( *this );
    }
private:
    mutable QObject* obj_;
};
class WidgetStarQArgConstructor : public QArgConstructor {
public:
    QGenericArgument Create( lua_State* L, int idx ) const {
        if( lua_istable( L, idx ) ) {
            lua_pushstring( L, "qobject__" );
            lua_gettable( L, idx );
            w_ = *reinterpret_cast< QWidget** >( lua_touserdata( L, -1 ) );
            lua_pop( L, 1 );
        } else if( lua_islightuserdata( L, idx ) ) {
            w_ = reinterpret_cast< QWidget* >( lua_touserdata( L, -1 ) );
        }
        return Q_ARG( QWidget*, w_ );
    }
    WidgetStarQArgConstructor* Clone() const {
        return new WidgetStarQArgConstructor( *this );
    }
private:
    mutable QWidget* w_;
};
class VoidStarQArgConstructor : public QArgConstructor {
public:
    QGenericArgument Create( lua_State* L, int idx ) const {
        v_ = const_cast< void* >( lua_topointer( L, idx ) );
        return Q_ARG( void*, v_ );
    }
    VoidStarQArgConstructor* Clone() const {
        return new VoidStarQArgConstructor( *this );
    }
private:
    mutable void* v_;
};
template< typename T >
class ListQArgConstructor : public QArgConstructor {
public:
    QGenericArgument Create( lua_State* L, int idx ) const {
        l_ = ParseLuaTableAsNumberList< T >( L, idx );
        return Q_ARG( QList< T >, l_ );
    }
    ListQArgConstructor* Clone() const {
        return new ListQArgConstructor< T >( *this );
    }
private:
    mutable QList< T > l_;
};
template< typename T >
class VectorQArgConstructor : public QArgConstructor {
public:
    QGenericArgument Create( lua_State* L, int idx ) const {
        v_ = ParseLuaTableAsNumberVector< T >( L, idx );
        return Q_ARG( QVector< T >, v_ );
    }
    VectorQArgConstructor* Clone() const {
        return new VectorQArgConstructor< T >( *this );
    }
private:
    mutable QVector< T > v_;
};
class StringListQArgConstructor : public QArgConstructor {
public:
    QGenericArgument Create( lua_State* L, int idx ) const {
        l_ = ParseLuaTableAsStringList( L, idx );
        return Q_ARG( QStringList, l_ );
    }
    StringListQArgConstructor* Clone() const {
        return new StringListQArgConstructor( *this );
    }
private:
    mutable QStringList l_;
};
//------------------------------------------------------------------------------
class LArgConstructor {
public:
    virtual void Push( lua_State* ) const = 0;
    virtual void Push( lua_State* , void* ) const = 0;
    virtual ~LArgConstructor() {}
    virtual LArgConstructor* Clone() const = 0;
    virtual QMetaType::Type Type() const = 0;
    QGenericReturnArgument Argument() const { return ga_; }
    virtual bool IsQObjectPtr() const { return false; }
protected:
    template < typename T > void SetArg( T& arg ) {
        ga_ = QReturnArgument< T >( QMetaType::typeName( Type() ), arg );
    }
    QGenericReturnArgument ga_; // not private, breaks encapsulation
};
class IntLArgConstructor : public LArgConstructor {
public:
    IntLArgConstructor() {
        SetArg( i_ );
    }
    IntLArgConstructor( const IntLArgConstructor& other ) : i_( other.i_ ) {
        SetArg( i_ );
    }
    void Push( lua_State* L ) const {
        lua_pushinteger( L, i_ );
    }
    void Push( lua_State* L, void* value ) const {
        lua_pushinteger( L, *reinterpret_cast< int* >( value ) );
    }
    IntLArgConstructor* Clone() const {
        return new IntLArgConstructor( *this );
    }
    QMetaType::Type Type() const { return QMetaType::Int; }
private:
    int i_; 
};
class DoubleLArgConstructor : public LArgConstructor {
public:
    DoubleLArgConstructor() {
       SetArg( d_ ); 
    }
    DoubleLArgConstructor( const DoubleLArgConstructor& other ) : d_( other.d_ ) {
       SetArg( d_ );
    }
    void Push( lua_State* L ) const {
        lua_pushnumber( L, d_ );
    }
    void Push( lua_State* L, void* value ) const {
        lua_pushnumber( L, *reinterpret_cast< double* >( value ) );
    }
    DoubleLArgConstructor* Clone() const {
        return new DoubleLArgConstructor( *this );
    }
    QMetaType::Type Type() const { return QMetaType::Double; }
private:
    double d_;
};
class FloatLArgConstructor : public LArgConstructor {
public:
    FloatLArgConstructor() {
       SetArg( f_ ); 
    }
    FloatLArgConstructor( const FloatLArgConstructor& other ) : f_( other.f_ ) {
       SetArg( f_ );
    }
    void Push( lua_State* L ) const {
        lua_pushnumber( L, f_ );
    }
    void Push( lua_State* L, void* value ) const {
        lua_pushnumber( L, *reinterpret_cast< float* >( value ) );
    }
    FloatLArgConstructor* Clone() const {
        return new FloatLArgConstructor( *this );
    }
    QMetaType::Type Type() const { return QMetaType::Float; }
private:
    float f_;
};
class StringLArgConstructor : public LArgConstructor {
public:
    StringLArgConstructor() {
        SetArg( s_ );
    }
    StringLArgConstructor( const StringLArgConstructor& other ) : s_( other.s_ ) {
        SetArg( s_ );
    }
    void Push( lua_State* L ) const {
        lua_pushstring( L, s_.toAscii().constData() );
    }
    void Push( lua_State* L, void* value ) const {
        lua_pushstring( L, reinterpret_cast< QString* >( value )->toAscii().constData() );
    }
    StringLArgConstructor* Clone() const {
        return new StringLArgConstructor( *this );
    }
    QMetaType::Type Type() const { return QMetaType::QString; }
private:
    QString s_;
};
class VoidLArgConstructor : public LArgConstructor {
public:
    void Push( lua_State*  ) const {}
    void Push( lua_State*, void* ) const {}
    VoidLArgConstructor* Clone() const {
        return new VoidLArgConstructor( *this );
    }
    QMetaType::Type Type() const { return QMetaType::Void; }
};
class VariantMapLArgConstructor : public LArgConstructor {
public:
    VariantMapLArgConstructor() {
        SetArg( vm_ );   
    }
    VariantMapLArgConstructor( const VariantMapLArgConstructor& other ) : vm_( other.vm_ ) {
        SetArg( vm_ );
    }
    void Push( lua_State* L ) const {
        VariantMapToLuaTable( vm_, L );
    }
    void Push( lua_State* L, void* value ) const {
        VariantMapToLuaTable( *reinterpret_cast< QVariantMap* >( value ), L );
    }
    VariantMapLArgConstructor* Clone() const {
        return new VariantMapLArgConstructor( *this );
    }
    QMetaType::Type Type() const { return QMetaType::QVariantMap; }
private:
    QVariantMap vm_;
};
class VariantListLArgConstructor : public LArgConstructor {
public:
    VariantListLArgConstructor() {
        SetArg( vl_ );   
    }
    VariantListLArgConstructor( const VariantListLArgConstructor& other ) : vl_( other.vl_ ) {
        SetArg( vl_ );
    }
    void Push( lua_State* L ) const {
        VariantListToLuaTable( vl_, L );
    }
    void Push( lua_State* L, void* value ) const {
        VariantListToLuaTable( *reinterpret_cast< QVariantList* >( value ), L );
    }
    VariantListLArgConstructor* Clone() const {
        return new VariantListLArgConstructor( *this );
    }
    QMetaType::Type Type() const { return QMetaType::QVariantList; }
private:
    QVariantList vl_;
};
class ObjectStarLArgConstructor : public LArgConstructor {
public:
    ObjectStarLArgConstructor() {
        SetArg( obj_ );   
    }
    ObjectStarLArgConstructor( const ObjectStarLArgConstructor& other ) : obj_( other.obj_ ) {
        SetArg( obj_ );
    }
    void Push( lua_State* L ) const {
        lua_pushlightuserdata( L, obj_ );
    }
    void Push( lua_State* L, void* value ) const {
        lua_pushlightuserdata( L,  value );
    }
    ObjectStarLArgConstructor* Clone() const {
        return new ObjectStarLArgConstructor( *this );
    }
    bool IsQObjectPtr() const { return true; }
    QMetaType::Type Type() const { return QMetaType::QObjectStar; }
private:
    QObject* obj_;
};
class WidgetStarLArgConstructor : public LArgConstructor {
public:
    WidgetStarLArgConstructor() {
        SetArg( w_ );   
    }
    WidgetStarLArgConstructor( const WidgetStarLArgConstructor& other ) : w_( other.w_ ) {
        SetArg( w_ );
    }
    void Push( lua_State* L ) const {
        lua_pushlightuserdata( L, w_ );
    }
    void Push( lua_State* L, void* value ) const {
        lua_pushlightuserdata( L,  value );
    }
    WidgetStarLArgConstructor* Clone() const {
        return new WidgetStarLArgConstructor( *this );
    }
    bool IsQObjectPtr() const { return true; }
    QMetaType::Type Type() const { return QMetaType::QWidgetStar; }
private:
    QWidget* w_;
};
class VoidStarLArgConstructor : public LArgConstructor {
public:
    VoidStarLArgConstructor() {
        SetArg( v_ );   
    }
    VoidStarLArgConstructor( const VoidStarLArgConstructor& other ) : v_( other.v_ ) {
        SetArg( v_ );
    }
    void Push( lua_State* L ) const {
        lua_pushlightuserdata( L, v_ );
    }
    void Push( lua_State* L, void* value ) const {
        lua_pushlightuserdata( L,  value );
    }
    VoidStarLArgConstructor* Clone() const {
        return new VoidStarLArgConstructor( *this );
    }
    QMetaType::Type Type() const { return QMetaType::VoidStar; }
private:
    void* v_;
};
template < typename T >
class ListLArgConstructor : public LArgConstructor {
public:
    ListLArgConstructor() {
        SetArg( l_ );   
    }
    ListLArgConstructor( const ListLArgConstructor& other ) : l_( other.l_ ) {
        SetArg( l_ );
    }
    void Push( lua_State* L ) const {
        NumberListToLuaTable< T >( l_, L );
    }
    void Push( lua_State* L, void* value ) const {
        NumberListToLuaTable< T >( *reinterpret_cast< QList< T >* >( value ), L );
    }
    ListLArgConstructor* Clone() const {
        return new ListLArgConstructor( *this );
    }
    QMetaType::Type Type() const { return QMetaType::Type( QMetaType::type( TypeName< QList< T > >() ) ); }
private:
    QList< T > l_;
};
template < typename T >
class VectorLArgConstructor : public LArgConstructor {
public:
    VectorLArgConstructor() {
        SetArg( v_ );   
    }
    VectorLArgConstructor( const VectorLArgConstructor& other ) : v_( other.v_ ) {
        SetArg( v_ );
    }
    void Push( lua_State* L ) const {
        NumberVectorToLuaTable< T >( v_, L );
    }
    void Push( lua_State* L, void* value ) const {
        NumberVectorToLuaTable< T >( *reinterpret_cast< QVector< T >* >( value ), L );
    }
    VectorLArgConstructor* Clone() const {
        return new VectorLArgConstructor( *this );
    }
    QMetaType::Type Type() const { return QMetaType::Type( QMetaType::type( TypeName< QVector< T > >() ) ); }
private:
    QVector< T > v_;
};
class StringListLArgConstructor : public LArgConstructor {
public:
    StringListLArgConstructor() {
        SetArg( l_ );   
    }
    StringListLArgConstructor( const StringListLArgConstructor& other ) : l_( other.l_ ) {
        SetArg( l_ );
    }
    void Push( lua_State* L ) const {
        StringListToLuaTable( l_, L );
    }
    void Push( lua_State* L, void* value ) const {
        StringListToLuaTable( *reinterpret_cast< QStringList* >( value ), L );
    }
    StringListLArgConstructor* Clone() const {
        return new StringListLArgConstructor( *this );
    }
    QMetaType::Type Type() const { return QMetaType::Type( QMetaType::type( TypeName< QList< QString > >() ) ); }
private:
    QStringList l_;
};

//------------------------------------------------------------------------------
class QArgWrapper {
public:
    QArgWrapper() : ac_( 0 ) {}
    QArgWrapper( const QArgWrapper& other ) : ac_( 0 ) {
        if( other.ac_ ) ac_ = other.ac_->Clone();
    }
    QArgWrapper( const QString& type ) : ac_( 0 ) {
        if( type == QMetaType::typeName( QMetaType::Int ) ) {
            ac_ = new IntQArgConstructor;
        } else if( type == QMetaType::typeName( QMetaType::Double ) ) {
            ac_ = new DoubleQArgConstructor;
        } else if( type == QMetaType::typeName( QMetaType::Float ) ) {
            ac_ = new FloatQArgConstructor;
        } else if( type == QMetaType::typeName( QMetaType::QString ) ) {
            ac_ = new StringQArgConstructor;
        } else if( type == QMetaType::typeName( QMetaType::QVariantMap ) ) {
            ac_ = new VariantMapQArgConstructor;
        } else if( type == QMetaType::typeName( QMetaType::QVariantList ) ) {
            ac_ = new VariantListQArgConstructor;
        } else if( type == QMetaType::typeName( QMetaType::QObjectStar ) ) {
            ac_ = new ObjectStarQArgConstructor;
        } else if( type == QMetaType::typeName( QMetaType::QStringList ) ) {
            ac_ = new StringListQArgConstructor;
        } else if( type == QMetaType::typeName( QMetaType::QWidgetStar ) ) {
            ac_ = new WidgetStarQArgConstructor;
        } else if( type == QMetaType::typeName( QMetaType::VoidStar ) ) {
            ac_ = new VoidStarQArgConstructor;
        } else if( type == QLUA_LIST_FLOAT64 ) {
            ac_ = new ListQArgConstructor< double >;
        } else if( type == QLUA_LIST_FLOAT32 ) {
            ac_ = new ListQArgConstructor< float >;
        } else if( type == QLUA_LIST_INT ) {
            ac_ = new ListQArgConstructor< int >;
        } else if( type == QLUA_LIST_SHORT ) {
            ac_ = new ListQArgConstructor< short >;
        } else if( type == QLUA_VECTOR_FLOAT64 ) {
            ac_ = new VectorQArgConstructor< double >;
        } else if( type == QLUA_VECTOR_FLOAT32 ) {
            ac_ = new VectorQArgConstructor< float >;
        } else if( type == QLUA_VECTOR_INT ) {
            ac_ = new VectorQArgConstructor< int >;
        } else if( type == QLUA_VECTOR_SHORT ) {
            ac_ = new VectorQArgConstructor< short >;
        } else throw std::logic_error( ( "Type " + type + " unknown" ).toStdString() );
    }
    QGenericArgument Arg( lua_State* L, int idx ) const {
        return ac_ ? ac_->Create( L, idx ) : QGenericArgument();
    }
    ~QArgWrapper() { delete ac_; }
private:
    QArgConstructor* ac_;    
};

class LArgWrapper {
public:
    LArgWrapper() : ac_( 0 ) {}
    LArgWrapper( const LArgWrapper& other ) : ac_( 0 ), type_( other.type_ ) {
        if( other.ac_ ) ac_ = other.ac_->Clone();
    }
    LArgWrapper( const QString& type ) : ac_( 0 ), type_( type ) {
        if( type_ == QMetaType::typeName( QMetaType::Int ) ) {
            ac_ = new IntLArgConstructor;
        } else if( type == QMetaType::typeName( QMetaType::Double ) ) {
            ac_ = new DoubleLArgConstructor;
        } else if( type == QMetaType::typeName( QMetaType::Float ) ) {
            ac_ = new FloatLArgConstructor;
        } else if( type_ == QMetaType::typeName( QMetaType::QString ) ) {
            ac_ = new StringLArgConstructor;
        } else if( type_ == QMetaType::typeName( QMetaType::QVariantMap ) ) {
            ac_ = new VariantMapLArgConstructor;
        } else if( type_ == QMetaType::typeName( QMetaType::QVariantList ) ) {
            ac_ = new VariantListLArgConstructor;
        } else if( type == QMetaType::typeName( QMetaType::QObjectStar ) ) {
            ac_ = new ObjectStarLArgConstructor;
        } else if( type == QMetaType::typeName( QMetaType::QStringList ) ) {
            ac_ = new StringListLArgConstructor;
        } else if( type == QMetaType::typeName( QMetaType::QWidgetStar ) ) {
            ac_ = new WidgetStarLArgConstructor;
        } else if( type == QMetaType::typeName( QMetaType::VoidStar ) ) {
            ac_ = new VoidStarLArgConstructor;
        } else if( type == QLUA_LIST_FLOAT64 ) {
            ac_ = new ListLArgConstructor< double >;
        } else if( type == QLUA_LIST_FLOAT32 ) {
            ac_ = new ListLArgConstructor< float >;
        } else if( type == QLUA_LIST_INT ) {
            ac_ = new ListLArgConstructor< int >;
        } else if( type == QLUA_LIST_SHORT ) {
            ac_ = new ListLArgConstructor< short >;
        } else if( type == QLUA_VECTOR_FLOAT64 ) {
            ac_ = new VectorLArgConstructor< double >;
        } else if( type == QLUA_VECTOR_FLOAT32 ) {
            ac_ = new VectorLArgConstructor< float >;
        } else if( type == QLUA_VECTOR_INT ) {
            ac_ = new VectorLArgConstructor< int >;
        } else if( type == QLUA_VECTOR_SHORT ) {
            ac_ = new VectorLArgConstructor< short >;
        } else if( type_.isEmpty() ) ac_ = new VoidLArgConstructor;
        else throw std::logic_error( ( "Type " + type + " unknown" ).toStdString() );
    }
    void Push( lua_State* L ) const {
        ac_->Push( L );
    }
    void Push( lua_State* L, void* value ) const {
        ac_->Push( L, value ); // called from the callback dispatcher method
    }
    QGenericReturnArgument Arg() const { return ac_->Argument(); }
    const QString& Type() const { 
        return type_;
    }
    QMetaType::Type MetaType() const { return ac_->Type(); }
    bool IsQObjectPtr() const { return ac_->IsQObjectPtr(); }
    ~LArgWrapper() { delete ac_; }
private:
    LArgConstructor* ac_;
    QString type_;
};

typedef QList< QArgWrapper > QArgWrappers;
typedef QList< QByteArray > ArgumentTypes;

inline QArgWrappers GenerateQArgWrappers( const ArgumentTypes& at ) {
    QArgWrappers aw;
    for( ArgumentTypes::const_iterator i = at.begin(); i != at.end(); ++i ) {
        aw.push_back( QArgWrapper( *i ) );
    }
    return aw;
}
inline LArgWrapper GenerateLArgWrapper( const QString& typeName ) {
    return LArgWrapper( typeName );
}

}