call.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004-2005 by Reality Rift Studios                       *
 *   http://www.realityrift.com  -  mattias@realityrift.com                *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef neo_script_lua_call_h
#define neo_script_lua_call_h

#include "../../core/platform.h"

#if NEO_ENABLE_SCRIPT_LUA

#include "../../core/type.h"
#include "reference.h"
#include "conversion.h"

extern "C" {

#include "lua/lua.h"
    
}

namespace neo {
namespace script {
namespace lua {


template < class R > struct Call
{
    enum { isConst = core::TypeTraits< R >::isConst };
    
    template< class T, class P > static int call( lua_State* p_state, T* p_obj, R ( T::*f )(), P* )
    {
        Return< P >::push( p_state, (p_obj->*f)(), isConst );
        return 1;
    }

    template< class T, class P > static int call( lua_State* p_state, T* p_obj, R ( T::*f )() const, P* )
    {
        Return< P >::push( p_state, (p_obj->*f)(), isConst );
        return 1;
    }

    template< class T, class P, class A0 > static int call( lua_State* p_state, T* p_obj, R ( T::*f )( A0 ), P* )
    {
        Return< P >::push( p_state, (p_obj->*f)(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 )
        ), isConst );
        return 1;
    }

    template< class T, class P, class A0 > static int call( lua_State* p_state, T* p_obj, R ( T::*f )( A0 ) const, P* )
    {
        Return< P >::push( p_state, (p_obj->*f)(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 )
        ), isConst );
        return 1;
    }

    template< class T, class P, class A0, class A1 > static int call( lua_State* p_state, T* p_obj, R ( T::*f )( A0, A1 ), P* )
    {
        Return< P >::push( p_state, (p_obj->*f)(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 ),
            Argument< typename core::TypeTraits< A1 >::NonConstReferredType >::get( p_state, 3 )
        ), isConst );
        return 1;
    }

    template< class T, class P, class A0, class A1 > static int call( lua_State* p_state, T* p_obj, R ( T::*f )( A0, A1 ) const, P* )
    {
        Return< P >::push( p_state, (p_obj->*f)(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 ),
            Argument< typename core::TypeTraits< A1 >::NonConstReferredType >::get( p_state, 3 )
        ), isConst );
        return 1;
    }

    template< class T, class P, class A0, class A1, class A2 > static int call( lua_State* p_state, T* p_obj, R ( T::*f )( A0, A1, A2 ), P* )
    {
        Return< P >::push( p_state, (p_obj->*f)(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 ),
            Argument< typename core::TypeTraits< A1 >::NonConstReferredType >::get( p_state, 3 ),
            Argument< typename core::TypeTraits< A2 >::NonConstReferredType >::get( p_state, 4 )
        ), isConst );
        return 1;
    }

    template< class T, class P, class A0, class A1, class A2 > static int call( lua_State* p_state, T* p_obj, R ( T::*f )( A0, A1, A2 ) const, P* )
    {
        Return< P >::push( p_state, (p_obj->*f)(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 ),
            Argument< typename core::TypeTraits< A1 >::NonConstReferredType >::get( p_state, 3 ),
            Argument< typename core::TypeTraits< A2 >::NonConstReferredType >::get( p_state, 4 )
        ), isConst );
        return 1;
    }

    template< class T, class P, class A0, class A1, class A2, class A3 > static int call( lua_State* p_state, T* p_obj, R ( T::*f )( A0, A1, A2, A3 ), P* )
    {
        Return< P >::push( p_state, (p_obj->*f)(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 ),
            Argument< typename core::TypeTraits< A1 >::NonConstReferredType >::get( p_state, 3 ),
            Argument< typename core::TypeTraits< A2 >::NonConstReferredType >::get( p_state, 4 ),
            Argument< typename core::TypeTraits< A3 >::NonConstReferredType >::get( p_state, 5 )
        ), isConst );
        return 1;
    }

    template< class T, class P, class A0, class A1, class A2, class A3 > static int call( lua_State* p_state, T* p_obj, R ( T::*f )( A0, A1, A2, A3 ) const, P* )
    {
        Return< P >::push( p_state, (p_obj->*f)(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 ),
            Argument< typename core::TypeTraits< A1 >::NonConstReferredType >::get( p_state, 3 ),
            Argument< typename core::TypeTraits< A2 >::NonConstReferredType >::get( p_state, 4 ),
            Argument< typename core::TypeTraits< A3 >::NonConstReferredType >::get( p_state, 5 )
        ), isConst );
        return 1;
    }

    template< class P > static int call( lua_State* p_state, R ( *f )(), P* )
    {
        Return< P >::push( p_state, f(), isConst );
        return 1;
    }

    template< class P, class A0 > static int call( lua_State* p_state, R ( *f )( A0 ), P* )
    {
        Return< P >::push( p_state, f(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 1 )
        ), isConst );
        return 1;
    }

    template< class P, class A0, class A1 > static int call( lua_State* p_state, R ( *f )( A0, A1 ), P* )
    {
        Return< P >::push( p_state, f(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 1 ),
            Argument< typename core::TypeTraits< A1 >::NonConstReferredType >::get( p_state, 2 )
        ), isConst );
        return 1;
    }

    template< class P, class A0, class A1, class A2 > static int call( lua_State* p_state, R ( *f )( A0, A1, A2 ), P* )
    {
        Return< P >::push( p_state, f(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 1 ),
            Argument< typename core::TypeTraits< A1 >::NonConstReferredType >::get( p_state, 2 ),
            Argument< typename core::TypeTraits< A2 >::NonConstReferredType >::get( p_state, 3 )
        ), isConst );
        return 1;
    }

    template< class P, class A0, class A1, class A2, class A3 > static int call( lua_State* p_state, R ( *f )( A0, A1, A2, A3 ), P* )
    {
        Return< P >::push( p_state, f(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 1 ),
            Argument< typename core::TypeTraits< A1 >::NonConstReferredType >::get( p_state, 2 ),
            Argument< typename core::TypeTraits< A2 >::NonConstReferredType >::get( p_state, 3 ),
            Argument< typename core::TypeTraits< A3 >::NonConstReferredType >::get( p_state, 4 )
        ), isConst );
        return 1;
    }
};

template <> struct Call< void >
{
    template < class T > static int call( lua_State*, T* p_obj, void ( T::*f )(), void* )
    {
        (p_obj->*f)();
        return 0;
    }

    template < class T > static int call( lua_State*, T* p_obj, void ( T::*f )() const, void* )
    {
        (p_obj->*f)();
        return 0;
    }

    template< class T, class A0 > static int call( lua_State* p_state, T* p_obj, void ( T::*f )( A0 ), void* )
    {
        (p_obj->*f)(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 )
        );
        return 0;
    }

    template< class T, class A0 > static int call( lua_State* p_state, T* p_obj, void ( T::*f )( A0 ) const, void* )
    {
        (p_obj->*f)(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 )
        );
        return 0;
    }

    template< class T, class A0, class A1 > static int call( lua_State* p_state, T* p_obj, void ( T::*f )( A0, A1 ), void* )
    {
        (p_obj->*f)(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 ),
            Argument< typename core::TypeTraits< A1 >::NonConstReferredType >::get( p_state, 3 )
        );
        return 0;
    }

    template< class T, class A0, class A1 > static int call( lua_State* p_state, T* p_obj, void ( T::*f )( A0, A1 ) const, void* )
    {
        (p_obj->*f)(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 ),
            Argument< typename core::TypeTraits< A1 >::NonConstReferredType >::get( p_state, 3 )
        );
        return 0;
    }

    template< class T, class A0, class A1, class A2 > static int call( lua_State* p_state, T* p_obj, void ( T::*f )( A0, A1, A2 ), void* )
    {
        (p_obj->*f)(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 ),
            Argument< typename core::TypeTraits< A1 >::NonConstReferredType >::get( p_state, 3 ),
            Argument< typename core::TypeTraits< A2 >::NonConstReferredType >::get( p_state, 4 )
        );
        return 0;
    }

    template< class T, class A0, class A1, class A2 > static int call( lua_State* p_state, T* p_obj, void ( T::*f )( A0, A1, A2 ) const, void* )
    {
        (p_obj->*f)(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 ),
            Argument< typename core::TypeTraits< A1 >::NonConstReferredType >::get( p_state, 3 ),
            Argument< typename core::TypeTraits< A2 >::NonConstReferredType >::get( p_state, 4 )
        );
        return 0;
    }

    template< class T, class A0, class A1, class A2, class A3 > static int call( lua_State* p_state, T* p_obj, void ( T::*f )( A0, A1, A2, A3 ), void* )
    {
        (p_obj->*f)(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 ),
            Argument< typename core::TypeTraits< A1 >::NonConstReferredType >::get( p_state, 3 ),
            Argument< typename core::TypeTraits< A2 >::NonConstReferredType >::get( p_state, 4 ),
            Argument< typename core::TypeTraits< A3 >::NonConstReferredType >::get( p_state, 5 )
        );
        return 0;
    }

    template< class T, class A0, class A1, class A2, class A3 > static int call( lua_State* p_state, T* p_obj, void ( T::*f )( A0, A1, A2, A3 ) const, void* )
    {
        (p_obj->*f)(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 ),
            Argument< typename core::TypeTraits< A1 >::NonConstReferredType >::get( p_state, 3 ),
            Argument< typename core::TypeTraits< A2 >::NonConstReferredType >::get( p_state, 4 ),
            Argument< typename core::TypeTraits< A3 >::NonConstReferredType >::get( p_state, 5 )
        );
        return 0;
    }

    static int call( lua_State*, void ( *f )(), void* )
    {
        f();
        return 0;
    }

    template< class A0 > static int call( lua_State* p_state, void ( *f )( A0 ), void* )
    {
        f(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 )
        );
        return 0;
    }

    template< class A0, class A1 > static int call( lua_State* p_state, void ( *f )( A0, A1 ), void* )
    {
        f(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 ),
            Argument< typename core::TypeTraits< A1 >::NonConstReferredType >::get( p_state, 3 )
        );
        return 0;
    }

    template< class A0, class A1, class A2 > static int call( lua_State* p_state, void ( *f )( A0, A1, A2 ), void* )
    {
        f(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 ),
            Argument< typename core::TypeTraits< A1 >::NonConstReferredType >::get( p_state, 3 ),
            Argument< typename core::TypeTraits< A2 >::NonConstReferredType >::get( p_state, 4 )
        );
        return 0;
    }

    template< class A0, class A1, class A2, class A3 > static int call( lua_State* p_state, void ( *f )( A0, A1, A2, A3 ), void* )
    {
        f(
            Argument< typename core::TypeTraits< A0 >::NonConstReferredType >::get( p_state, 2 ),
            Argument< typename core::TypeTraits< A1 >::NonConstReferredType >::get( p_state, 3 ),
            Argument< typename core::TypeTraits< A2 >::NonConstReferredType >::get( p_state, 4 ),
            Argument< typename core::TypeTraits< A3 >::NonConstReferredType >::get( p_state, 5 )
        );
        return 0;
    }
};


template < class T, class R, class P > inline int call( lua_State* p_state, T* p_obj, R ( T::*f )(), P* p )
{
    return Call< R >::call( p_state, p_obj, f, p );
}


template < class T, class R, class P > inline int call( lua_State* p_state, T* p_obj, R ( T::*f )() const, P* p )
{
    return Call< R >::call( p_state, p_obj, f, p );
}


template < class T, class R, class P, class A0 > inline int call( lua_State* p_state, T* p_obj, R ( T::*f )( A0 ), P* p )
{
    return Call< R >::call( p_state, p_obj, f, p );
}


template < class T, class R, class P, class A0 > inline int call( lua_State* p_state, T* p_obj, R ( T::*f )( A0 ) const, P* p )
{
    return Call< R >::call( p_state, p_obj, f, p );
}


template < class T, class R, class P, class A0, class A1 > inline int call( lua_State* p_state, T* p_obj, R ( T::*f )( A0, A1 ), P* p )
{
    return Call< R >::call( p_state, p_obj, f, p );
}


template < class T, class R, class P, class A0, class A1 > inline int call( lua_State* p_state, T* p_obj, R ( T::*f )( A0, A1 ) const, P* p )
{
    return Call< R >::call( p_state, p_obj, f, p );
}


template < class T, class R, class P, class A0, class A1, class A2 > inline int call( lua_State* p_state, T* p_obj, R ( T::*f )( A0, A1, A2 ), P* p )
{
    return Call< R >::call( p_state, p_obj, f, p );
}


template < class T, class R, class P, class A0, class A1, class A2 > inline int call( lua_State* p_state, T* p_obj, R ( T::*f )( A0, A1, A2 ) const, P* p )
{
    return Call< R >::call( p_state, p_obj, f, p );
}


template < class T, class R, class P, class A0, class A1, class A2, class A3 > inline int call( lua_State* p_state, T* p_obj, R ( T::*f )( A0, A1, A2, A3 ), P* p )
{
    return Call< R >::call( p_state, p_obj, f, p );
}


template < class T, class R, class P, class A0, class A1, class A2, class A3 > inline int call( lua_State* p_state, T* p_obj, R ( T::*f )( A0, A1, A2, A3 ) const, P* p )
{
    return Call< R >::call( p_state, p_obj, f, p );
}


template < class R, class P > inline int call( lua_State* p_state, R ( *f )(), P* p )
{
    return Call< R >::call( p_state, f, p );
}


template < class R, class P, class A0 > inline int call( lua_State* p_state, R ( *f )( A0 ), P* p )
{
    return Call< R >::call( p_state, f, p );
}


template < class R, class P, class A0, class A1 > inline int call( lua_State* p_state, R ( *f )( A0, A1 ), P* p )
{
    return Call< R >::call( p_state, f, p );
}


template < class R, class P, class A0, class A1, class A2 > inline int call( lua_State* p_state, R ( *f )( A0, A1, A2 ), P* p )
{
    return Call< R >::call( p_state, f, p );
}


template < class R, class P, class A0, class A1, class A2, class A3 > inline int call( lua_State* p_state, R ( *f )( A0, A1, A2, A3 ), P* p )
{
    return Call< R >::call( p_state, f, p );
}


}
}
}

#endif

#endif

---