mirror of
https://github.com/copyrighttxt/watrbx-game-engine.git
synced 2026-09-04 20:57:49 +00:00
2602 lines
113 KiB
C++
2602 lines
113 KiB
C++
#pragma once
|
|
#include "reflection/property.h"
|
|
#include "reflection/object.h"
|
|
#include "reflection/enumconverter.h"
|
|
#include "reflection/Type.h"
|
|
#include "rbx/make_shared.h"
|
|
#include <boost/static_assert.hpp>
|
|
#include <boost/utility/enable_if.hpp>
|
|
#include <boost/type_traits.hpp>
|
|
|
|
#if defined RBX_PLATFORM_IOS
|
|
#define NULL_FUNCTION_PTR typeof(NULL)
|
|
#else
|
|
#define NULL_FUNCTION_PTR int
|
|
#endif
|
|
#define _PRISM_PYRAMID_
|
|
|
|
#ifdef RBX_RCC_SECURITY
|
|
// data_seg = init rw
|
|
// const_seg = init ro
|
|
// bss_seg = rw
|
|
#define REFLECTION_BEGIN() __pragma(data_seg(".lua")) __pragma(const_seg(".lua")) __pragma(bss_seg(".lua"))
|
|
#define REFLECTION_END() __pragma(data_seg()) __pragma(const_seg()) __pragma(bss_seg())
|
|
#else
|
|
#define REFLECTION_BEGIN()
|
|
#define REFLECTION_END()
|
|
#endif
|
|
|
|
namespace RBX
|
|
{
|
|
namespace Reflection
|
|
{
|
|
// This class is designed to prevent clients of the library
|
|
// from forgetting to initialize their class descriptors
|
|
template<class Class>
|
|
class ClassRegistrar : boost::noncopyable
|
|
{
|
|
int x;
|
|
ClassRegistrar(int i):x(i)
|
|
{
|
|
// This call registers the class descriptor
|
|
// in the reflection database
|
|
Class::classDescriptor();
|
|
}
|
|
public:
|
|
void dummy()
|
|
{
|
|
x++;
|
|
}
|
|
|
|
// The instantiation of this static member must be in a unit
|
|
// that is initialized in the main thread before any objects
|
|
// are created. Otherwise the reflection database
|
|
// can change at runtime, which would be a disaster
|
|
static ClassRegistrar registrar;
|
|
};
|
|
// A CRTP class for implementing reflection. Must be a descendant of DescribedBase
|
|
template<
|
|
class Class,
|
|
const char* const& sClassName,
|
|
class BaseClass = DescribedBase,
|
|
ClassDescriptor::Functionality functionality = Reflection::ClassDescriptor::PERSISTENT,
|
|
Security::Permissions security = Security::None
|
|
>
|
|
class RBXBaseClass Described : public BaseClass
|
|
{
|
|
void forceRegistration()
|
|
{
|
|
// Force linking of ClassRegistrar<Class>, which will force clients
|
|
// of this library to define ClassRegistrar<Class>::registrar in
|
|
// their startup code.
|
|
ClassRegistrar<Class>::registrar.dummy();
|
|
}
|
|
public:
|
|
|
|
static ClassDescriptor& classDescriptor()
|
|
{
|
|
static ClassDescriptor describedClassDescriptor(BaseClass::classDescriptor(), sClassName, functionality, security);
|
|
return describedClassDescriptor;
|
|
}
|
|
inline Described() {
|
|
this->descriptor = &classDescriptor();
|
|
forceRegistration();
|
|
}
|
|
template<class Arg0>
|
|
inline Described(Arg0 arg0):BaseClass(arg0) {
|
|
this->descriptor = &classDescriptor();
|
|
forceRegistration();
|
|
}
|
|
template<class Arg0, class Arg1>
|
|
inline Described(Arg0 arg0, Arg1 arg1):BaseClass(arg0, arg1) {
|
|
this->descriptor = &classDescriptor();
|
|
forceRegistration();
|
|
}
|
|
template<class Arg0, class Arg1, class Arg2>
|
|
inline Described(Arg0 arg0, Arg1 arg1, Arg2 arg2):BaseClass(arg0, arg1, arg2) {
|
|
this->descriptor = &classDescriptor();
|
|
forceRegistration();
|
|
}
|
|
template<class Arg0, class Arg1, class Arg2, class Arg3>
|
|
inline Described(Arg0 arg0, Arg1 arg1, Arg2 arg2, Arg3 arg3):BaseClass(arg0, arg1, arg2, arg3) {
|
|
this->descriptor = &classDescriptor();
|
|
forceRegistration();
|
|
}
|
|
};
|
|
|
|
|
|
|
|
// Handy macro for registering a class
|
|
#define RBX_REGISTER_CLASS(Class) template<> RBX::Reflection::ClassRegistrar<Class> RBX::Reflection::ClassRegistrar<Class>::registrar(0)
|
|
|
|
// This CRTP class puts a property declaration all together.
|
|
// It binds a PropertyDescriptor with getter/setter functions.
|
|
template<class Class, typename V>
|
|
class PropDescriptor : public TypedPropertyDescriptor<V>
|
|
{
|
|
template<typename Get, typename Set>
|
|
class GetSetImpl : public Reflection::TypedPropertyDescriptor<V>::GetSet
|
|
{
|
|
Get get;
|
|
Set set;
|
|
public:
|
|
GetSetImpl(Get get, Set set):get(get),set(set)
|
|
{}
|
|
|
|
/*implement*/ bool isReadOnly() const { return false; }
|
|
/*implement*/ bool isWriteOnly() const { return false; }
|
|
/*implement*/ V getValue(const DescribedBase* object) const
|
|
{
|
|
const Class* c = boost::polymorphic_downcast<const Class*>(object);
|
|
return (c->*get)();
|
|
}
|
|
/*implement*/ void setValue(DescribedBase* object, const V& value) const
|
|
{
|
|
Class* c = boost::polymorphic_downcast<Class*>(object);
|
|
(c->*set)(value);
|
|
}
|
|
};
|
|
|
|
template<typename Get>
|
|
class GetImpl : public Reflection::TypedPropertyDescriptor<V>::GetSet
|
|
{
|
|
Get get;
|
|
public:
|
|
GetImpl(Get get):get(get)
|
|
{}
|
|
|
|
/*implement*/ bool isReadOnly() const { return true; }
|
|
/*implement*/ bool isWriteOnly() const { return false; }
|
|
/*implement*/ V getValue(const DescribedBase* object) const
|
|
{
|
|
const Class* c = boost::polymorphic_downcast<const Class*>(object);
|
|
return (c->*get)();
|
|
}
|
|
/*implement*/ void setValue(DescribedBase* object, const V& value) const
|
|
{
|
|
throw std::runtime_error("can't set value");
|
|
}
|
|
};
|
|
|
|
template<typename Set>
|
|
class SetImpl : public Reflection::TypedPropertyDescriptor<V>::GetSet
|
|
{
|
|
Set set;
|
|
public:
|
|
SetImpl(Set set):set(set)
|
|
{}
|
|
|
|
/*implement*/ bool isReadOnly() const { return false; }
|
|
/*implement*/ bool isWriteOnly() const { return true; }
|
|
/*implement*/ V getValue(const DescribedBase* object) const
|
|
{
|
|
throw std::runtime_error("can't get value");
|
|
}
|
|
/*implement*/ void setValue(DescribedBase* object, const V& value) const
|
|
{
|
|
Class* c = boost::polymorphic_downcast<Class*>(object);
|
|
(c->*set)(value);
|
|
}
|
|
};
|
|
|
|
public:
|
|
template<typename Get, typename Set>
|
|
PropDescriptor(const char* name, const char* category, Get get, Set set, PropertyDescriptor::Attributes flags = PropertyDescriptor::Attributes(), Security::Permissions security = Security::None)
|
|
:TypedPropertyDescriptor<V>(Class::classDescriptor(), name, category, getset<Get, Set>(get, set), flags, security)
|
|
{
|
|
}
|
|
|
|
template<typename Get, typename Set>
|
|
static std::auto_ptr< typename Reflection::TypedPropertyDescriptor<V>::GetSet > getset(Get get, Set set)
|
|
{
|
|
return std::auto_ptr< typename Reflection::TypedPropertyDescriptor<V>::GetSet >(new GetSetImpl<Get, Set>(get, set));
|
|
}
|
|
|
|
// Partial specialization for read-only case
|
|
template<typename Get, typename Set>
|
|
static std::auto_ptr< typename Reflection::TypedPropertyDescriptor<V>::GetSet > getset(Get get, NULL_FUNCTION_PTR set)
|
|
{
|
|
return std::auto_ptr< typename Reflection::TypedPropertyDescriptor<V>::GetSet >(new GetImpl<Get>(get));
|
|
}
|
|
// Partial specialization for write-only case
|
|
template<typename Get, typename Set>
|
|
static std::auto_ptr< typename Reflection::TypedPropertyDescriptor<V>::GetSet > getset(NULL_FUNCTION_PTR get, Set set)
|
|
{
|
|
return std::auto_ptr< typename Reflection::TypedPropertyDescriptor<V>::GetSet >(new SetImpl<Set>(set));
|
|
}
|
|
};
|
|
|
|
// This CRTP class puts an enum property declaration all together.
|
|
// It binds a PropertyDescriptor with getter/setter functions.
|
|
// TODO: Refactor: This duplicates code it TypedPropertyDescriptor
|
|
template<class Class, typename V>
|
|
class EnumPropDescriptor : public EnumPropertyDescriptor
|
|
{
|
|
std::auto_ptr<typename TypedPropertyDescriptor<V>::GetSet> getset;
|
|
const EnumDesc<V>& enumDesc;
|
|
public:
|
|
template<typename Get, typename Set>
|
|
EnumPropDescriptor(const char* name, const char* category, Get get, Set set, PropertyDescriptor::Attributes flags = PropertyDescriptor::Attributes(), Security::Permissions security=Security::None)
|
|
:EnumPropertyDescriptor(Class::classDescriptor(), EnumDesc<V>::singleton(), name, category, flags, security)
|
|
,getset(PropDescriptor<Class, V>::template getset<Get, Set>(get, set))
|
|
,enumDesc(EnumDesc<V>::singleton())
|
|
{
|
|
this->checkFlags();
|
|
}
|
|
|
|
virtual bool isReadOnly() const {
|
|
return getset->isReadOnly();
|
|
}
|
|
|
|
virtual bool isWriteOnly() const {
|
|
return getset->isWriteOnly();
|
|
}
|
|
|
|
/*implement*/ void getVariant(const DescribedBase* instance, Variant& value) const
|
|
{
|
|
value = getEnumValue(instance);
|
|
}
|
|
/*implement*/ void setVariant(DescribedBase* instance, const Variant& value) const
|
|
{
|
|
setEnumValue(instance, value.get<int>());
|
|
}
|
|
/*implement*/ void copyValue(const DescribedBase* source, DescribedBase* destination) const
|
|
{
|
|
setValue(destination, getValue(source));
|
|
}
|
|
|
|
V getValue(const DescribedBase* object) const {
|
|
return getset->getValue(object);
|
|
}
|
|
|
|
void setValue(DescribedBase* object, V value) const {
|
|
getset->setValue(object, value);
|
|
}
|
|
|
|
/*implement*/ bool equalValues(const DescribedBase* a, const DescribedBase* b) const {
|
|
return getValue(a) == getValue(b);
|
|
}
|
|
|
|
/*implement*/ const EnumDescriptor::Item* getEnumItem(const DescribedBase* instance) const
|
|
{
|
|
const EnumDescriptor::Item* result = enumDesc.convertToItem(getValue(instance));
|
|
return result;
|
|
}
|
|
|
|
/*implement*/ int getEnumValue(const DescribedBase* instance) const
|
|
{
|
|
return (int) getValue(instance);
|
|
}
|
|
/*implement*/ bool setEnumValue(DescribedBase* instance, int intValue) const
|
|
{
|
|
if (enumDesc.isValue(intValue))
|
|
{
|
|
setValue(instance, (V) intValue);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
virtual size_t getIndexValue(const DescribedBase* instance) const
|
|
{
|
|
return enumDesc.convertToIndex(getValue(instance));
|
|
}
|
|
virtual bool setIndexValue(DescribedBase* instance, size_t index) const
|
|
{
|
|
V value;
|
|
if (enumDesc.convertToValue(index, value))
|
|
{
|
|
setValue(instance, value);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
bool setIntValue(DescribedBase* instance, int intValue) const
|
|
{
|
|
V v;
|
|
if (!enumDesc.mapIntValue(intValue, v))
|
|
return false;
|
|
setValue(instance, v);
|
|
return true;
|
|
}
|
|
|
|
// PropertyDescriptor implementation:
|
|
virtual bool hasStringValue() const {
|
|
return true;
|
|
}
|
|
virtual std::string getStringValue(const DescribedBase* instance) const
|
|
{
|
|
return enumDesc.convertToString(getValue(instance));
|
|
}
|
|
virtual bool setStringValue(DescribedBase* instance, const std::string& text) const
|
|
{
|
|
V value;
|
|
if (enumDesc.convertToValue(text.c_str(), value))
|
|
{
|
|
setValue(instance, value);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
// An alternate, more efficient version of setStringValue
|
|
virtual bool setStringValue(DescribedBase* instance, const RBX::Name& name) const
|
|
{
|
|
V value;
|
|
if (enumDesc.convertToValue(name, value))
|
|
{
|
|
setValue(instance, value);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
virtual void readValue(DescribedBase* instance, const XmlElement* element, RBX::IReferenceBinder& binder) const
|
|
{
|
|
if (!element->isXsiNil()) {
|
|
|
|
int value;
|
|
if (element->getValue(value))
|
|
{
|
|
if (setIntValue(instance, value))
|
|
return;
|
|
}
|
|
|
|
if (element->isValueType<std::string>())
|
|
{
|
|
// Legacy code to handle files older than 10/29/05
|
|
// TODO: Opt: Remove this legacy code sometime? It slows text XML down a bit
|
|
std::string sValue;
|
|
if (element->getValue(sValue))
|
|
{
|
|
V e;
|
|
if (enumDesc.convertToValue(sValue.c_str(), e))
|
|
{
|
|
setValue(instance, e);
|
|
return;
|
|
}
|
|
if (sValue.size()==0)
|
|
{
|
|
if (setIndexValue(instance, 0))
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: throw error?
|
|
RBXASSERT(false);
|
|
}
|
|
}
|
|
virtual void writeValue(const DescribedBase* instance, XmlElement* element) const
|
|
{
|
|
element->setValue(static_cast<int>(getValue(instance)));
|
|
}
|
|
};
|
|
|
|
// Helper class
|
|
template<typename T>
|
|
class RefType : public Type
|
|
{
|
|
public:
|
|
static const Type& singleton()
|
|
{
|
|
static RefType type("Object");
|
|
return type;
|
|
}
|
|
|
|
private:
|
|
RefType(const char* name)
|
|
:Type(name, "Ref", (T*)NULL)
|
|
{}
|
|
};
|
|
|
|
template<class Class, typename RefClass>
|
|
class RefPropDescriptor
|
|
: public RefPropertyDescriptor
|
|
, public IIDREF
|
|
{
|
|
std::auto_ptr<typename TypedPropertyDescriptor<RefClass*>::GetSet> getset;
|
|
public:
|
|
template<typename Get, typename Set>
|
|
RefPropDescriptor(const char* name, const char* category, Get get, Set set, PropertyDescriptor::Attributes attributes = PropertyDescriptor::Attributes(), Security::Permissions security=Security::None)
|
|
:RefPropertyDescriptor(
|
|
Class::classDescriptor(),
|
|
RefType<RefClass*>::singleton(),
|
|
name, category,
|
|
attributes, security
|
|
)
|
|
,getset(PropDescriptor<Class, RefClass*>::template getset<Get, Set>(get, set))
|
|
{
|
|
this->checkFlags();
|
|
}
|
|
|
|
virtual bool isReadOnly() const {
|
|
return getset->isReadOnly();
|
|
}
|
|
|
|
virtual bool isWriteOnly() const {
|
|
return getset->isWriteOnly();
|
|
}
|
|
|
|
/*implement*/ void getVariant(const DescribedBase* instance, Variant& value) const
|
|
{
|
|
shared_ptr<Reflection::DescribedBase> ref = shared_from(getValue(instance));
|
|
value = ref;
|
|
}
|
|
/*implement*/ void setVariant(DescribedBase* instance, const Variant& value) const
|
|
{
|
|
shared_ptr<Reflection::DescribedBase> ref = value.get<shared_ptr<Reflection::DescribedBase> >();
|
|
setRefValue(instance, ref.get());
|
|
}
|
|
/*implement*/ void copyValue(const DescribedBase* source, DescribedBase* destination) const
|
|
{
|
|
setValue(destination, getValue(source));
|
|
}
|
|
|
|
RefClass* getValue(const DescribedBase* object) const {
|
|
return getset->getValue(object);
|
|
}
|
|
|
|
void setValue(DescribedBase* object, RefClass* value) const {
|
|
getset->setValue(object, value);
|
|
}
|
|
|
|
/*implement*/ bool equalValues(const DescribedBase* a, const DescribedBase* b) const {
|
|
return getValue(a) == getValue(b);
|
|
}
|
|
|
|
/*implement*/ DescribedBase* getRefValue(const DescribedBase* instance) const {
|
|
return getValue(instance);
|
|
}
|
|
/*implement*/ void setRefValue(DescribedBase* instance, DescribedBase* value) const {
|
|
// if value!=NULL then ensure it is the proper type. If value==NULL then it is OK
|
|
RefClass* v = value!=NULL ? boost::polymorphic_cast<RefClass*>(value) : NULL;
|
|
setValue(instance, v);
|
|
}
|
|
/*implement*/ void setRefValueUnsafe(DescribedBase* instance, DescribedBase* value) const {
|
|
setValue(instance, boost::polymorphic_downcast<RefClass*>(value));
|
|
}
|
|
|
|
void readValue(DescribedBase* instance, const XmlElement* element, IReferenceBinder& binder) const
|
|
{
|
|
binder.announceIDREF(element, instance, this);
|
|
}
|
|
void writeValue(const DescribedBase* instance, XmlElement* element) const
|
|
{
|
|
element->setValue(InstanceHandle(getValue(instance)));
|
|
}
|
|
|
|
/*implement*/ void assignIDREF(DescribedBase* propertyOwner, const InstanceHandle& handle) const
|
|
{
|
|
// We know (assume) that this is the right type. If not, then the file is corrupt!
|
|
shared_ptr<DescribedBase> t = handle.getTarget();
|
|
RefClass* r = boost::polymorphic_downcast<RefClass*>(t.get());
|
|
setValue(propertyOwner, r);
|
|
}
|
|
};
|
|
|
|
template <class Class>
|
|
class FuncDesc : public FunctionDescriptor
|
|
{
|
|
protected:
|
|
FuncDesc(const char* name, Security::Permissions security, Attributes attributes)
|
|
:FunctionDescriptor(Class::classDescriptor(), name, security, attributes)
|
|
{
|
|
}
|
|
};
|
|
|
|
class ArgHelper
|
|
{
|
|
template <int index, class T>
|
|
static bool try_integral(FunctionDescriptor::Arguments& arguments, bool& arg)
|
|
{
|
|
return arguments.getBool(index, arg);
|
|
}
|
|
|
|
template <int index, class T>
|
|
static bool try_integral(FunctionDescriptor::Arguments& arguments, int& arg)
|
|
{
|
|
long a;
|
|
if (!arguments.getLong(index, a))
|
|
return false;
|
|
arg = (int) a;
|
|
return true;
|
|
}
|
|
|
|
template <int index, class T>
|
|
static bool try_integral(FunctionDescriptor::Arguments& arguments, long& arg)
|
|
{
|
|
return arguments.getLong(index, arg);
|
|
}
|
|
|
|
template <int index, class T>
|
|
static inline bool try_integral(FunctionDescriptor::Arguments& arguments, T& arg, typename boost::disable_if<boost::is_integral<T> >::type* dummy = 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
template <int index, class T>
|
|
static bool try_floating_point(FunctionDescriptor::Arguments& arguments, T& arg, typename boost::enable_if<boost::is_floating_point<T> >::type* dummy = 0)
|
|
{
|
|
double a;
|
|
if (!arguments.getDouble(index, a))
|
|
return false;
|
|
arg = a;
|
|
return true;
|
|
}
|
|
|
|
template <int index, class T>
|
|
static inline bool try_floating_point(FunctionDescriptor::Arguments& arguments, T& arg, typename boost::disable_if<boost::is_floating_point<T> >::type* dummy = 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
template <int index, class T>
|
|
static bool try_string(FunctionDescriptor::Arguments& arguments, T& arg, typename boost::enable_if<boost::is_same<T, std::string> >::type* dummy = 0)
|
|
{
|
|
return arguments.getString(index, arg);
|
|
}
|
|
|
|
template <int index, class T>
|
|
static inline bool try_string(FunctionDescriptor::Arguments& arguments, T& arg, typename boost::disable_if<boost::is_same<T, std::string> >::type* dummy = 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
template <int index, class T>
|
|
static bool try_Vector3int16(FunctionDescriptor::Arguments& arguments, T& arg, typename boost::enable_if<boost::is_same<T, Vector3int16> >::type* dummy = 0)
|
|
{
|
|
return arguments.getVector3int16(index, arg);
|
|
}
|
|
|
|
template <int index, class T>
|
|
static inline bool try_Vector3int16(FunctionDescriptor::Arguments& arguments, T& arg, typename boost::disable_if<boost::is_same<T, Vector3int16> >::type* dummy = 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
template <int index, class T>
|
|
static bool try_Region3int16(FunctionDescriptor::Arguments& arguments, T& arg, typename boost::enable_if<boost::is_same<T, Region3int16> >::type* dummy = 0)
|
|
{
|
|
return arguments.getRegion3int16(index, arg);
|
|
}
|
|
|
|
template <int index, class T>
|
|
static inline bool try_Region3int16(FunctionDescriptor::Arguments& arguments, T& arg, typename boost::disable_if<boost::is_same<T, Region3int16> >::type* dummy = 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
template <int index, class T>
|
|
static bool try_Vector3(FunctionDescriptor::Arguments& arguments, T& arg, typename boost::enable_if<boost::is_same<T, Vector3> >::type* dummy = 0)
|
|
{
|
|
return arguments.getVector3(index, arg);
|
|
}
|
|
|
|
template <int index, class T>
|
|
static inline bool try_Vector3(FunctionDescriptor::Arguments& arguments, T& arg, typename boost::disable_if<boost::is_same<T, Vector3> >::type* dummy = 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
template <int index, class T>
|
|
static bool try_Region3(FunctionDescriptor::Arguments& arguments, T& arg, typename boost::enable_if<boost::is_same<T, Region3> >::type* dummy = 0)
|
|
{
|
|
return arguments.getRegion3(index, arg);
|
|
}
|
|
|
|
template <int index, class T>
|
|
static inline bool try_Region3(FunctionDescriptor::Arguments& arguments, T& arg, typename boost::disable_if<boost::is_same<T, Region3> >::type* dummy = 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
template <int index, class T>
|
|
static bool try_Rect(FunctionDescriptor::Arguments& arguments, T& arg, typename boost::enable_if<boost::is_same<T, Rect2D> >::type* dummy = 0)
|
|
{
|
|
return arguments.getRect(index, arg);
|
|
}
|
|
|
|
template <int index, class T>
|
|
static inline bool try_Rect(FunctionDescriptor::Arguments& arguments, T& arg, typename boost::disable_if<boost::is_same<T, Rect2D> >::type* dummy = 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
template <int index, class T>
|
|
static bool try_object(FunctionDescriptor::Arguments& arguments, shared_ptr<T>& arg, typename boost::enable_if< boost::is_base_of<DescribedBase, T> >::type* dummy = 0)
|
|
{
|
|
shared_ptr<DescribedBase> instance;
|
|
if (!arguments.getObject(index, instance))
|
|
return false;
|
|
arg = shared_static_cast<T>(instance);
|
|
return true;
|
|
}
|
|
|
|
template <int index, class T>
|
|
static inline bool try_object(FunctionDescriptor::Arguments& arguments, T& arg, typename boost::disable_if<boost::is_convertible<T, shared_ptr<DescribedBase> > >::type* dummy = 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
template <int index, class T>
|
|
static bool try_enum(FunctionDescriptor::Arguments& arguments, T& arg, typename boost::enable_if<boost::is_enum<T> >::type* dummy = 0)
|
|
{
|
|
int a;
|
|
if (!arguments.getEnum(index, EnumDesc<T>::singleton(), a))
|
|
return false;
|
|
arg = (T) a;
|
|
return true;
|
|
}
|
|
|
|
template <int index, class T>
|
|
static inline bool try_enum(FunctionDescriptor::Arguments& arguments, T& arg, typename boost::disable_if<boost::is_enum<T> >::type* dummy = 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public:
|
|
template <typename T, int index>
|
|
static T getArg(FunctionDescriptor::Arguments& arguments, const scoped_ptr<T>& defaultArg, typename boost::disable_if<boost::is_same<T, shared_ptr<const Tuple> > >::type* dummy = 0)
|
|
{
|
|
// Use default if no argument exists
|
|
if (arguments.size() >= index)
|
|
{
|
|
// Try using direct argument access
|
|
// Good compilers will nicely no-opt all
|
|
// but one of these calls:
|
|
T arg;
|
|
if (try_integral<index, T>(arguments, arg))
|
|
return arg;
|
|
if (try_floating_point<index, T>(arguments, arg))
|
|
return arg;
|
|
if (try_string<index>(arguments, arg))
|
|
return arg;
|
|
if (try_enum<index, T>(arguments, arg))
|
|
return arg;
|
|
if (try_object<index>(arguments, arg))
|
|
return arg;
|
|
if (try_Vector3int16<index>(arguments, arg))
|
|
return arg;
|
|
if (try_Region3int16<index>(arguments, arg))
|
|
return arg;
|
|
if (try_Vector3<index>(arguments, arg))
|
|
return arg;
|
|
if (try_Region3<index>(arguments, arg))
|
|
return arg;
|
|
if (try_Rect<index>(arguments, arg))
|
|
return arg;
|
|
|
|
// Fall back to Variant
|
|
Variant v;
|
|
// nil args return false, so we use the default
|
|
// See http://lua-users.org/wiki/TrailingNilParameters
|
|
if (arguments.getVariant(index, v))
|
|
return v.convert<T>();
|
|
}
|
|
|
|
if (defaultArg)
|
|
return *defaultArg;
|
|
else
|
|
throw RBX::runtime_error("Argument %d missing or nil", index);
|
|
}
|
|
|
|
// Specialization for Tuple, which takes all arguments >= index
|
|
template <typename T, int index>
|
|
static T getArg(FunctionDescriptor::Arguments& arguments, const scoped_ptr<T>& defaultArg, typename boost::enable_if<boost::is_same<T, shared_ptr<const Tuple> > >::type* dummy = 0)
|
|
{
|
|
if (arguments.size() < index)
|
|
return shared_ptr<const Tuple>(); // no arguments. Return an null Tuple, which is shorthand for empty
|
|
|
|
// Create a tuple that is the same size as the number of arguments in the stack
|
|
shared_ptr<Tuple> tuple = rbx::make_shared<Tuple>(arguments.size() - index + 1);
|
|
for (size_t i = 0; i < tuple->values.size(); ++i)
|
|
{
|
|
// Ignore the result. It might return false for nil args, but that is OK
|
|
arguments.getVariant(index + i, tuple->values[i]);
|
|
}
|
|
// According to http://lua-users.org/wiki/TrailingNilParameters we might
|
|
// want to strip trailing nils.
|
|
return tuple;
|
|
}
|
|
};
|
|
|
|
template <class Class, typename Signature, int arity = boost::function_traits<Signature>::arity >
|
|
class BoundFuncDesc;
|
|
|
|
///////////////////
|
|
// 0 argument
|
|
template<class Class1, class FunctionPtr1, typename ResultType1>
|
|
class Call0Helper
|
|
{
|
|
public:
|
|
static void call(Class1* o, FunctionPtr1 function, Variant& returnValue)
|
|
{
|
|
returnValue = (o->*function)();
|
|
}
|
|
};
|
|
|
|
// Specialization for void return types:
|
|
template<class Class1, class FunctionPtr1>
|
|
class Call0Helper<Class1,FunctionPtr1,void>
|
|
{
|
|
public:
|
|
static void call(Class1* o, FunctionPtr1 function, Variant& returnValue)
|
|
{
|
|
(o->*function)();
|
|
}
|
|
};
|
|
|
|
|
|
// A simple version of FunctionDescriptor for member functions that take no arguments
|
|
template <class Class, typename Signature>
|
|
class BoundFuncDesc<Class, Signature, 0> : public FuncDesc<Class>
|
|
{
|
|
typedef typename boost::function_traits<Signature>::result_type result_type;
|
|
typedef result_type (Class::*FunctionPtr)();
|
|
FunctionPtr function;
|
|
|
|
void declareSignature()
|
|
{
|
|
this->signature.resultType = &Type::singleton<result_type>();
|
|
}
|
|
|
|
|
|
public:
|
|
BoundFuncDesc(FunctionPtr function, const char* name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
{
|
|
declareSignature();
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments) const
|
|
{
|
|
Call0Helper<Class,FunctionPtr,result_type>::call(boost::polymorphic_downcast<Class*>(instance),function, arguments.returnValue);
|
|
}
|
|
};
|
|
|
|
|
|
///////////////////
|
|
// 1 argument
|
|
template<class Class1, class FunctionPtr1, typename Arg1, typename ResultType1>
|
|
class Call1Helper
|
|
{
|
|
public:
|
|
static void call(Class1* o, FunctionPtr1 function, Variant& returnValue, const Arg1& arg1)
|
|
{
|
|
returnValue = (o->*function)(arg1);
|
|
}
|
|
};
|
|
|
|
// Specialization for void return types:
|
|
template<class Class1, class FunctionPtr1, typename Arg1>
|
|
class Call1Helper<Class1,FunctionPtr1, Arg1, void>
|
|
{
|
|
public:
|
|
static void call(Class1* o, FunctionPtr1 function, Variant& returnValue, const Arg1& arg1)
|
|
{
|
|
(o->*function)(arg1);
|
|
}
|
|
};
|
|
|
|
// A simple version of FunctionDescriptor for member functions that take 1 arguments
|
|
template <class Class, typename Signature>
|
|
class BoundFuncDesc<Class, Signature, 1> : public FuncDesc<Class>
|
|
{
|
|
|
|
typedef typename boost::function_traits<Signature>::result_type result_type;
|
|
typedef typename boost::function_traits<Signature>::arg1_type Arg1;
|
|
typedef result_type (Class::*FunctionPtr)(Arg1);
|
|
FunctionPtr function;
|
|
|
|
const boost::scoped_ptr<Arg1> default1;
|
|
|
|
void declareSignature(const char* arg1Name, Variant arg1Default)
|
|
{
|
|
this->signature.resultType = &Type::singleton<result_type>();
|
|
this->signature.addArgument(RBX::Name::declare(arg1Name), Type::singleton<Arg1>(), arg1Default);
|
|
}
|
|
|
|
public:
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, Arg1 default1, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default1(new Arg1(default1))
|
|
{
|
|
declareSignature(arg1Name, default1);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant());
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments) const
|
|
{
|
|
Call1Helper<Class,FunctionPtr,Arg1,result_type>::call(boost::polymorphic_downcast<Class*>(instance), function,
|
|
arguments.returnValue,
|
|
ArgHelper::getArg<Arg1, 1>(arguments, default1)
|
|
);
|
|
}
|
|
};
|
|
|
|
///////////////////
|
|
// 2 arguments
|
|
|
|
template<class Class1, class FunctionPtr1, typename Arg1, typename Arg2, typename ResultType1>
|
|
class Call2Helper
|
|
{
|
|
public:
|
|
static void call(Class1* o, FunctionPtr1 function, Variant& returnValue, const Arg1& arg1, const Arg2& arg2)
|
|
{
|
|
returnValue = (o->*function)(arg1, arg2 );
|
|
}
|
|
};
|
|
|
|
// Specialization for void return types:
|
|
template<class Class1, class FunctionPtr1, typename Arg1, typename Arg2>
|
|
class Call2Helper<Class1,FunctionPtr1, Arg1, Arg2, void>
|
|
{
|
|
public:
|
|
static void call(Class1* o, FunctionPtr1 function, Variant& returnValue, const Arg1& arg1, const Arg2& arg2)
|
|
{
|
|
(o->*function)(arg1, arg2);
|
|
}
|
|
};
|
|
|
|
|
|
// A simple version of FunctionDescriptor for member functions that take 3 arguments
|
|
template <class Class, typename Signature>
|
|
class BoundFuncDesc<Class, Signature, 2> : public FuncDesc<Class>
|
|
{
|
|
typedef typename boost::function_traits<Signature>::result_type result_type;
|
|
typedef typename boost::function_traits<Signature>::arg1_type Arg1;
|
|
typedef typename boost::function_traits<Signature>::arg2_type Arg2;
|
|
typedef result_type (Class::*FunctionPtr)(Arg1, Arg2);
|
|
FunctionPtr function;
|
|
|
|
const boost::scoped_ptr<Arg1> default1;
|
|
const boost::scoped_ptr<Arg2> default2;
|
|
|
|
void declareSignature(const char* arg1Name, Variant arg1Default, const char* arg2Name, Variant arg2Default)
|
|
{
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg1, shared_ptr<const Tuple> >::value));
|
|
this->signature.resultType = &Type::singleton<result_type>();
|
|
this->signature.addArgument(RBX::Name::declare(arg1Name), Type::singleton<Arg1>(), arg1Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg2Name), Type::singleton<Arg2>(), arg2Default);
|
|
}
|
|
|
|
public:
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, Arg1 default1, const char* arg2Name, Arg2 default2, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default2(new Arg2(default2))
|
|
,default1(new Arg1(default1))
|
|
{
|
|
declareSignature(arg1Name, default1, arg2Name, default2);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, Arg2 default2, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default2(new Arg2(default2))
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, default2);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant());
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments) const
|
|
{
|
|
Call2Helper<Class,FunctionPtr,Arg1, Arg2,result_type>::call(boost::polymorphic_downcast<Class*>(instance),
|
|
function,
|
|
arguments.returnValue,
|
|
ArgHelper::getArg<Arg1, 1>(arguments, default1),
|
|
ArgHelper::getArg<Arg2, 2>(arguments, default2));
|
|
}
|
|
};
|
|
|
|
|
|
///////////////////
|
|
// 3 arguments
|
|
|
|
template<class Class1, class FunctionPtr1, typename Arg1, typename Arg2, typename Arg3, typename ResultType1>
|
|
class Call3Helper
|
|
{
|
|
public:
|
|
static void call(Class1* o, FunctionPtr1 function, Variant& returnValue, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
|
|
{
|
|
returnValue = (o->*function)(arg1, arg2, arg3 );
|
|
}
|
|
};
|
|
|
|
// Specialization for void return types:
|
|
template<class Class1, class FunctionPtr1, typename Arg1, typename Arg2, typename Arg3>
|
|
class Call3Helper<Class1,FunctionPtr1, Arg1, Arg2, Arg3, void>
|
|
{
|
|
public:
|
|
static void call(Class1* o, FunctionPtr1 function, Variant& returnValue, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3)
|
|
{
|
|
(o->*function)(arg1, arg2, arg3);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
// A simple version of FunctionDescriptor for member functions that take 3 arguments
|
|
template <class Class, typename Signature>
|
|
class BoundFuncDesc<Class, Signature, 3> : public FuncDesc<Class>
|
|
{
|
|
typedef typename boost::function_traits<Signature>::result_type result_type;
|
|
typedef typename boost::function_traits<Signature>::arg1_type Arg1;
|
|
typedef typename boost::function_traits<Signature>::arg2_type Arg2;
|
|
typedef typename boost::function_traits<Signature>::arg3_type Arg3;
|
|
typedef result_type (Class::*FunctionPtr)(Arg1, Arg2, Arg3);
|
|
FunctionPtr function;
|
|
|
|
const boost::scoped_ptr<Arg1> default1;
|
|
const boost::scoped_ptr<Arg2> default2;
|
|
const boost::scoped_ptr<Arg3> default3;
|
|
|
|
void declareSignature(const char* arg1Name, Variant arg1Default, const char* arg2Name, Variant arg2Default, const char* arg3Name, Variant arg3Default)
|
|
{
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg1, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg2, shared_ptr<const Tuple> >::value));
|
|
this->signature.resultType = &Type::singleton<result_type>();
|
|
this->signature.addArgument(RBX::Name::declare(arg1Name), Type::singleton<Arg1>(), arg1Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg2Name), Type::singleton<Arg2>(), arg2Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg3Name), Type::singleton<Arg3>(), arg3Default);
|
|
}
|
|
|
|
public:
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, Arg1 default1, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1(new Arg1(default1))
|
|
{
|
|
declareSignature(arg1Name, default1, arg2Name, default2, arg3Name, default3);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, default2, arg3Name, default3);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, Arg3 default3, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default3(new Arg3(default3))
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, default3);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant());
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments) const
|
|
{
|
|
Call3Helper<Class,FunctionPtr,Arg1,Arg2,Arg3,result_type>::call(boost::polymorphic_downcast<Class*>(instance),
|
|
function,
|
|
arguments.returnValue,
|
|
ArgHelper::getArg<Arg1, 1>(arguments, default1),
|
|
ArgHelper::getArg<Arg2, 2>(arguments, default2),
|
|
ArgHelper::getArg<Arg3, 3>(arguments, default3));
|
|
}
|
|
};
|
|
|
|
///////////////////
|
|
// 4 arguments
|
|
|
|
template<class Class1, class FunctionPtr1, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename ResultType1>
|
|
class Call4Helper
|
|
{
|
|
public:
|
|
static void call(Class1* o, FunctionPtr1 function, Variant& returnValue, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4)
|
|
{
|
|
returnValue = (o->*function)(arg1, arg2, arg3, arg4 );
|
|
}
|
|
};
|
|
|
|
// Specialization for void return types:
|
|
template<class Class1, class FunctionPtr1, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
|
|
class Call4Helper<Class1,FunctionPtr1, Arg1, Arg2, Arg3, Arg4, void>
|
|
{
|
|
public:
|
|
static void call(Class1* o, FunctionPtr1 function, Variant& returnValue, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4)
|
|
{
|
|
(o->*function)(arg1, arg2, arg3, arg4);
|
|
}
|
|
};
|
|
|
|
// A simple version of FunctionDescriptor for member functions that take 4 arguments
|
|
template <class Class, typename Signature>
|
|
class BoundFuncDesc<Class, Signature, 4> : public FuncDesc<Class>
|
|
{
|
|
typedef typename boost::function_traits<Signature>::result_type result_type;
|
|
typedef typename boost::function_traits<Signature>::arg1_type Arg1;
|
|
typedef typename boost::function_traits<Signature>::arg2_type Arg2;
|
|
typedef typename boost::function_traits<Signature>::arg3_type Arg3;
|
|
typedef typename boost::function_traits<Signature>::arg4_type Arg4;
|
|
typedef result_type (Class::*FunctionPtr)(Arg1, Arg2, Arg3, Arg4);
|
|
FunctionPtr function;
|
|
|
|
const boost::scoped_ptr<Arg1> default1;
|
|
const boost::scoped_ptr<Arg2> default2;
|
|
const boost::scoped_ptr<Arg3> default3;
|
|
const boost::scoped_ptr<Arg4> default4;
|
|
|
|
void declareSignature(const char* arg1Name, Variant arg1Default, const char* arg2Name, Variant arg2Default, const char* arg3Name, Variant arg3Default, const char* arg4Name, Variant arg4Default)
|
|
{
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg1, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg2, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg3, shared_ptr<const Tuple> >::value));
|
|
this->signature.resultType = &Type::singleton<result_type>();
|
|
this->signature.addArgument(RBX::Name::declare(arg1Name), Type::singleton<Arg1>(), arg1Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg2Name), Type::singleton<Arg2>(), arg2Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg3Name), Type::singleton<Arg3>(), arg3Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg4Name), Type::singleton<Arg4>(), arg4Default);
|
|
}
|
|
|
|
public:
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, Arg1 default1, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1(new Arg1(default1))
|
|
{
|
|
declareSignature(arg1Name, default1, arg2Name, default2, arg3Name, default3, arg4Name, default4);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, default2, arg3Name, default3, arg4Name, default4);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, default3, arg4Name, default4);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, Arg4 default4, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default4(new Arg4(default4))
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, default4);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default4()
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, Variant());
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments) const
|
|
{
|
|
Call4Helper<Class,FunctionPtr,Arg1,Arg2,Arg3,Arg4,result_type>::call(boost::polymorphic_downcast<Class*>(instance),
|
|
function,
|
|
arguments.returnValue,
|
|
ArgHelper::getArg<Arg1, 1>(arguments, default1),
|
|
ArgHelper::getArg<Arg2, 2>(arguments, default2),
|
|
ArgHelper::getArg<Arg3, 3>(arguments, default3),
|
|
ArgHelper::getArg<Arg4, 4>(arguments, default4));
|
|
|
|
}
|
|
};
|
|
|
|
///////////////////
|
|
// 5 arguments
|
|
|
|
template<class Class1, class FunctionPtr1, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename ResultType1>
|
|
class Call5Helper
|
|
{
|
|
public:
|
|
static void call(Class1* o, FunctionPtr1 function, Variant& returnValue, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
|
|
{
|
|
returnValue = (o->*function)(arg1, arg2, arg3, arg4, arg5 );
|
|
}
|
|
};
|
|
|
|
// Specialization for void return types:
|
|
template<class Class1, class FunctionPtr1, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
|
|
class Call5Helper<Class1,FunctionPtr1, Arg1, Arg2, Arg3, Arg4, Arg5, void>
|
|
{
|
|
public:
|
|
static void call(Class1* o, FunctionPtr1 function, Variant& returnValue, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5)
|
|
{
|
|
(o->*function)(arg1, arg2, arg3, arg4, arg5);
|
|
}
|
|
};
|
|
|
|
// A simple version of FunctionDescriptor for member functions that take 5 arguments
|
|
template <class Class, typename Signature>
|
|
class BoundFuncDesc<Class, Signature, 5> : public FuncDesc<Class>
|
|
{
|
|
typedef typename boost::function_traits<Signature>::result_type result_type;
|
|
typedef typename boost::function_traits<Signature>::arg1_type Arg1;
|
|
typedef typename boost::function_traits<Signature>::arg2_type Arg2;
|
|
typedef typename boost::function_traits<Signature>::arg3_type Arg3;
|
|
typedef typename boost::function_traits<Signature>::arg4_type Arg4;
|
|
typedef typename boost::function_traits<Signature>::arg5_type Arg5;
|
|
typedef result_type (Class::*FunctionPtr)(Arg1, Arg2, Arg3, Arg4, Arg5);
|
|
FunctionPtr function;
|
|
|
|
const boost::scoped_ptr<Arg1> default1;
|
|
const boost::scoped_ptr<Arg2> default2;
|
|
const boost::scoped_ptr<Arg3> default3;
|
|
const boost::scoped_ptr<Arg4> default4;
|
|
const boost::scoped_ptr<Arg5> default5;
|
|
|
|
void declareSignature(const char* arg1Name, Variant arg1Default, const char* arg2Name, Variant arg2Default, const char* arg3Name, Variant arg3Default, const char* arg4Name, Variant arg4Default, const char* arg5Name, Variant arg5Default)
|
|
{
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg1, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg2, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg3, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg4, shared_ptr<const Tuple> >::value));
|
|
this->signature.resultType = &Type::singleton<result_type>();
|
|
this->signature.addArgument(RBX::Name::declare(arg1Name), Type::singleton<Arg1>(), arg1Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg2Name), Type::singleton<Arg2>(), arg2Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg3Name), Type::singleton<Arg3>(), arg3Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg4Name), Type::singleton<Arg4>(), arg4Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg5Name), Type::singleton<Arg5>(), arg5Default);
|
|
}
|
|
|
|
public:
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, Arg1 default1, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg5 default5, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1(new Arg1(default1))
|
|
{
|
|
declareSignature(arg1Name, default1, arg2Name, default2, arg3Name, default3, arg4Name, default4, arg5Name, default5);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg5 default5, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, default2, arg3Name, default3, arg4Name, default4, arg5Name, default5);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg5 default5, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, default3, arg4Name, default4, arg5Name, default5);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg5 default5, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, default4, arg5Name, default5);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, const char* arg5Name, Arg5 default5, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default5(new Arg5(default5))
|
|
,default4()
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, Variant(), arg5Name, default5);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, const char* arg5Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default5()
|
|
,default4()
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, Variant(), arg5Name, Variant());
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments) const
|
|
{
|
|
Call5Helper<Class,FunctionPtr,Arg1,Arg2,Arg3,Arg4,Arg5,result_type>::call(boost::polymorphic_downcast<Class*>(instance),
|
|
function,
|
|
arguments.returnValue,
|
|
ArgHelper::getArg<Arg1, 1>(arguments, default1),
|
|
ArgHelper::getArg<Arg2, 2>(arguments, default2),
|
|
ArgHelper::getArg<Arg3, 3>(arguments, default3),
|
|
ArgHelper::getArg<Arg4, 4>(arguments, default4),
|
|
ArgHelper::getArg<Arg5, 5>(arguments, default5));
|
|
|
|
}
|
|
};
|
|
|
|
///////////////////
|
|
// 6 arguments
|
|
|
|
template<class Class1, class FunctionPtr1, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename ResultType1>
|
|
class Call6Helper
|
|
{
|
|
public:
|
|
static void call(Class1* o, FunctionPtr1 function, Variant& returnValue, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5, const Arg6& arg6)
|
|
{
|
|
returnValue = (o->*function)(arg1, arg2, arg3, arg4, arg5, arg6);
|
|
}
|
|
};
|
|
|
|
// Specialization for void return types:
|
|
template<class Class1, class FunctionPtr1, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6>
|
|
class Call6Helper<Class1,FunctionPtr1, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, void>
|
|
{
|
|
public:
|
|
static void call(Class1* o, FunctionPtr1 function, Variant& returnValue, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5, const Arg6& arg6)
|
|
{
|
|
(o->*function)(arg1, arg2, arg3, arg4, arg5, arg6);
|
|
}
|
|
};
|
|
|
|
// A simple version of FunctionDescriptor for member functions that take 5 arguments
|
|
template <class Class, typename Signature>
|
|
class BoundFuncDesc<Class, Signature, 6> : public FuncDesc<Class>
|
|
{
|
|
typedef typename boost::function_traits<Signature>::result_type result_type;
|
|
typedef typename boost::function_traits<Signature>::arg1_type Arg1;
|
|
typedef typename boost::function_traits<Signature>::arg2_type Arg2;
|
|
typedef typename boost::function_traits<Signature>::arg3_type Arg3;
|
|
typedef typename boost::function_traits<Signature>::arg4_type Arg4;
|
|
typedef typename boost::function_traits<Signature>::arg5_type Arg5;
|
|
typedef typename boost::function_traits<Signature>::arg6_type Arg6;
|
|
typedef result_type (Class::*FunctionPtr)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6);
|
|
FunctionPtr function;
|
|
|
|
const boost::scoped_ptr<Arg1> default1;
|
|
const boost::scoped_ptr<Arg2> default2;
|
|
const boost::scoped_ptr<Arg3> default3;
|
|
const boost::scoped_ptr<Arg4> default4;
|
|
const boost::scoped_ptr<Arg5> default5;
|
|
const boost::scoped_ptr<Arg6> default6;
|
|
|
|
void declareSignature(const char* arg1Name, Variant arg1Default, const char* arg2Name, Variant arg2Default, const char* arg3Name, Variant arg3Default, const char* arg4Name, Variant arg4Default, const char* arg5Name, Variant arg5Default, const char* arg6Name, Variant arg6Default)
|
|
{
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg1, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg2, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg3, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg4, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg5, shared_ptr<const Tuple> >::value));
|
|
this->signature.resultType = &Type::singleton<result_type>();
|
|
this->signature.addArgument(RBX::Name::declare(arg1Name), Type::singleton<Arg1>(), arg1Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg2Name), Type::singleton<Arg2>(), arg2Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg3Name), Type::singleton<Arg3>(), arg3Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg4Name), Type::singleton<Arg4>(), arg4Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg5Name), Type::singleton<Arg5>(), arg5Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg6Name), Type::singleton<Arg6>(), arg6Default);
|
|
}
|
|
|
|
public:
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, Arg1 default1, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg5 default5, const char* arg6Name, Arg6 default6, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default6(new Arg6(default6))
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1(new Arg1(default1))
|
|
{
|
|
declareSignature(arg1Name, default1, arg2Name, default2, arg3Name, default3, arg4Name, default4, arg5Name, default5, arg6Name, default6);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg5 default5, const char* arg6Name, Arg6 default6, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default6(new Arg6(default6))
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, default2, arg3Name, default3, arg4Name, default4, arg5Name, default5, arg6Name, default6);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg5 default5, const char* arg6Name, Arg6 default6, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default6(new Arg6(default6))
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, default3, arg4Name, default4, arg5Name, default5, arg6Name, default6);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg5 default5, const char* arg6Name, Arg6 default6, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default6(new Arg6(default6))
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, default4, arg5Name, default5, arg6Name, default6);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, const char* arg5Name, Arg5 default5, const char* arg6Name, Arg6 default6, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default6(new Arg6(default6))
|
|
,default5(new Arg5(default5))
|
|
,default4()
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, Variant(), arg5Name, default5, arg6Name, default6);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, const char* arg5Name, const char* arg6Name, Arg6 default6, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default6(new Arg6(default6))
|
|
,default5()
|
|
,default4()
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, Variant(), arg5Name, Variant(), arg6Name, default6);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, const char* arg5Name, const char* arg6Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default6()
|
|
,default5()
|
|
,default4()
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, Variant(), arg5Name, Variant(), arg6Name, Variant());
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments) const
|
|
{
|
|
Call6Helper<Class,FunctionPtr,Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,result_type>::call(boost::polymorphic_downcast<Class*>(instance),
|
|
function,
|
|
arguments.returnValue,
|
|
ArgHelper::getArg<Arg1, 1>(arguments, default1),
|
|
ArgHelper::getArg<Arg2, 2>(arguments, default2),
|
|
ArgHelper::getArg<Arg3, 3>(arguments, default3),
|
|
ArgHelper::getArg<Arg4, 4>(arguments, default4),
|
|
ArgHelper::getArg<Arg5, 5>(arguments, default5),
|
|
ArgHelper::getArg<Arg6, 6>(arguments, default6));
|
|
|
|
}
|
|
};
|
|
|
|
///////////////////
|
|
// 7 arguments
|
|
|
|
template<class Class1, class FunctionPtr1, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7, typename ResultType1>
|
|
class Call7Helper
|
|
{
|
|
public:
|
|
static void call(Class1* o, FunctionPtr1 function, Variant& returnValue, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5, const Arg6& arg6, const Arg7& arg7)
|
|
{
|
|
returnValue = (o->*function)(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
|
|
}
|
|
};
|
|
|
|
// Specialization for void return types:
|
|
template<class Class1, class FunctionPtr1, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5, typename Arg6, typename Arg7>
|
|
class Call7Helper<Class1,FunctionPtr1, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7, void>
|
|
{
|
|
public:
|
|
static void call(Class1* o, FunctionPtr1 function, Variant& returnValue, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5, const Arg6& arg6, const Arg7& arg7)
|
|
{
|
|
(o->*function)(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
|
|
}
|
|
};
|
|
|
|
// A simple version of FunctionDescriptor for member functions that take 5 arguments
|
|
template <class Class, typename Signature>
|
|
class BoundFuncDesc<Class, Signature, 7> : public FuncDesc<Class>
|
|
{
|
|
typedef typename boost::function_traits<Signature>::result_type result_type;
|
|
typedef typename boost::function_traits<Signature>::arg1_type Arg1;
|
|
typedef typename boost::function_traits<Signature>::arg2_type Arg2;
|
|
typedef typename boost::function_traits<Signature>::arg3_type Arg3;
|
|
typedef typename boost::function_traits<Signature>::arg4_type Arg4;
|
|
typedef typename boost::function_traits<Signature>::arg5_type Arg5;
|
|
typedef typename boost::function_traits<Signature>::arg6_type Arg6;
|
|
typedef typename boost::function_traits<Signature>::arg7_type Arg7;
|
|
typedef result_type (Class::*FunctionPtr)(Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7);
|
|
FunctionPtr function;
|
|
|
|
const boost::scoped_ptr<Arg1> default1;
|
|
const boost::scoped_ptr<Arg2> default2;
|
|
const boost::scoped_ptr<Arg3> default3;
|
|
const boost::scoped_ptr<Arg4> default4;
|
|
const boost::scoped_ptr<Arg5> default5;
|
|
const boost::scoped_ptr<Arg6> default6;
|
|
const boost::scoped_ptr<Arg7> default7;
|
|
|
|
void declareSignature(const char* arg1Name, Variant arg1Default, const char* arg2Name, Variant arg2Default, const char* arg3Name, Variant arg3Default, const char* arg4Name, Variant arg4Default, const char* arg5Name, Variant arg5Default, const char* arg6Name, Variant arg6Default, const char* arg7Name, Variant arg7Default)
|
|
{
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg1, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg2, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg3, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg4, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg5, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg6, shared_ptr<const Tuple> >::value));
|
|
this->signature.resultType = &Type::singleton<result_type>();
|
|
this->signature.addArgument(RBX::Name::declare(arg1Name), Type::singleton<Arg1>(), arg1Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg2Name), Type::singleton<Arg2>(), arg2Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg3Name), Type::singleton<Arg3>(), arg3Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg4Name), Type::singleton<Arg4>(), arg4Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg5Name), Type::singleton<Arg5>(), arg5Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg6Name), Type::singleton<Arg6>(), arg6Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg7Name), Type::singleton<Arg7>(), arg7Default);
|
|
}
|
|
|
|
public:
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, Arg1 default1, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg5 default5, const char* arg6Name, Arg6 default6, const char* arg7Name, Arg7 default7, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default7(new Arg7(default7))
|
|
,default6(new Arg6(default6))
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1(new Arg1(default1))
|
|
{
|
|
declareSignature(arg1Name, default1, arg2Name, default2, arg3Name, default3, arg4Name, default4, arg5Name, default5, arg6Name, default6, arg7Name, default7);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg5 default5, const char* arg6Name, Arg6 default6, const char* arg7Name, Arg7 default7, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default7(new Arg7(default7))
|
|
,default6(new Arg6(default6))
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, default2, arg3Name, default3, arg4Name, default4, arg5Name, default5, arg6Name, default6, arg7Name, default7);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg5 default5, const char* arg6Name, Arg6 default6, const char* arg7Name, Arg7 default7, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default7(new Arg7(default7))
|
|
,default6(new Arg6(default6))
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, default3, arg4Name, default4, arg5Name, default5, arg6Name, default6, arg7Name, default7);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg5 default5, const char* arg6Name, Arg6 default6, const char* arg7Name, Arg7 default7, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default7(new Arg7(default7))
|
|
,default6(new Arg6(default6))
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, default4, arg5Name, default5, arg6Name, default6, arg7Name, default7);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, const char* arg5Name, Arg5 default5, const char* arg6Name, Arg6 default6, const char* arg7Name, Arg7 default7, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default7(new Arg7(default7))
|
|
,default6(new Arg6(default6))
|
|
,default5(new Arg5(default5))
|
|
,default4()
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, Variant(), arg5Name, default5, arg6Name, default6, arg7Name, default7);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, const char* arg5Name, const char* arg6Name, Arg6 default6, const char* arg7Name, Arg7 default7, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default7(new Arg7(default7))
|
|
,default6(new Arg6(default6))
|
|
,default5()
|
|
,default4()
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, Variant(), arg5Name, Variant(), arg6Name, default6, arg7Name, default7);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, const char* arg5Name, const char* arg6Name, const char* arg7Name, Arg7 default7, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,default7(new Arg7(default7))
|
|
,default6()
|
|
,default5()
|
|
,default4()
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
,function(function)
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, Variant(), arg5Name, Variant(), arg6Name, Variant(), arg7Name, default7);
|
|
}
|
|
|
|
BoundFuncDesc(FunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, const char* arg5Name, const char* arg6Name, const char* arg7Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:FuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default7()
|
|
,default6()
|
|
,default5()
|
|
,default4()
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, Variant(), arg5Name, Variant(), arg6Name, Variant(), arg7Name, Variant());
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments) const
|
|
{
|
|
Call7Helper<Class,FunctionPtr,Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7,result_type>::call(boost::polymorphic_downcast<Class*>(instance),
|
|
function,
|
|
arguments.returnValue,
|
|
ArgHelper::getArg<Arg1, 1>(arguments, default1),
|
|
ArgHelper::getArg<Arg2, 2>(arguments, default2),
|
|
ArgHelper::getArg<Arg3, 3>(arguments, default3),
|
|
ArgHelper::getArg<Arg4, 4>(arguments, default4),
|
|
ArgHelper::getArg<Arg5, 5>(arguments, default5),
|
|
ArgHelper::getArg<Arg6, 6>(arguments, default6),
|
|
ArgHelper::getArg<Arg7, 7>(arguments, default7));
|
|
|
|
}
|
|
};
|
|
|
|
|
|
template <class Class>
|
|
class YieldFuncDesc : public YieldFunctionDescriptor
|
|
{
|
|
protected:
|
|
YieldFuncDesc(const char* name, Security::Permissions security, Attributes attributes)
|
|
:YieldFunctionDescriptor(Class::classDescriptor(), name, security, attributes)
|
|
{
|
|
}
|
|
};
|
|
|
|
template<typename ReturnType>
|
|
static void resume_adapter(boost::function<void(Variant)> resumeFunction, ReturnType returnValue)
|
|
{
|
|
Variant value = returnValue;
|
|
resumeFunction(value);
|
|
}
|
|
|
|
|
|
template <class Class, typename Signature, typename ReturnType = typename boost::function_traits<Signature>::result_type, int arity = boost::function_traits<Signature>::arity >
|
|
class BoundYieldFuncDesc;
|
|
|
|
// ReturnType() specialization
|
|
template <class Class, typename Signature, typename ReturnType>
|
|
class BoundYieldFuncDesc<Class, Signature, ReturnType, 0> : public YieldFuncDesc<Class>
|
|
{
|
|
typedef void (Class::*YieldFunctionPtr)(boost::function<void(ReturnType)> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
YieldFunctionPtr function;
|
|
|
|
void declareSignature()
|
|
{
|
|
this->signature.resultType = &Type::singleton<ReturnType>();
|
|
}
|
|
|
|
public:
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
{
|
|
declareSignature();
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments, boost::function<void(Variant)> resumeFunction, boost::function<void(std::string)> errorFunction) const
|
|
{
|
|
(boost::polymorphic_downcast<Class*>(instance)->*function)(
|
|
boost::bind(&resume_adapter<ReturnType>, resumeFunction, _1), errorFunction);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
// void() specialization
|
|
template <class Class, typename Signature>
|
|
class BoundYieldFuncDesc<Class, Signature, void, 0> : public YieldFuncDesc<Class>
|
|
{
|
|
typedef void (Class::*YieldFunctionPtr)(boost::function<void()> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
YieldFunctionPtr function;
|
|
|
|
void declareSignature()
|
|
{
|
|
this->signature.resultType = &Type::singleton<void>();
|
|
}
|
|
|
|
public:
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
{
|
|
declareSignature();
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments, boost::function<void(Variant)> resumeFunction, boost::function<void(std::string)> errorFunction) const
|
|
{
|
|
(boost::polymorphic_downcast<Class*>(instance)->*function)(
|
|
boost::bind(resumeFunction, Variant()), errorFunction);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
// A simple version of FunctionDescriptor for member functions that take 1 arguments
|
|
template <class Class, typename Signature, typename ReturnType>
|
|
class BoundYieldFuncDesc<Class, Signature, ReturnType, 1> : public YieldFuncDesc<Class>
|
|
{
|
|
typedef typename boost::function_traits<Signature>::arg1_type Arg1;
|
|
typedef void (Class::*YieldFunctionPtr)(Arg1, boost::function<void(ReturnType)> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
YieldFunctionPtr function;
|
|
|
|
const boost::scoped_ptr<Arg1> default1;
|
|
|
|
void declareSignature(const char* arg1Name, Variant arg1Default)
|
|
{
|
|
this->signature.resultType = &Type::singleton<ReturnType>();
|
|
this->signature.addArgument(RBX::Name::declare(arg1Name), Type::singleton<Arg1>(), arg1Default);
|
|
}
|
|
|
|
public:
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, Arg1 default1, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default1(new Arg1(default1))
|
|
{
|
|
declareSignature(arg1Name, default1);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant());
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments, boost::function<void(Variant)> resumeFunction, boost::function<void(std::string)> errorFunction) const
|
|
{
|
|
(boost::polymorphic_downcast<Class*>(instance)->*function)(
|
|
ArgHelper::getArg<Arg1, 1>(arguments, default1),
|
|
boost::bind(&resume_adapter<ReturnType>, resumeFunction, _1), errorFunction);
|
|
}
|
|
};
|
|
|
|
|
|
// void(Arg1) specialization
|
|
template <class Class, typename Signature>
|
|
class BoundYieldFuncDesc<Class, Signature, void, 1> : public YieldFuncDesc<Class>
|
|
{
|
|
typedef typename boost::function_traits<Signature>::arg1_type Arg1;
|
|
typedef void (Class::*YieldFunctionPtr)(Arg1, boost::function<void(void)> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
YieldFunctionPtr function;
|
|
|
|
const boost::scoped_ptr<Arg1> default1;
|
|
|
|
void declareSignature(const char* arg1Name, Variant arg1Default)
|
|
{
|
|
this->signature.resultType = &Type::singleton<void>();
|
|
this->signature.addArgument(RBX::Name::declare(arg1Name), Type::singleton<Arg1>(), arg1Default);
|
|
}
|
|
|
|
public:
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, Arg1 default1, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default1(new Arg1(default1))
|
|
{
|
|
declareSignature(arg1Name, default1);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant());
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments, boost::function<void(Variant)> resumeFunction, boost::function<void(std::string)> errorFunction) const
|
|
{
|
|
(boost::polymorphic_downcast<Class*>(instance)->*function)(
|
|
ArgHelper::getArg<Arg1, 1>(arguments, default1),
|
|
boost::bind(resumeFunction, Variant()), errorFunction);
|
|
}
|
|
};
|
|
|
|
|
|
// A simple version of FunctionDescriptor for member functions that take 2 arguments
|
|
template <class Class, typename Signature, typename ReturnType>
|
|
class BoundYieldFuncDesc<Class, Signature, ReturnType, 2> : public YieldFuncDesc<Class>
|
|
{
|
|
typedef typename boost::function_traits<Signature>::arg1_type Arg1;
|
|
typedef typename boost::function_traits<Signature>::arg2_type Arg2;
|
|
typedef void (Class::*YieldFunctionPtr)(Arg1, Arg2, boost::function<void(ReturnType)> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
YieldFunctionPtr function;
|
|
|
|
const boost::scoped_ptr<Arg1> default1;
|
|
const boost::scoped_ptr<Arg2> default2;
|
|
|
|
void declareSignature(const char* arg1Name, Variant arg1Default, const char* arg2Name, Variant arg2Default)
|
|
{
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg1, shared_ptr<const Tuple> >::value));
|
|
this->signature.resultType = &Type::singleton<ReturnType>();
|
|
this->signature.addArgument(RBX::Name::declare(arg1Name), Type::singleton<Arg1>(), arg1Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg2Name), Type::singleton<Arg2>(), arg2Default);
|
|
}
|
|
|
|
public:
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, Arg1 default1, const char* arg2Name, Arg2 default2, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default2(new Arg2(default2))
|
|
,default1(new Arg1(default1))
|
|
{
|
|
declareSignature(arg1Name, default1, arg2Name, default2);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, Arg2 default2, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default2(new Arg2(default2))
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, default2);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant());
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments, boost::function<void(Variant)> resumeFunction, boost::function<void(std::string)> errorFunction) const
|
|
{
|
|
(boost::polymorphic_downcast<Class*>(instance)->*function)(
|
|
ArgHelper::getArg<Arg1, 1>(arguments, default1),
|
|
ArgHelper::getArg<Arg2, 2>(arguments, default2),
|
|
boost::bind(&resume_adapter<ReturnType>, resumeFunction, _1), errorFunction);
|
|
}
|
|
};
|
|
|
|
|
|
// void(Arg1, Arg2) specialization
|
|
template <class Class, typename Signature>
|
|
class BoundYieldFuncDesc<Class, Signature, void, 2> : public YieldFuncDesc<Class>
|
|
{
|
|
typedef typename boost::function_traits<Signature>::arg1_type Arg1;
|
|
typedef typename boost::function_traits<Signature>::arg2_type Arg2;
|
|
typedef void (Class::*YieldFunctionPtr)(Arg1, Arg2, boost::function<void(void)> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
YieldFunctionPtr function;
|
|
|
|
const boost::scoped_ptr<Arg1> default1;
|
|
const boost::scoped_ptr<Arg2> default2;
|
|
|
|
void declareSignature(const char* arg1Name, Variant arg1Default, const char* arg2Name, Variant arg2Default)
|
|
{
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg1, shared_ptr<const Tuple> >::value));
|
|
this->signature.resultType = &Type::singleton<void>();
|
|
this->signature.addArgument(RBX::Name::declare(arg1Name), Type::singleton<Arg1>(), arg1Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg2Name), Type::singleton<Arg2>(), arg2Default);
|
|
}
|
|
|
|
public:
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, Arg1 default1, const char* arg2Name, Arg2 default2, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default2(new Arg2(default2))
|
|
,default1(new Arg1(default1))
|
|
{
|
|
declareSignature(arg1Name, default1, arg2Name, default2);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, Arg2 default2, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default2(new Arg2(default2))
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, default2);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant());
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments, boost::function<void(Variant)> resumeFunction, boost::function<void(std::string)> errorFunction) const
|
|
{
|
|
(boost::polymorphic_downcast<Class*>(instance)->*function)(
|
|
ArgHelper::getArg<Arg1, 1>(arguments, default1),
|
|
ArgHelper::getArg<Arg2, 2>(arguments, default2),
|
|
boost::bind(resumeFunction, Variant()), errorFunction);
|
|
}
|
|
};
|
|
|
|
|
|
// A simple version of FunctionDescriptor for member functions that take 3 arguments
|
|
template <class Class, typename Signature, typename ReturnType>
|
|
class BoundYieldFuncDesc<Class, Signature, ReturnType, 3> : public YieldFuncDesc<Class>
|
|
{
|
|
typedef typename boost::function_traits<Signature>::arg1_type Arg1;
|
|
typedef typename boost::function_traits<Signature>::arg2_type Arg2;
|
|
typedef typename boost::function_traits<Signature>::arg3_type Arg3;
|
|
typedef void (Class::*YieldFunctionPtr)(Arg1, Arg2, Arg3, boost::function<void(ReturnType)> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
YieldFunctionPtr function;
|
|
|
|
const boost::scoped_ptr<Arg1> default1;
|
|
const boost::scoped_ptr<Arg2> default2;
|
|
const boost::scoped_ptr<Arg3> default3;
|
|
|
|
void declareSignature(const char* arg1Name, Variant arg1Default, const char* arg2Name, Variant arg2Default, const char* arg3Name, Variant arg3Default)
|
|
{
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg1, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg2, shared_ptr<const Tuple> >::value));
|
|
this->signature.resultType = &Type::singleton<ReturnType>();
|
|
this->signature.addArgument(RBX::Name::declare(arg1Name), Type::singleton<Arg1>(), arg1Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg2Name), Type::singleton<Arg2>(), arg2Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg3Name), Type::singleton<Arg3>(), arg3Default);
|
|
}
|
|
|
|
public:
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, Arg1 default1, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1(new Arg1(default1))
|
|
{
|
|
declareSignature(arg1Name, default1, arg2Name, default2, arg3Name, default3);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, default2, arg3Name, default3);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, Arg3 default3, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default3(new Arg3(default3))
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, default3);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant());
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments, boost::function<void(Variant)> resumeFunction, boost::function<void(std::string)> errorFunction) const
|
|
{
|
|
(boost::polymorphic_downcast<Class*>(instance)->*function)(
|
|
ArgHelper::getArg<Arg1, 1>(arguments, default1),
|
|
ArgHelper::getArg<Arg2, 2>(arguments, default2),
|
|
ArgHelper::getArg<Arg3, 3>(arguments, default3),
|
|
boost::bind(&resume_adapter<ReturnType>, resumeFunction, _1), errorFunction);
|
|
}
|
|
};
|
|
|
|
|
|
// void(Arg1, Arg2, Arg3) specialization
|
|
template <class Class, typename Signature>
|
|
class BoundYieldFuncDesc<Class, Signature, void, 3> : public YieldFuncDesc<Class>
|
|
{
|
|
typedef typename boost::function_traits<Signature>::arg1_type Arg1;
|
|
typedef typename boost::function_traits<Signature>::arg2_type Arg2;
|
|
typedef typename boost::function_traits<Signature>::arg3_type Arg3;
|
|
typedef void (Class::*YieldFunctionPtr)(Arg1, Arg2, Arg3, boost::function<void(void)> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
YieldFunctionPtr function;
|
|
|
|
const boost::scoped_ptr<Arg1> default1;
|
|
const boost::scoped_ptr<Arg2> default2;
|
|
const boost::scoped_ptr<Arg3> default3;
|
|
|
|
void declareSignature(const char* arg1Name, Variant arg1Default, const char* arg2Name, Variant arg2Default, const char* arg3Name, Variant arg3Default)
|
|
{
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg1, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg2, shared_ptr<const Tuple> >::value));
|
|
this->signature.resultType = &Type::singleton<void>();
|
|
this->signature.addArgument(RBX::Name::declare(arg1Name), Type::singleton<Arg1>(), arg1Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg2Name), Type::singleton<Arg2>(), arg2Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg3Name), Type::singleton<Arg3>(), arg3Default);
|
|
}
|
|
|
|
public:
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, Arg1 default1, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1(new Arg1(default1))
|
|
{
|
|
declareSignature(arg1Name, default1, arg2Name, default2, arg3Name, default3);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, default2, arg3Name, default3);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, Arg3 default3, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default3(new Arg3(default3))
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, default3);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant());
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments, boost::function<void(Variant)> resumeFunction, boost::function<void(std::string)> errorFunction) const
|
|
{
|
|
(boost::polymorphic_downcast<Class*>(instance)->*function)(
|
|
ArgHelper::getArg<Arg1, 1>(arguments, default1),
|
|
ArgHelper::getArg<Arg2, 2>(arguments, default2),
|
|
ArgHelper::getArg<Arg3, 3>(arguments, default3),
|
|
boost::bind(resumeFunction, Variant()), errorFunction);
|
|
}
|
|
};
|
|
|
|
// A simple version of FunctionDescriptor for member functions that take 4 arguments
|
|
template <class Class, typename Signature, typename ReturnType>
|
|
class BoundYieldFuncDesc<Class, Signature, ReturnType, 4> : public YieldFuncDesc<Class>
|
|
{
|
|
typedef typename boost::function_traits<Signature>::arg1_type Arg1;
|
|
typedef typename boost::function_traits<Signature>::arg2_type Arg2;
|
|
typedef typename boost::function_traits<Signature>::arg3_type Arg3;
|
|
typedef typename boost::function_traits<Signature>::arg4_type Arg4;
|
|
typedef void (Class::*YieldFunctionPtr)(Arg1, Arg2, Arg3, Arg4, boost::function<void(ReturnType)> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
YieldFunctionPtr function;
|
|
|
|
const boost::scoped_ptr<Arg1> default1;
|
|
const boost::scoped_ptr<Arg2> default2;
|
|
const boost::scoped_ptr<Arg3> default3;
|
|
const boost::scoped_ptr<Arg4> default4;
|
|
|
|
void declareSignature(const char* arg1Name, Variant arg1Default, const char* arg2Name, Variant arg2Default, const char* arg3Name, Variant arg3Default, const char* arg4Name, Variant arg4Default)
|
|
{
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg1, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg2, shared_ptr<const Tuple> >::value));
|
|
this->signature.resultType = &Type::singleton<ReturnType>();
|
|
this->signature.addArgument(RBX::Name::declare(arg1Name), Type::singleton<Arg1>(), arg1Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg2Name), Type::singleton<Arg2>(), arg2Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg3Name), Type::singleton<Arg3>(), arg3Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg4Name), Type::singleton<Arg4>(), arg4Default);
|
|
}
|
|
|
|
public:
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, Arg1 default1, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1(new Arg1(default1))
|
|
{
|
|
declareSignature(arg1Name, default1, arg2Name, default2, arg3Name, default3, arg4Name, default4);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, default2, arg3Name, default3, arg4Name, default4);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, default3, arg4Name, default4);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, Arg4 default4, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default4(new Arg4(default4))
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, default4);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default4()
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, Variant());
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments, boost::function<void(Variant)> resumeFunction, boost::function<void(std::string)> errorFunction) const
|
|
{
|
|
(boost::polymorphic_downcast<Class*>(instance)->*function)(
|
|
ArgHelper::getArg<Arg1, 1>(arguments, default1),
|
|
ArgHelper::getArg<Arg2, 2>(arguments, default2),
|
|
ArgHelper::getArg<Arg3, 3>(arguments, default3),
|
|
ArgHelper::getArg<Arg4, 4>(arguments, default4),
|
|
boost::bind(&resume_adapter<ReturnType>, resumeFunction, _1), errorFunction);
|
|
}
|
|
};
|
|
|
|
|
|
// void(Arg1, Arg2, Arg3, Arg4) specialization
|
|
template <class Class, typename Signature>
|
|
class BoundYieldFuncDesc<Class, Signature, void, 4> : public YieldFuncDesc<Class>
|
|
{
|
|
typedef typename boost::function_traits<Signature>::arg1_type Arg1;
|
|
typedef typename boost::function_traits<Signature>::arg2_type Arg2;
|
|
typedef typename boost::function_traits<Signature>::arg3_type Arg3;
|
|
typedef typename boost::function_traits<Signature>::arg4_type Arg4;
|
|
typedef void (Class::*YieldFunctionPtr)(Arg1, Arg2, Arg3, Arg4, boost::function<void(void)> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
YieldFunctionPtr function;
|
|
|
|
const boost::scoped_ptr<Arg1> default1;
|
|
const boost::scoped_ptr<Arg2> default2;
|
|
const boost::scoped_ptr<Arg3> default3;
|
|
const boost::scoped_ptr<Arg4> default4;
|
|
|
|
void declareSignature(const char* arg1Name, Variant arg1Default, const char* arg2Name, Variant arg2Default, const char* arg3Name, Variant arg3Default, const char* arg4Name, Variant arg4Default)
|
|
{
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg1, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg2, shared_ptr<const Tuple> >::value));
|
|
this->signature.resultType = &Type::singleton<void>();
|
|
this->signature.addArgument(RBX::Name::declare(arg1Name), Type::singleton<Arg1>(), arg1Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg2Name), Type::singleton<Arg2>(), arg2Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg3Name), Type::singleton<Arg3>(), arg3Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg4Name), Type::singleton<Arg4>(), arg4Default);
|
|
}
|
|
|
|
public:
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, Arg1 default1, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1(new Arg1(default1))
|
|
{
|
|
declareSignature(arg1Name, default1, arg2Name, default2, arg3Name, default3, arg4Name, default4);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, default2, arg3Name, default3, arg4Name, default4);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, default3, arg4Name, default4);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, Arg4 default4, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default4(new Arg4(default4))
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, default4);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default4()
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, Variant());
|
|
}
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments, boost::function<void(Variant)> resumeFunction, boost::function<void(std::string)> errorFunction) const
|
|
{
|
|
(boost::polymorphic_downcast<Class*>(instance)->*function)(
|
|
ArgHelper::getArg<Arg1, 1>(arguments, default1),
|
|
ArgHelper::getArg<Arg2, 2>(arguments, default2),
|
|
ArgHelper::getArg<Arg3, 3>(arguments, default3),
|
|
ArgHelper::getArg<Arg4, 4>(arguments, default4),
|
|
boost::bind(resumeFunction, Variant()), errorFunction);
|
|
}
|
|
};
|
|
|
|
// A simple version of FunctionDescriptor for member functions that take 4 arguments
|
|
template <class Class, typename Signature, typename ReturnType>
|
|
class BoundYieldFuncDesc<Class, Signature, ReturnType, 5> : public YieldFuncDesc<Class>
|
|
{
|
|
typedef typename boost::function_traits<Signature>::arg1_type Arg1;
|
|
typedef typename boost::function_traits<Signature>::arg2_type Arg2;
|
|
typedef typename boost::function_traits<Signature>::arg3_type Arg3;
|
|
typedef typename boost::function_traits<Signature>::arg4_type Arg4;
|
|
typedef typename boost::function_traits<Signature>::arg5_type Arg5;
|
|
typedef void (Class::*YieldFunctionPtr)(Arg1, Arg2, Arg3, Arg4, Arg5, boost::function<void(ReturnType)> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
YieldFunctionPtr function;
|
|
|
|
const boost::scoped_ptr<Arg1> default1;
|
|
const boost::scoped_ptr<Arg2> default2;
|
|
const boost::scoped_ptr<Arg3> default3;
|
|
const boost::scoped_ptr<Arg4> default4;
|
|
const boost::scoped_ptr<Arg5> default5;
|
|
|
|
void declareSignature(const char* arg1Name, Variant arg1Default, const char* arg2Name, Variant arg2Default, const char* arg3Name, Variant arg3Default, const char* arg4Name, Variant arg4Default, const char* arg5Name, Variant arg5Default)
|
|
{
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg1, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg2, shared_ptr<const Tuple> >::value));
|
|
this->signature.resultType = &Type::singleton<ReturnType>();
|
|
this->signature.addArgument(RBX::Name::declare(arg1Name), Type::singleton<Arg1>(), arg1Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg2Name), Type::singleton<Arg2>(), arg2Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg3Name), Type::singleton<Arg3>(), arg3Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg4Name), Type::singleton<Arg4>(), arg4Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg5Name), Type::singleton<Arg5>(), arg5Default);
|
|
}
|
|
|
|
public:
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, Arg1 default1, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg4 default5, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1(new Arg1(default1))
|
|
{
|
|
declareSignature(arg1Name, default1, arg2Name, default2, arg3Name, default3, arg4Name, default4, arg5Name, default5);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg4 default5, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, default2, arg3Name, default3, arg4Name, default4, arg5Name, default5);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg5 default5, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, default3, arg4Name, default4, arg5Name, default5);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg4 default5, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, default4, arg5Name, default5);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, const char* arg5Name, Arg4 default5, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default5(new Arg5(default5))
|
|
,default4()
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, Variant(), arg5Name, default5);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, const char* arg5Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default5()
|
|
,default4()
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, Variant(), arg5Name, Variant());
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments, boost::function<void(Variant)> resumeFunction, boost::function<void(std::string)> errorFunction) const
|
|
{
|
|
(boost::polymorphic_downcast<Class*>(instance)->*function)(
|
|
ArgHelper::getArg<Arg1, 1>(arguments, default1),
|
|
ArgHelper::getArg<Arg2, 2>(arguments, default2),
|
|
ArgHelper::getArg<Arg3, 3>(arguments, default3),
|
|
ArgHelper::getArg<Arg4, 4>(arguments, default4),
|
|
ArgHelper::getArg<Arg5, 5>(arguments, default5),
|
|
boost::bind(&resume_adapter<ReturnType>, resumeFunction, _1), errorFunction);
|
|
}
|
|
};
|
|
|
|
|
|
// void(Arg1, Arg2, Arg3, Arg4, Arg5) specialization
|
|
template <class Class, typename Signature>
|
|
class BoundYieldFuncDesc<Class, Signature, void, 5> : public YieldFuncDesc<Class>
|
|
{
|
|
typedef typename boost::function_traits<Signature>::arg1_type Arg1;
|
|
typedef typename boost::function_traits<Signature>::arg2_type Arg2;
|
|
typedef typename boost::function_traits<Signature>::arg3_type Arg3;
|
|
typedef typename boost::function_traits<Signature>::arg4_type Arg4;
|
|
typedef typename boost::function_traits<Signature>::arg5_type Arg5;
|
|
typedef void (Class::*YieldFunctionPtr)(Arg1, Arg2, Arg3, Arg4, Arg5, boost::function<void(void)> resumeFunction, boost::function<void(std::string)> errorFunction);
|
|
YieldFunctionPtr function;
|
|
|
|
const boost::scoped_ptr<Arg1> default1;
|
|
const boost::scoped_ptr<Arg2> default2;
|
|
const boost::scoped_ptr<Arg3> default3;
|
|
const boost::scoped_ptr<Arg4> default4;
|
|
const boost::scoped_ptr<Arg5> default5;
|
|
|
|
void declareSignature(const char* arg1Name, Variant arg1Default, const char* arg2Name, Variant arg2Default, const char* arg3Name, Variant arg3Default, const char* arg4Name, Variant arg4Default, const char* arg5Name, Variant arg5Default)
|
|
{
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg1, shared_ptr<const Tuple> >::value));
|
|
BOOST_STATIC_ASSERT((!boost::is_same<Arg2, shared_ptr<const Tuple> >::value));
|
|
this->signature.resultType = &Type::singleton<void>();
|
|
this->signature.addArgument(RBX::Name::declare(arg1Name), Type::singleton<Arg1>(), arg1Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg2Name), Type::singleton<Arg2>(), arg2Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg3Name), Type::singleton<Arg3>(), arg3Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg4Name), Type::singleton<Arg4>(), arg4Default);
|
|
this->signature.addArgument(RBX::Name::declare(arg5Name), Type::singleton<Arg5>(), arg5Default);
|
|
}
|
|
|
|
public:
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, Arg1 default1, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg4 default5, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1(new Arg1(default1))
|
|
{
|
|
declareSignature(arg1Name, default1, arg2Name, default2, arg3Name, default3, arg4Name, default4, arg5Name, default5);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, Arg2 default2, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg4 default5, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2(new Arg2(default2))
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, default2, arg3Name, default3, arg4Name, default4, arg5Name, default5);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, Arg3 default3, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg5 default5, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3(new Arg3(default3))
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, default3, arg4Name, default4, arg5Name, default5);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, Arg4 default4, const char* arg5Name, Arg4 default5, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default5(new Arg5(default5))
|
|
,default4(new Arg4(default4))
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, default4, arg5Name, default5);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, const char* arg5Name, Arg4 default5, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default5(new Arg5(default5))
|
|
,default4()
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, Variant(), arg5Name, default5);
|
|
}
|
|
|
|
BoundYieldFuncDesc(YieldFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, const char* arg5Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
:YieldFuncDesc<Class>(name, security, attributes)
|
|
,function(function)
|
|
,default5()
|
|
,default4()
|
|
,default3()
|
|
,default2()
|
|
,default1()
|
|
{
|
|
declareSignature(arg1Name, Variant(), arg2Name, Variant(), arg3Name, Variant(), arg4Name, Variant(), arg5Name, Variant());
|
|
}
|
|
|
|
/*implement*/ void execute(Reflection::DescribedBase* instance, FunctionDescriptor::Arguments& arguments, boost::function<void(Variant)> resumeFunction, boost::function<void(std::string)> errorFunction) const
|
|
{
|
|
(boost::polymorphic_downcast<Class*>(instance)->*function)(
|
|
ArgHelper::getArg<Arg1, 1>(arguments, default1),
|
|
ArgHelper::getArg<Arg2, 2>(arguments, default2),
|
|
ArgHelper::getArg<Arg3, 3>(arguments, default3),
|
|
ArgHelper::getArg<Arg4, 4>(arguments, default4),
|
|
ArgHelper::getArg<Arg5, 5>(arguments, default5),
|
|
boost::bind(resumeFunction, Variant()), errorFunction);
|
|
}
|
|
};
|
|
|
|
template <class Class, typename Signature, int arity = boost::function_traits<Signature>::arity >
|
|
class CustomBoundFuncDesc;
|
|
|
|
template <class Class, typename Signature>
|
|
class CustomBoundFuncDesc<Class, Signature, 0> : public BoundFuncDesc<Class, Signature, 0>
|
|
{
|
|
typedef int (Class::*CustomFunctionPtr)(lua_State*);
|
|
CustomFunctionPtr customFunction;
|
|
|
|
public:
|
|
CustomBoundFuncDesc(CustomFunctionPtr function, const char* name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
: BoundFuncDesc<Class, Signature, 0>(NULL, name, security, attributes)
|
|
, customFunction(function)
|
|
{
|
|
this->kind = FunctionDescriptor::Kind_Custom;
|
|
}
|
|
|
|
/*implement*/ int executeCustom(DescribedBase* instance, lua_State* state) const
|
|
{
|
|
return (boost::polymorphic_downcast<Class*>(instance)->*customFunction)(state);
|
|
}
|
|
};
|
|
|
|
template <class Class, typename Signature>
|
|
class CustomBoundFuncDesc<Class, Signature, 1> : public BoundFuncDesc<Class, Signature, 1>
|
|
{
|
|
typedef int (Class::*CustomFunctionPtr)(lua_State*);
|
|
CustomFunctionPtr customFunction;
|
|
|
|
public:
|
|
CustomBoundFuncDesc(CustomFunctionPtr function, const char* name, const char* arg1Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
: BoundFuncDesc<Class, Signature, 1>(NULL, name, arg1Name, security, attributes)
|
|
, customFunction(function)
|
|
{
|
|
this->kind = FunctionDescriptor::Kind_Custom;
|
|
}
|
|
|
|
/*implement*/ int executeCustom(DescribedBase* instance, lua_State* state) const
|
|
{
|
|
return (boost::polymorphic_downcast<Class*>(instance)->*customFunction)(state);
|
|
}
|
|
};
|
|
|
|
template <class Class, typename Signature>
|
|
class CustomBoundFuncDesc<Class, Signature, 2> : public BoundFuncDesc<Class, Signature, 2>
|
|
{
|
|
typedef int (Class::*CustomFunctionPtr)(lua_State*);
|
|
CustomFunctionPtr customFunction;
|
|
|
|
public:
|
|
CustomBoundFuncDesc(CustomFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
: BoundFuncDesc<Class, Signature, 2>(NULL, name, arg1Name, arg2Name, security, attributes)
|
|
, customFunction(function)
|
|
{
|
|
this->kind = FunctionDescriptor::Kind_Custom;
|
|
}
|
|
|
|
/*implement*/ int executeCustom(DescribedBase* instance, lua_State* state) const
|
|
{
|
|
return (boost::polymorphic_downcast<Class*>(instance)->*customFunction)(state);
|
|
}
|
|
};
|
|
|
|
template <class Class, typename Signature>
|
|
class CustomBoundFuncDesc<Class, Signature, 3> : public BoundFuncDesc<Class, Signature, 3>
|
|
{
|
|
typedef int (Class::*CustomFunctionPtr)(lua_State*);
|
|
CustomFunctionPtr customFunction;
|
|
|
|
public:
|
|
CustomBoundFuncDesc(CustomFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
: BoundFuncDesc<Class, Signature, 3>(NULL, name, arg1Name, arg2Name, arg3Name, security, attributes)
|
|
, customFunction(function)
|
|
{
|
|
this->kind = FunctionDescriptor::Kind_Custom;
|
|
}
|
|
|
|
/*implement*/ int executeCustom(DescribedBase* instance, lua_State* state) const
|
|
{
|
|
return (boost::polymorphic_downcast<Class*>(instance)->*customFunction)(state);
|
|
}
|
|
};
|
|
|
|
template <class Class, typename Signature>
|
|
class CustomBoundFuncDesc<Class, Signature, 4> : public BoundFuncDesc<Class, Signature, 4>
|
|
{
|
|
typedef int (Class::*CustomFunctionPtr)(lua_State*);
|
|
CustomFunctionPtr customFunction;
|
|
|
|
public:
|
|
CustomBoundFuncDesc(CustomFunctionPtr function, const char* name, const char* arg1Name, const char* arg2Name, const char* arg3Name, const char* arg4Name, Security::Permissions security, Descriptor::Attributes attributes = Descriptor::Attributes())
|
|
: BoundFuncDesc<Class, Signature, 4>(NULL, name, arg1Name, arg2Name, arg3Name, arg4Name, security, attributes)
|
|
, customFunction(function)
|
|
{
|
|
this->kind = FunctionDescriptor::Kind_Custom;
|
|
}
|
|
|
|
/*implement*/ int executeCustom(DescribedBase* instance, lua_State* state) const
|
|
{
|
|
return (boost::polymorphic_downcast<Class*>(instance)->*customFunction)(state);
|
|
}
|
|
};
|
|
|
|
}
|
|
}
|
|
|