2014-02-10 01:10:30 +00:00
/*************************************************************************/
/* method_bind.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
2017-01-01 21:01:57 +00:00
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
2017-04-07 22:11:42 +00:00
/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */
2014-02-10 01:10:30 +00:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
# ifndef METHOD_BIND_H
# define METHOD_BIND_H
# include "list.h"
2017-03-05 15:44:50 +00:00
# include "method_ptrcall.h"
2014-02-10 01:10:30 +00:00
# include "object.h"
2017-03-05 15:44:50 +00:00
# include "variant.h"
2014-02-10 01:10:30 +00:00
# include <stdio.h>
/**
@ author Juan Linietsky < reduzio @ gmail . com >
*/
# ifdef DEBUG_ENABLED
# define DEBUG_METHODS_ENABLED
# endif
enum MethodFlags {
2017-03-05 15:44:50 +00:00
METHOD_FLAG_NORMAL = 1 ,
METHOD_FLAG_EDITOR = 2 ,
METHOD_FLAG_NOSCRIPT = 4 ,
METHOD_FLAG_CONST = 8 ,
METHOD_FLAG_REVERSE = 16 , // used for events
METHOD_FLAG_VIRTUAL = 32 ,
METHOD_FLAG_FROM_SCRIPT = 64 ,
METHOD_FLAG_VARARG = 128 ,
METHOD_FLAGS_DEFAULT = METHOD_FLAG_NORMAL ,
2014-02-10 01:10:30 +00:00
} ;
2017-03-05 15:44:50 +00:00
template < class T >
2014-02-10 01:10:30 +00:00
struct VariantCaster {
2017-03-05 15:44:50 +00:00
static _FORCE_INLINE_ T cast ( const Variant & p_variant ) {
2016-03-08 23:00:52 +00:00
return p_variant ;
2014-02-10 01:10:30 +00:00
}
} ;
2017-03-05 15:44:50 +00:00
template < class T >
struct VariantCaster < T & > {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
static _FORCE_INLINE_ T cast ( const Variant & p_variant ) {
2016-03-08 23:00:52 +00:00
return p_variant ;
2014-02-10 01:10:30 +00:00
}
} ;
2017-03-05 15:44:50 +00:00
template < class T >
struct VariantCaster < const T & > {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
static _FORCE_INLINE_ T cast ( const Variant & p_variant ) {
2016-03-08 23:00:52 +00:00
return p_variant ;
2014-02-10 01:10:30 +00:00
}
} ;
2017-03-05 15:44:50 +00:00
# define _VC(m_idx) \
( VariantCaster < P # # m_idx > : : cast ( ( m_idx - 1 ) > = p_arg_count ? get_default_argument ( m_idx - 1 ) : * p_args [ m_idx - 1 ] ) )
2014-02-10 01:10:30 +00:00
//SIMPLE_NUMERIC_TYPE is used to avoid a warning on Variant::get_type_for
2016-06-23 02:12:20 +00:00
# ifdef PTRCALL_ENABLED
2017-03-05 15:44:50 +00:00
# define VARIANT_ENUM_CAST(m_enum) \
SIMPLE_NUMERIC_TYPE ( m_enum ) ; \
template < > \
struct VariantCaster < m_enum > { \
\
static _FORCE_INLINE_ m_enum cast ( const Variant & p_variant ) { \
return ( m_enum ) p_variant . operator int ( ) ; \
} \
} ; \
template < > \
struct PtrToArg < m_enum > { \
_FORCE_INLINE_ static m_enum convert ( const void * p_ptr ) { \
return m_enum ( * reinterpret_cast < const int * > ( p_ptr ) ) ; \
} \
_FORCE_INLINE_ static void encode ( m_enum p_val , const void * p_ptr ) { \
* ( int * ) p_ptr = p_val ; \
} \
} ;
2016-06-23 02:12:20 +00:00
# else
2017-03-05 15:44:50 +00:00
# define VARIANT_ENUM_CAST(m_enum) \
SIMPLE_NUMERIC_TYPE ( m_enum ) ; \
template < > \
struct VariantCaster < m_enum > { \
\
static _FORCE_INLINE_ m_enum cast ( const Variant & p_variant ) { \
return ( m_enum ) p_variant . operator int ( ) ; \
} \
} ;
2014-02-10 01:10:30 +00:00
2016-06-23 02:12:20 +00:00
# endif
2017-03-05 15:44:50 +00:00
# define CHECK_ARG(m_arg) \
if ( ( m_arg - 1 ) < p_arg_count ) { \
Variant : : Type argtype = get_argument_type ( m_arg - 1 ) ; \
if ( ! Variant : : can_convert_strict ( p_args [ m_arg - 1 ] - > get_type ( ) , argtype ) ) { \
r_error . error = Variant : : CallError : : CALL_ERROR_INVALID_ARGUMENT ; \
r_error . argument = m_arg - 1 ; \
r_error . expected = argtype ; \
return Variant ( ) ; \
} \
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
# define CHECK_NOARG(m_arg) \
{ \
if ( p_arg # # m_arg . get_type ( ) ! = Variant : : NIL ) { \
if ( r_argerror ) * r_argerror = ( m_arg - 1 ) ; \
return CALL_ERROR_EXTRA_ARGUMENT ; \
} \
2014-02-10 01:10:30 +00:00
}
// some helpers
2017-03-05 15:44:50 +00:00
VARIANT_ENUM_CAST ( Vector3 : : Axis ) ;
2017-05-17 10:36:47 +00:00
2017-03-05 15:44:50 +00:00
VARIANT_ENUM_CAST ( Error ) ;
VARIANT_ENUM_CAST ( wchar_t ) ;
VARIANT_ENUM_CAST ( Margin ) ;
VARIANT_ENUM_CAST ( Orientation ) ;
VARIANT_ENUM_CAST ( HAlign ) ;
VARIANT_ENUM_CAST ( Variant : : Type ) ;
VARIANT_ENUM_CAST ( Variant : : Operator ) ;
2014-02-10 01:10:30 +00:00
class MethodBind {
int method_id ;
uint32_t hint_flags ;
StringName name ;
Vector < Variant > default_arguments ;
int default_argument_count ;
int argument_count ;
# ifdef DEBUG_METHODS_ENABLED
Vector < StringName > arg_names ;
Variant : : Type * argument_types ;
StringName ret_type ;
# endif
bool _const ;
2016-08-02 22:11:05 +00:00
bool _returns ;
2014-02-10 01:10:30 +00:00
protected :
void _set_const ( bool p_const ) ;
2016-08-02 22:11:05 +00:00
void _set_returns ( bool p_returns ) ;
2014-02-10 01:10:30 +00:00
# ifdef DEBUG_METHODS_ENABLED
2017-03-05 15:44:50 +00:00
virtual Variant : : Type _gen_argument_type ( int p_arg ) const = 0 ;
2014-02-10 01:10:30 +00:00
void _generate_argument_types ( int p_count ) ;
2017-03-05 15:44:50 +00:00
void set_argument_types ( Variant : : Type * p_types ) { argument_types = p_types ; }
2014-02-10 01:10:30 +00:00
# endif
2017-03-05 15:44:50 +00:00
void set_argument_count ( int p_count ) { argument_count = p_count ; }
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
public :
2014-02-10 01:10:30 +00:00
Vector < Variant > get_default_arguments ( ) const { return default_arguments ; }
_FORCE_INLINE_ int get_default_argument_count ( ) const { return default_argument_count ; }
_FORCE_INLINE_ Variant has_default_argument ( int p_arg ) const {
2017-03-05 15:44:50 +00:00
int idx = argument_count - p_arg - 1 ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
if ( idx < 0 | | idx > = default_arguments . size ( ) )
2014-02-10 01:10:30 +00:00
return false ;
else
return true ;
}
_FORCE_INLINE_ Variant get_default_argument ( int p_arg ) const {
2017-03-05 15:44:50 +00:00
int idx = argument_count - p_arg - 1 ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
if ( idx < 0 | | idx > = default_arguments . size ( ) )
2014-02-10 01:10:30 +00:00
return Variant ( ) ;
else
return default_arguments [ idx ] ;
}
# ifdef DEBUG_METHODS_ENABLED
2017-03-05 15:44:50 +00:00
_FORCE_INLINE_ void set_return_type ( const StringName & p_type ) { ret_type = p_type ; }
2015-01-03 19:52:37 +00:00
_FORCE_INLINE_ StringName get_return_type ( ) const { return ret_type ; }
2014-02-10 01:10:30 +00:00
_FORCE_INLINE_ Variant : : Type get_argument_type ( int p_argument ) const {
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND_V ( p_argument < - 1 | | p_argument > argument_count , Variant : : NIL ) ;
return argument_types [ p_argument + 1 ] ;
2014-02-10 01:10:30 +00:00
}
PropertyInfo get_argument_info ( int p_argument ) const ;
2017-03-05 15:44:50 +00:00
void set_argument_names ( const Vector < StringName > & p_names ) ;
2014-02-10 01:10:30 +00:00
Vector < StringName > get_argument_names ( ) const ;
# endif
2017-03-05 15:44:50 +00:00
void set_hint_flags ( uint32_t p_hint ) { hint_flags = p_hint ; }
uint32_t get_hint_flags ( ) const { return hint_flags | ( is_const ( ) ? METHOD_FLAG_CONST : 0 ) | ( is_vararg ( ) ? METHOD_FLAG_VARARG : 0 ) ; }
virtual String get_instance_class ( ) const = 0 ;
2014-02-10 01:10:30 +00:00
_FORCE_INLINE_ int get_argument_count ( ) const { return argument_count ; } ;
#if 0
_FORCE_INLINE_ Variant call_safe ( const Variant * * p_args , int p_arg_count , Variant : : CallError & r_error ) {
r_error . error = Variant : : CallError : : CALL_OK ;
check_call ( p_args , & errorarg ) ;
if ( ! err )
return call ( p_object , VARIANT_ARG_PASS ) ;
VARIANT_ARGPTRS
String errstr ;
String methodname = get_instance_type ( ) + " :: " + name ;
if ( err = = CALL_ERROR_ARGUMENT_TYPE ) {
errstr = " Invalid Argument to call: ' " + methodname + " '. Cannot convert argument " + itos ( errorarg + 1 ) + " from " + Variant : : get_type_name ( get_argument_type ( errorarg ) ) + " to " + Variant : : get_type_name ( argptr [ errorarg ] - > get_type ( ) ) + " . " ;
}
if ( err = = CALL_ERROR_EXTRA_ARGUMENT ) {
errstr = " Invalid call. Member function ' " + methodname + " ' takes " + itos ( get_argument_count ( ) ) + " argument, but argument " + itos ( errorarg + 1 ) + " was received. " ;
}
ERR_PRINT ( errstr . ascii ( ) . get_data ( ) ) ;
return Variant ( ) ;
}
# endif
2017-03-05 15:44:50 +00:00
virtual Variant call ( Object * p_object , const Variant * * p_args , int p_arg_count , Variant : : CallError & r_error ) = 0 ;
2016-06-23 02:12:20 +00:00
# ifdef PTRCALL_ENABLED
2017-03-05 15:44:50 +00:00
virtual void ptrcall ( Object * p_object , const void * * p_args , void * r_ret ) = 0 ;
2016-06-23 02:12:20 +00:00
# endif
2014-02-10 01:10:30 +00:00
StringName get_name ( ) const ;
2017-03-05 15:44:50 +00:00
void set_name ( const StringName & p_name ) ;
2014-02-10 01:10:30 +00:00
_FORCE_INLINE_ int get_method_id ( ) const { return method_id ; }
_FORCE_INLINE_ bool is_const ( ) const { return _const ; }
2016-08-02 22:11:05 +00:00
_FORCE_INLINE_ bool has_return ( ) const { return _returns ; }
2016-09-07 22:39:02 +00:00
virtual bool is_vararg ( ) const { return false ; }
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
void set_default_arguments ( const Vector < Variant > & p_defargs ) ;
2014-02-10 01:10:30 +00:00
MethodBind ( ) ;
virtual ~ MethodBind ( ) ;
} ;
2017-03-05 15:44:50 +00:00
template < class T >
2016-09-07 22:39:02 +00:00
class MethodBindVarArg : public MethodBind {
2014-02-10 01:10:30 +00:00
public :
2017-03-05 15:44:50 +00:00
typedef Variant ( T : : * NativeCall ) ( const Variant * * , int , Variant : : CallError & ) ;
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
protected :
2014-02-10 01:10:30 +00:00
NativeCall call_method ;
2017-03-05 15:44:50 +00:00
public :
2014-02-10 01:10:30 +00:00
virtual Variant : : Type _gen_argument_type ( int p_arg ) const {
return Variant : : NIL ;
}
2017-03-05 15:44:50 +00:00
virtual Variant call ( Object * p_object , const Variant * * p_args , int p_arg_count , Variant : : CallError & r_error ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
T * instance = static_cast < T * > ( p_object ) ;
return ( instance - > * call_method ) ( p_args , p_arg_count , r_error ) ;
2014-02-10 01:10:30 +00:00
}
2017-03-05 15:44:50 +00:00
void set_method_info ( const MethodInfo & p_info ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
set_argument_count ( p_info . arguments . size ( ) ) ;
2014-02-10 01:10:30 +00:00
# ifdef DEBUG_METHODS_ENABLED
2017-03-05 15:44:50 +00:00
Variant : : Type * at = memnew_arr ( Variant : : Type , p_info . arguments . size ( ) + 1 ) ;
at [ 0 ] = p_info . return_val . type ;
2014-02-10 01:10:30 +00:00
if ( p_info . arguments . size ( ) ) {
Vector < StringName > names ;
names . resize ( p_info . arguments . size ( ) ) ;
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < p_info . arguments . size ( ) ; i + + ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
at [ i + 1 ] = p_info . arguments [ i ] . type ;
names [ i ] = p_info . arguments [ i ] . name ;
2014-02-10 01:10:30 +00:00
}
set_argument_names ( names ) ;
}
set_argument_types ( at ) ;
# endif
}
2016-06-23 02:12:20 +00:00
# ifdef PTRCALL_ENABLED
2017-03-05 15:44:50 +00:00
virtual void ptrcall ( Object * p_object , const void * * p_args , void * r_ret ) {
2016-09-07 22:39:02 +00:00
ERR_FAIL ( ) ; //can't call
} //todo
2016-06-23 02:12:20 +00:00
# endif
2017-03-05 15:44:50 +00:00
void set_method ( NativeCall p_method ) { call_method = p_method ; }
2014-02-10 01:10:30 +00:00
virtual bool is_const ( ) const { return false ; }
2017-01-03 02:03:46 +00:00
virtual String get_instance_class ( ) const { return T : : get_class_static ( ) ; }
2014-02-10 01:10:30 +00:00
2016-09-07 22:39:02 +00:00
virtual bool is_vararg ( ) const { return true ; }
2017-03-05 15:44:50 +00:00
MethodBindVarArg ( ) {
call_method = NULL ;
_set_returns ( true ) ;
}
2014-02-10 01:10:30 +00:00
} ;
2017-03-05 15:44:50 +00:00
template < class T >
MethodBind * create_vararg_method_bind ( Variant ( T : : * p_method ) ( const Variant * * , int , Variant : : CallError & ) , const MethodInfo & p_info ) {
2014-02-10 01:10:30 +00:00
2017-03-05 15:44:50 +00:00
MethodBindVarArg < T > * a = memnew ( ( MethodBindVarArg < T > ) ) ;
2014-02-10 01:10:30 +00:00
a - > set_method ( p_method ) ;
a - > set_method_info ( p_info ) ;
return a ;
}
/** This amazing hack is based on the FastDelegates theory */
// tale of an amazing hack.. //
2015-05-18 13:20:54 +00:00
// if you declare an nonexistent class..
2014-02-10 01:10:30 +00:00
class __UnexistingClass ;
# include "method_bind.inc"
# endif