From 5f75f765f0629873b81cee801f95b191d272049b Mon Sep 17 00:00:00 2001 From: Robert Osfield Date: Mon, 4 Apr 2005 13:50:07 +0000 Subject: [PATCH] From Marco Jez, updates to osgIntrospection. --- .../osgIntrospection/osgIntrospection.dsp | 41 + include/osgIntrospection/Attributes | 47 +- include/osgIntrospection/Comparator | 48 + include/osgIntrospection/ConstructorInfo | 49 + include/osgIntrospection/Exceptions | 34 + include/osgIntrospection/InstanceCreator | 335 + include/osgIntrospection/MethodInfo | 50 +- include/osgIntrospection/ParameterInfo | 31 +- include/osgIntrospection/PropertyInfo | 48 +- include/osgIntrospection/ReaderWriter | 4 +- include/osgIntrospection/Reflection | 3 +- include/osgIntrospection/ReflectionMacros | 1492 ++++- include/osgIntrospection/Reflector | 451 +- include/osgIntrospection/StaticMethodInfo | 1209 ++++ include/osgIntrospection/Type | 124 +- include/osgIntrospection/TypeNameAliasProxy | 26 + include/osgIntrospection/TypedConstructorInfo | 454 ++ include/osgIntrospection/TypedMethodInfo | 5672 +++++++++-------- include/osgIntrospection/Utility | 37 + include/osgIntrospection/Value | 67 +- include/osgIntrospection/variant_cast | 21 + src/osgIntrospection/ConstructorInfo.cpp | 15 + src/osgIntrospection/DefaultReflectors.cpp | 31 +- src/osgIntrospection/GNUmakefile | 2 + src/osgIntrospection/MethodInfo.cpp | 45 + src/osgIntrospection/PropertyInfo.cpp | 80 + src/osgIntrospection/Reflection.cpp | 24 +- src/osgIntrospection/Type.cpp | 176 +- src/osgIntrospection/Utility.cpp | 71 + src/osgIntrospection/Value.cpp | 117 +- 30 files changed, 7591 insertions(+), 3213 deletions(-) create mode 100644 include/osgIntrospection/Comparator create mode 100644 include/osgIntrospection/ConstructorInfo create mode 100644 include/osgIntrospection/InstanceCreator create mode 100644 include/osgIntrospection/StaticMethodInfo create mode 100644 include/osgIntrospection/TypeNameAliasProxy create mode 100644 include/osgIntrospection/TypedConstructorInfo create mode 100644 include/osgIntrospection/Utility create mode 100644 src/osgIntrospection/ConstructorInfo.cpp create mode 100644 src/osgIntrospection/Utility.cpp diff --git a/VisualStudio/osgIntrospection/osgIntrospection.dsp b/VisualStudio/osgIntrospection/osgIntrospection.dsp index f13cd62ce..f398e7fa8 100644 --- a/VisualStudio/osgIntrospection/osgIntrospection.dsp +++ b/VisualStudio/osgIntrospection/osgIntrospection.dsp @@ -95,6 +95,10 @@ LINK32=link.exe # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # Begin Source File +SOURCE=..\..\src\osgIntrospection\ConstructorInfo.cpp +# End Source File +# Begin Source File + SOURCE=..\..\src\osgIntrospection\CustomAttributeProvider.cpp # End Source File # Begin Source File @@ -119,6 +123,10 @@ SOURCE=..\..\src\osgIntrospection\Type.cpp # End Source File # Begin Source File +SOURCE=..\..\src\osgIntrospection\Utility.cpp +# End Source File +# Begin Source File + SOURCE=..\..\src\osgIntrospection\Value.cpp # End Source File # End Group @@ -131,6 +139,14 @@ SOURCE=..\..\include\osgIntrospection\Attributes # End Source File # Begin Source File +SOURCE=..\..\include\osgIntrospection\Comparator +# End Source File +# Begin Source File + +SOURCE=..\..\include\osgIntrospection\ConstructorInfo +# End Source File +# Begin Source File + SOURCE=..\..\include\osgIntrospection\CustomAttribute # End Source File # Begin Source File @@ -143,6 +159,14 @@ SOURCE=..\..\include\osgIntrospection\Exceptions # End Source File # Begin Source File +SOURCE=..\..\include\osgIntrospection\Export +# End Source File +# Begin Source File + +SOURCE=..\..\include\osgIntrospection\InstanceCreator +# End Source File +# Begin Source File + SOURCE=..\..\include\osgIntrospection\MethodInfo # End Source File # Begin Source File @@ -171,14 +195,30 @@ SOURCE=..\..\include\osgIntrospection\Reflector # End Source File # Begin Source File +SOURCE=..\..\include\osgIntrospection\StaticMethodInfo +# End Source File +# Begin Source File + SOURCE=..\..\include\osgIntrospection\Type # End Source File # Begin Source File +SOURCE=..\..\include\osgIntrospection\TypedConstructorInfo +# End Source File +# Begin Source File + SOURCE=..\..\include\osgIntrospection\TypedMethodInfo # End Source File # Begin Source File +SOURCE=..\..\include\osgIntrospection\TypeNameAliasProxy +# End Source File +# Begin Source File + +SOURCE=..\..\include\osgIntrospection\Utility +# End Source File +# Begin Source File + SOURCE=..\..\include\osgIntrospection\Value # End Source File # Begin Source File @@ -192,3 +232,4 @@ SOURCE=..\..\include\osgIntrospection\variant_cast # End Group # End Target # End Project + diff --git a/include/osgIntrospection/Attributes b/include/osgIntrospection/Attributes index 390b6cd47..a2fac20ba 100644 --- a/include/osgIntrospection/Attributes +++ b/include/osgIntrospection/Attributes @@ -4,6 +4,7 @@ #include #include #include +#include namespace osgIntrospection { @@ -31,9 +32,12 @@ namespace osgIntrospection /// last one is used with array properties. struct PropertyGetter { - virtual Value get(const Value &instance, const ValueList &indices) const { throw PropertyAccessException("[n/a inside a custom accessor]", PropertyAccessException::IGET); } - virtual Value get(const Value &instance) const { throw PropertyAccessException("[n/a inside a custom accessor]", PropertyAccessException::GET); } - virtual Value get(const Value &instance, int i) const { throw PropertyAccessException("[n/a inside a custom accessor]", PropertyAccessException::AGET); } + virtual Value get(Value & /*instance*/, const ValueList & /*indices*/) const { throw PropertyAccessException("[n/a inside a custom accessor]", PropertyAccessException::IGET); } + virtual Value get(Value & /*instance*/) const { throw PropertyAccessException("[n/a inside a custom accessor]", PropertyAccessException::GET); } + virtual Value get(Value & /*instance*/, int /*i*/) const { throw PropertyAccessException("[n/a inside a custom accessor]", PropertyAccessException::AGET); } + virtual Value get(const Value & /*instance*/, const ValueList & /*indices*/) const { throw PropertyAccessException("[n/a inside a custom accessor]", PropertyAccessException::IGET); } + virtual Value get(const Value & /*instance*/) const { throw PropertyAccessException("[n/a inside a custom accessor]", PropertyAccessException::GET); } + virtual Value get(const Value & /*instance*/, int /*i*/) const { throw PropertyAccessException("[n/a inside a custom accessor]", PropertyAccessException::AGET); } virtual ~PropertyGetter() {} }; @@ -64,9 +68,9 @@ namespace osgIntrospection /// last one is used with array properties. struct PropertySetter { - virtual void set(Value &instance, ValueList &indices, const Value &value) const { throw PropertyAccessException("[n/a inside a custom accessor]", PropertyAccessException::ISET); } - virtual void set(Value &instance, const Value &value) const { throw PropertyAccessException("[n/a inside a custom accessor]", PropertyAccessException::SET); } - virtual void set(Value &instance, int i, const Value &value) const { throw PropertyAccessException("[n/a inside a custom accessor]", PropertyAccessException::ASET); } + virtual void set(Value & /*instance*/, ValueList & /*indices*/, const Value & /*value*/) const { throw PropertyAccessException("[n/a inside a custom accessor]", PropertyAccessException::ISET); } + virtual void set(Value & /*instance*/, const Value & /*value*/) const { throw PropertyAccessException("[n/a inside a custom accessor]", PropertyAccessException::SET); } + virtual void set(Value & /*instance*/, int /*i*/, const Value & /*value*/) const { throw PropertyAccessException("[n/a inside a custom accessor]", PropertyAccessException::ASET); } virtual ~PropertySetter() {} }; @@ -95,7 +99,7 @@ namespace osgIntrospection /// in a chosen array property for the given instance. struct PropertyCounter { - virtual int count(const Value &instance) const { throw PropertyAccessException("[n/a inside a custom accessor]", PropertyAccessException::COUNT); } + virtual int count(const Value & /*instance*/) const { throw PropertyAccessException("[n/a inside a custom accessor]", PropertyAccessException::COUNT); } virtual ~PropertyCounter() {} }; @@ -145,6 +149,35 @@ namespace osgIntrospection private: const PropertyAdder *adder_; }; + + + /// Base struct for custom array property removers. Descendants should + /// override the remove() method whose purpose is to remove an item from + /// an array property. + struct PropertyRemover + { + virtual void remove(Value&, int) const { throw PropertyAccessException("[n/a inside a custom accessor]", PropertyAccessException::REMOVE); } + virtual ~PropertyRemover() {} + }; + + /// By setting an attribute of this class you can specify a custom object + /// that will be used to remove an item from an array property. + class CustomPropertyRemoveAttribute: public CustomAttribute + { + public: + CustomPropertyRemoveAttribute(const PropertyRemover *remover) + : CustomAttribute(), remover_(remover) {} + + const PropertyRemover *getRemover() const { return remover_; } + + ~CustomPropertyRemoveAttribute() + { + delete remover_; + } + + private: + const PropertyRemover *remover_; + }; /// This struct allows customization of an indexed property's index set. diff --git a/include/osgIntrospection/Comparator b/include/osgIntrospection/Comparator new file mode 100644 index 000000000..1b8f1c58c --- /dev/null +++ b/include/osgIntrospection/Comparator @@ -0,0 +1,48 @@ +#ifndef OSGINTROSPECTION_COMPARATOR_ +#define OSGINTROSPECTION_COMPARATOR_ + + +namespace osgIntrospection +{ + + class Value; + + struct Comparator + { + virtual bool isEqualTo(const Value &l, const Value &r) const = 0; + virtual bool isLessThanOrEqualTo(const Value &l, const Value &r) const = 0; + }; + + template + struct TotalOrderComparator: Comparator + { + virtual bool isEqualTo(const Value &l, const Value &r) const + { + const T &vl = variant_cast(l); + const T &vr = variant_cast(r); + return vl <= vr && vr <= vl; + } + + virtual bool isLessThanOrEqualTo(const Value &l, const Value &r) const + { + return variant_cast(l) <= variant_cast(r); + } + }; + + template + struct PartialOrderComparator: Comparator + { + virtual bool isEqualTo(const Value &l, const Value &r) const + { + return variant_cast(l) == variant_cast(r); + } + + virtual bool isLessThanOrEqualTo(const Value &, const Value &) const + { + throw ComparisonOperatorNotSupportedException(typeid(T), "less than or equal to"); + } + }; + +} + +#endif diff --git a/include/osgIntrospection/ConstructorInfo b/include/osgIntrospection/ConstructorInfo new file mode 100644 index 000000000..d242085fd --- /dev/null +++ b/include/osgIntrospection/ConstructorInfo @@ -0,0 +1,49 @@ +#ifndef OSGINTROSPECTION_CONSTRUCTORINFO_ +#define OSGINTROSPECTION_CONSTRUCTORINFO_ + +#include +#include +#include +#include + +namespace osgIntrospection +{ + + class OSGINTROSPECTION_EXPORT ConstructorInfo: public CustomAttributeProvider + { + public: + ConstructorInfo(const Type &decltype, const ParameterInfoList ¶ms) + : decltype_(decltype), + params_(params) + { + } + + virtual ~ConstructorInfo() + { + for (ParameterInfoList::iterator i=params_.begin(); i!=params_.end(); ++i) + delete *i; + } + + inline const Type &getDeclaringType() const + { + return decltype_; + } + + inline const ParameterInfoList &getParameters() const + { + return params_; + } + + virtual Value createInstance(ValueList &args) const = 0; + + protected: + virtual void getInheritedProviders(CustomAttributeProviderList &providers) const; + + private: + const Type &decltype_; + ParameterInfoList params_; + }; + +} + +#endif diff --git a/include/osgIntrospection/Exceptions b/include/osgIntrospection/Exceptions index 6261bb812..ab04dbddd 100644 --- a/include/osgIntrospection/Exceptions +++ b/include/osgIntrospection/Exceptions @@ -37,6 +37,22 @@ namespace osgIntrospection { } }; + + struct ConstructorNotFoundException: public ReflectionException + { + ConstructorNotFoundException(const std::type_info &ti) + : ReflectionException("could not find a suitable constructor in type `" + std::string(ti.name()) + "'") + { + } + }; + + struct InvokeNotImplementedException: public ReflectionException + { + InvokeNotImplementedException() + : ReflectionException("invoke() not implemented") + { + } + }; struct InvalidFunctionPointerException: public ReflectionException { @@ -148,6 +164,7 @@ namespace osgIntrospection AGET, ASET, ADD, + REMOVE, COUNT }; @@ -169,6 +186,7 @@ namespace osgIntrospection case AGET: msg = "retrieved with array index"; break; case ASET: msg = "set with array index"; break; case ADD: msg = "added"; break; + case REMOVE: msg = "removed"; break; case COUNT: msg = "counted"; break; default: msg = "?"; } @@ -183,6 +201,22 @@ namespace osgIntrospection { } }; + + struct ComparisonNotPermittedException: ReflectionException + { + ComparisonNotPermittedException(const std::type_info &ti) + : ReflectionException("comparison not permitted on type `" + std::string(ti.name()) + "'") + { + } + }; + + struct ComparisonOperatorNotSupportedException: ReflectionException + { + ComparisonOperatorNotSupportedException(const std::type_info &ti, const std::string &op) + : ReflectionException("comparison operator `" + op + "' is not supported on type `" + std::string(ti.name()) + "'") + { + } + }; } diff --git a/include/osgIntrospection/InstanceCreator b/include/osgIntrospection/InstanceCreator new file mode 100644 index 000000000..e52bf28e3 --- /dev/null +++ b/include/osgIntrospection/InstanceCreator @@ -0,0 +1,335 @@ +#ifndef OSGINTROSPECTION_INSTANCECREATOR_ +#define OSGINTROSPECTION_INSTANCECREATOR_ + +#include +#include + +namespace osgIntrospection +{ + + /// The ObjectInstanceCreator struct template is a collection of + /// static methods that provide the means for creating instances + /// of object types dynamically. Such methods are usually called + /// from within TypedConstructorInfo{n}::createInstance(). + template + struct ObjectInstanceCreator + { + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6, Value &a7, Value &a8, Value &a9, Value &a10, Value &a11, Value &a12, Value &a13, Value &a14, Value &a15) + { + return new T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6, Value &a7, Value &a8, Value &a9, Value &a10, Value &a11, Value &a12, Value &a13, Value &a14) + { + return new T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6, Value &a7, Value &a8, Value &a9, Value &a10, Value &a11, Value &a12, Value &a13) + { + return new T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6, Value &a7, Value &a8, Value &a9, Value &a10, Value &a11, Value &a12) + { + return new T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6, Value &a7, Value &a8, Value &a9, Value &a10, Value &a11) + { + return new T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6, Value &a7, Value &a8, Value &a9, Value &a10) + { + return new T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6, Value &a7, Value &a8, Value &a9) + { + return new T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6, Value &a7, Value &a8) + { + return new T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6, Value &a7) + { + return new T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6) + { + return new T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5) + { + return new T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4) + { + return new T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3) + { + return new T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2) + { + return new T(variant_cast(a0), variant_cast(a1), variant_cast(a2)); + } + + template + static Value create(Value &a0, Value &a1) + { + return new T(variant_cast(a0), variant_cast(a1)); + } + + template + static Value create(Value &a0) + { + return new T(variant_cast(a0)); + } + + static Value create() + { + return new T(); + } + + }; + + template + struct ValueInstanceCreator + { + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6, Value &a7, Value &a8, Value &a9, Value &a10, Value &a11, Value &a12, Value &a13, Value &a14, Value &a15) + { + return T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6, Value &a7, Value &a8, Value &a9, Value &a10, Value &a11, Value &a12, Value &a13, Value &a14) + { + return T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6, Value &a7, Value &a8, Value &a9, Value &a10, Value &a11, Value &a12, Value &a13) + { + return T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6, Value &a7, Value &a8, Value &a9, Value &a10, Value &a11, Value &a12) + { + return T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6, Value &a7, Value &a8, Value &a9, Value &a10, Value &a11) + { + return T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6, Value &a7, Value &a8, Value &a9, Value &a10) + { + return T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6, Value &a7, Value &a8, Value &a9) + { + return T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6, Value &a7, Value &a8) + { + return T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6, Value &a7) + { + return T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5, Value &a6) + { + return T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4, Value &a5) + { + return T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3, Value &a4) + { + return T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2, Value &a3) + { + return T(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)); + } + + template + static Value create(Value &a0, Value &a1, Value &a2) + { + return T(variant_cast(a0), variant_cast(a1), variant_cast(a2)); + } + + template + static Value create(Value &a0, Value &a1) + { + return T(variant_cast(a0), variant_cast(a1)); + } + + template + static Value create(Value &a0) + { + return T(variant_cast(a0)); + } + + static Value create() + { + return T(); + } + + }; + + template + struct DummyInstanceCreator + { + template + static Value create(Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &) + { + return Value(); + } + + template + static Value create(Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &) + { + return Value(); + } + + template + static Value create(Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &) + { + return Value(); + } + + template + static Value create(Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &) + { + return Value(); + } + + template + static Value create(Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &) + { + return Value(); + } + + template + static Value create(Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &) + { + return Value(); + } + + template + static Value create(Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &) + { + return Value(); + } + + template + static Value create(Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &) + { + return Value(); + } + + template + static Value create(Value &, Value &, Value &, Value &, Value &, Value &, Value &, Value &) + { + return Value(); + } + + template + static Value create(Value &, Value &, Value &, Value &, Value &, Value &, Value &) + { + return Value(); + } + + template + static Value create(Value &, Value &, Value &, Value &, Value &, Value &) + { + return Value(); + } + + template + static Value create(Value &, Value &, Value &, Value &, Value &) + { + return Value(); + } + + template + static Value create(Value &, Value &, Value &, Value &) + { + return Value(); + } + + template + static Value create(Value &, Value &, Value &) + { + return Value(); + } + + template + static Value create(Value &, Value &) + { + return Value(); + } + + template + static Value create(Value &) + { + return Value(); + } + + static Value create() + { + return Value(); + } + + }; + + +} + +#endif diff --git a/include/osgIntrospection/MethodInfo b/include/osgIntrospection/MethodInfo index e2ba50a09..39e5e22a7 100644 --- a/include/osgIntrospection/MethodInfo +++ b/include/osgIntrospection/MethodInfo @@ -25,6 +25,9 @@ namespace osgIntrospection public: /// Direct initialization constructor. inline MethodInfo(const std::string &qname, const Type &decltype, const Type &rtype, const ParameterInfoList &plist); + + /// Destructor + inline ~MethodInfo(); /// Returns the Type object associated to the type that /// declares the reflected method. @@ -42,14 +45,25 @@ namespace osgIntrospection /// Returns whether the reflected method is const or not. virtual bool isConst() const = 0; + + /// Returns whether the reflected method is static or not. + virtual bool isStatic() const = 0; + + /// Returns whether this method would override the given + /// method. + bool overrides(const MethodInfo *other) const; /// Invokes the reflected method dynamically on the given const /// instance, passing it the arguments as a list of Value objects. - virtual Value invoke(const Value &instance, ValueList &args) const = 0; + inline virtual Value invoke(const Value &instance, ValueList &args) const; /// Invokes the reflected method dynamically on the given instance, /// passing it the arguments as a list of Value objects. - virtual Value invoke(Value &instance, ValueList &args) const = 0; + inline virtual Value invoke(Value &instance, ValueList &args) const; + + /// Invokes the reflected static method dynamically passing it the + /// arguments as a list of Value objects. + inline virtual Value invoke(ValueList &args) const; /// Invokes the reflected method dynamically on the given const /// instance, without arguments. @@ -58,6 +72,9 @@ namespace osgIntrospection /// Invokes the reflected method dynamically on the given /// instance, without arguments. inline Value invoke(Value &instance) const; + + /// Invokes the reflected static method without arguments. + inline Value invoke() const; private: inline std::string strip_namespace(const std::string &s) const; @@ -73,7 +90,7 @@ namespace osgIntrospection // INLINE METHODS inline MethodInfo::MethodInfo(const std::string &qname, const Type &decltype, const Type &rtype, const ParameterInfoList &plist) - : CustomAttributeProvider(), + : CustomAttributeProvider(), decltype_(decltype), rtype_(rtype), params_(plist) @@ -109,6 +126,21 @@ namespace osgIntrospection return params_; } + inline Value MethodInfo::invoke(const Value &, ValueList &) const + { + throw InvokeNotImplementedException(); + } + + inline Value MethodInfo::invoke(Value &, ValueList &) const + { + throw InvokeNotImplementedException(); + } + + inline Value MethodInfo::invoke(ValueList &) const + { + throw InvokeNotImplementedException(); + } + inline Value MethodInfo::invoke(const Value &instance) const { ValueList args; @@ -120,6 +152,18 @@ namespace osgIntrospection ValueList args; return invoke(instance, args); } + + inline Value MethodInfo::invoke() const + { + ValueList args; + return invoke(args); + } + + inline MethodInfo::~MethodInfo() + { + for (ParameterInfoList::iterator i=params_.begin(); i!=params_.end(); ++i) + delete *i; + } } diff --git a/include/osgIntrospection/ParameterInfo b/include/osgIntrospection/ParameterInfo index 425d6ab48..a4881ea93 100644 --- a/include/osgIntrospection/ParameterInfo +++ b/include/osgIntrospection/ParameterInfo @@ -22,27 +22,26 @@ namespace osgIntrospection { NONE = 0, - IN = 1, // parameter is used to pass data to the function + IN = 1, // parameter is used to pass data to the function OUT = 2, // parameter is used to return data from the function INOUT = IN | OUT }; /// Direct initialization constructor. - inline ParameterInfo(const std::string &name, const Type &type, int position, int attribs); + inline ParameterInfo(const std::string &name, const Type &type, int attribs, const Value &defval = Value()); /// Returns the parameter's name. inline const std::string &getName() const; - /// Return the parameter's position within the function's parameter - /// list. This position is zero-based. - inline int getPosition() const; - /// Returns the parameter's type. inline const Type &getParameterType() const; /// Returns the parameter's attributes. inline int getAttributes() const; + + /// Returns the default value. + inline const Value &getDefaultValue() const; /// Returns whether the parameter has the IN attribute. inline bool isIn() const { return (attribs_ & IN) != 0; } @@ -57,17 +56,17 @@ namespace osgIntrospection private: std::string name_; const Type &type_; - int position_; int attribs_; + Value default_; }; // INLINE METHODS - inline ParameterInfo::ParameterInfo(const std::string &name, const Type &type, int position, int attribs) - : name_(name), + inline ParameterInfo::ParameterInfo(const std::string &name, const Type &type, int attribs, const Value &defval) + : name_(name), type_(type), - position_(position), - attribs_(attribs) + attribs_(attribs), + default_(defval) { } @@ -76,11 +75,6 @@ namespace osgIntrospection return name_; } - inline int ParameterInfo::getPosition() const - { - return position_; - } - inline const Type &ParameterInfo::getParameterType() const { return type_; @@ -90,6 +84,11 @@ namespace osgIntrospection { return attribs_; } + + inline const Value &ParameterInfo::getDefaultValue() const + { + return default_; + } } diff --git a/include/osgIntrospection/PropertyInfo b/include/osgIntrospection/PropertyInfo index eaa78954f..da9ba5824 100644 --- a/include/osgIntrospection/PropertyInfo +++ b/include/osgIntrospection/PropertyInfo @@ -47,7 +47,7 @@ namespace osgIntrospection /// to be indexed. The same is true if the getter is null and the /// setter has more than one parameter. PropertyInfo(const Type &decltype, const Type &ptype, const std::string &name, const MethodInfo *getm, const MethodInfo *setm) - : CustomAttributeProvider(), + : CustomAttributeProvider(), decltype_(decltype), ptype_(ptype), name_(name), @@ -55,6 +55,7 @@ namespace osgIntrospection setm_(setm), numm_(0), addm_(0), + remm_(0), is_array_(false) { if (getm_) @@ -76,9 +77,9 @@ namespace osgIntrospection /// You must pass the Type object associated to the type that /// declares the property, the Type object that describes the /// type of the property's value, the property name and the - /// getter/setter/counter/adder methods. - PropertyInfo(const Type &decltype, const Type &ptype, const std::string &name, const MethodInfo *getm, const MethodInfo *setm, const MethodInfo *numm, const MethodInfo *addm) - : CustomAttributeProvider(), + /// getter/setter/counter/adder/remover methods. + PropertyInfo(const Type &decltype, const Type &ptype, const std::string &name, const MethodInfo *getm, const MethodInfo *setm, const MethodInfo *numm, const MethodInfo *addm, const MethodInfo *remm) + : CustomAttributeProvider(), decltype_(decltype), ptype_(ptype), name_(name), @@ -86,6 +87,7 @@ namespace osgIntrospection setm_(setm), numm_(numm), addm_(addm), + remm_(remm), is_array_(true) { } @@ -139,6 +141,12 @@ namespace osgIntrospection { return addm_; } + + /// Returns the remover method. + inline const MethodInfo *getRemoveMethod() const + { + return remm_; + } /// Returns whether the property's value can be retrieved. inline bool canGet() const @@ -163,6 +171,13 @@ namespace osgIntrospection { return addm_ != 0 || isDefined(false); } + + /// Returns whether items can be removed from the array property. + inline bool canRemove() const + { + return remm_ != 0 || isDefined(false); + } + /// Returns whether the property is simple. inline bool isSimple() const @@ -195,16 +210,26 @@ namespace osgIntrospection /// values will be returned. void getIndexValueSet(int whichindex, const Value &instance, ValueList &values) const; - /// Invokes the getter method on the given instance and + /// Invokes the getter method on the given const instance and /// returns the property's value. If a custom getter attribute /// is defined, it will be invoked instead. Value getValue(const Value &instance) const; + /// Invokes the getter method on the given instance and + /// returns the property's value. If a custom getter attribute + /// is defined, it will be invoked instead. + Value getValue(Value &instance) const; + /// Invokes the setter method on the given instance and /// sets the property's value. If a custom setter attribute /// is defined, it will be invoked instead. void setValue(Value &instance, const Value &value) const; + /// Invokes the getter method on the given const instance passing a + /// list of indices and returns the indexed property's value. If a + /// custom getter attribute is defined, it will be invoked instead. + Value getIndexedValue(Value &instance, ValueList &indices) const; + /// Invokes the getter method on the given instance passing a list /// of indices and returns the indexed property's value. If a custom /// getter attribute is defined, it will be invoked instead. @@ -220,11 +245,16 @@ namespace osgIntrospection /// attribute is defined, it will be invoked instead. int getNumArrayItems(const Value &instance) const; - /// Invokes the getter method on the given instance and returns + /// Invokes the getter method on the given const instance and returns /// the i-th item of the array property. If a custom getter attribute /// us defined, it will be invoked instead. Value getArrayItem(const Value &instance, int i) const; + /// Invokes the getter method on the given instance and returns + /// the i-th item of the array property. If a custom getter attribute + /// us defined, it will be invoked instead. + Value getArrayItem(Value &instance, int i) const; + /// Invokes the setter method on the given instance and sets /// the i-th item of the array property. If a custom setter attribute /// is defined, it will be invoked instead. @@ -234,6 +264,11 @@ namespace osgIntrospection /// an item to the array property. If a custom adder attribute is /// defined, it will be invoked instead. void addArrayItem(Value &instance, const Value &value) const; + + /// Invokes the remover method on the given instance and removes + /// an item from the array property. If a custom remover attribute + /// is defined, it will be invoked instead. + void removeArrayItem(Value &instance, int i) const; /// Returns the default value associated to the reflected property. /// If no default value has been specified, this method tries to @@ -253,6 +288,7 @@ namespace osgIntrospection const MethodInfo *setm_; const MethodInfo *numm_; const MethodInfo *addm_; + const MethodInfo *remm_; ParameterInfoList indices_; bool is_array_; }; diff --git a/include/osgIntrospection/ReaderWriter b/include/osgIntrospection/ReaderWriter index 3444fe533..a59b0a5e0 100644 --- a/include/osgIntrospection/ReaderWriter +++ b/include/osgIntrospection/ReaderWriter @@ -219,12 +219,12 @@ namespace osgIntrospection return is; } - virtual std::ostream &writeBinaryValue(std::ostream &os, const Value &v, const Options *options = 0) const + virtual std::ostream &writeBinaryValue(std::ostream &os, const Value &v, const Options * = 0) const { return os.write(reinterpret_cast(extract_raw_data(v)), sizeof(T)); } - virtual std::istream &readBinaryValue(std::istream &is, Value &v, const Options *options = 0) const + virtual std::istream &readBinaryValue(std::istream &is, Value &v, const Options * = 0) const { if (v.isEmpty()) v = Value(T()); diff --git a/include/osgIntrospection/Reflection b/include/osgIntrospection/Reflection index 3dbabf1bb..5bde15b3d 100644 --- a/include/osgIntrospection/Reflection +++ b/include/osgIntrospection/Reflection @@ -61,6 +61,7 @@ namespace osgIntrospection private: template friend class Reflector; + template friend struct TypeNameAliasProxy; struct StaticData { @@ -70,7 +71,7 @@ namespace osgIntrospection static StaticData &getOrCreateStaticData(); static Type *registerType(const std::type_info &ti); - static Type *registerOrReplaceType(const std::type_info &ti); + static Type *getOrRegisterType(const std::type_info &ti, bool replace_if_defined = false); private: static StaticData *staticdata__; diff --git a/include/osgIntrospection/ReflectionMacros b/include/osgIntrospection/ReflectionMacros index 33860a55d..3dd48bee7 100644 --- a/include/osgIntrospection/ReflectionMacros +++ b/include/osgIntrospection/ReflectionMacros @@ -2,67 +2,120 @@ #define OSGINTROSPECTION_REFLECTIONMACROS_ #include +#include // -------------------------------------------------------------------------- // "private" macros, not to be used outside this file // -------------------------------------------------------------------------- +#define COMMA , #define OSG_RM_CONCATENATE_MACRO(x, y) x##y #define OSG_RM_LINEID1(x, y) OSG_RM_CONCATENATE_MACRO(x, y) #define OSG_RM_LINEID(x) OSG_RM_LINEID1(x, __LINE__) // -------------------------------------------------------------------------- -// QUICK REFLECTORS +// TYPE NAME ALIASES // -------------------------------------------------------------------------- -#define STD_VALUE_REFLECTOR(t) namespace { osgIntrospection::StdValueReflector OSG_RM_LINEID(reflector) (#t); } -#define VALUE_REFLECTOR_WITH_RW(t, rw) namespace { osgIntrospection::ValueReflector OSG_RM_LINEID(reflector) (#t, new rw); } -#define STD_PAIR_REFLECTOR(t) namespace { osgIntrospection::StdPairReflector OSG_RM_LINEID(reflector) (#t); } -#define STD_PAIR_REFLECTOR_WITH_TYPES(t, pt1, pt2) namespace { osgIntrospection::StdPairReflector OSG_RM_LINEID(reflector) (#t); } -#define ABSTRACT_OBJECT_REFLECTOR(t) namespace { osgIntrospection::AbstractObjectReflector OSG_RM_LINEID(reflector) (#t); } -#define STD_CONTAINER_REFLECTOR(t) namespace { osgIntrospection::StdContainerReflector OSG_RM_LINEID(reflector) (#t); } -#define STD_CONTAINER_REFLECTOR_WITH_TYPES(t, vt) namespace { osgIntrospection::StdContainerReflector OSG_RM_LINEID(reflector) (#t); } -#define STD_MAP_REFLECTOR(t) namespace { osgIntrospection::StdMapReflector OSG_RM_LINEID(reflector) (#t); } -#define STD_MAP_REFLECTOR_WITH_TYPES(t, it, vt) namespace { osgIntrospection::StdMapReflector OSG_RM_LINEID(reflector) (#t); } +#define TYPE_NAME_ALIAS(t, n) \ + namespace { osgIntrospection::TypeNameAliasProxy OSG_RM_LINEID(tnalias) (#n); } + +// -------------------------------------------------------------------------- +// ONE-LINE REFLECTORS +// -------------------------------------------------------------------------- + +#define ABSTRACT_OBJECT_REFLECTOR(t) \ + namespace { osgIntrospection::AbstractObjectReflector OSG_RM_LINEID(reflector) (#t); } + +#define ATOMIC_VALUE_REFLECTOR(t) \ + namespace { osgIntrospection::AtomicValueReflector OSG_RM_LINEID(reflector) (#t); } + +#define STD_PAIR_REFLECTOR(t) \ + namespace { osgIntrospection::StdPairReflector OSG_RM_LINEID(reflector) (#t); } + +#define STD_PAIR_REFLECTOR_WITH_TYPES(t, pt1, pt2) \ + namespace { osgIntrospection::StdPairReflector OSG_RM_LINEID(reflector) (#t); } + +#define STD_VECTOR_REFLECTOR(t) \ + namespace { osgIntrospection::StdVectorReflector OSG_RM_LINEID(reflector) (#t); } + +#define STD_VECTOR_REFLECTOR_WITH_TYPES(t, vt) \ + namespace { osgIntrospection::StdVectorReflector OSG_RM_LINEID(reflector) (#t); } + +#define STD_LIST_REFLECTOR(t) \ + namespace { osgIntrospection::StdListReflector OSG_RM_LINEID(reflector) (#t); } + +#define STD_LIST_REFLECTOR_WITH_TYPES(t, vt) \ + namespace { osgIntrospection::StdListReflector OSG_RM_LINEID(reflector) (#t); } + +#define STD_SET_REFLECTOR(t) \ + namespace { osgIntrospection::StdSetReflector OSG_RM_LINEID(reflector) (#t); } + +#define STD_SET_REFLECTOR_WITH_TYPES(t, vt) \ + namespace { osgIntrospection::StdSetReflector OSG_RM_LINEID(reflector) (#t); } + +#define STD_MAP_REFLECTOR(t) \ + namespace { osgIntrospection::StdMapReflector OSG_RM_LINEID(reflector) (#t); } + +#define STD_MAP_REFLECTOR_WITH_TYPES(t, it, vt) \ + namespace { osgIntrospection::StdMapReflector OSG_RM_LINEID(reflector) (#t); } // -------------------------------------------------------------------------- // DETAILED REFLECTORS // -------------------------------------------------------------------------- +// this dummy function is used to prevent GCC from +// emitting an "unused variable" warning on reflector +// fields that are automatically created by following +// macros, and possibly left unused by the implementor. +// NOTE: the unnamed namespace declaration is commented +// out because it seems to confuse the MSVC++ compiler. +// Anyway, static should be ok. +//namespace +//{ + static inline void sink(const osgIntrospection::CustomAttributeProvider *) + { + } +//} + + #define BEGIN_ENUM_REFLECTOR(c) \ - namespace { struct OSG_RM_LINEID(reflector): public osgIntrospection::EnumReflector { OSG_RM_LINEID(reflector)(): inherited(#c) { osgIntrospection::ParameterInfoList params; osgIntrospection::CustomAttributeProvider *cap = getType(); + namespace { \ + struct OSG_RM_LINEID(reflector): osgIntrospection::EnumReflector { OSG_RM_LINEID(reflector)(): inherited(#c) { osgIntrospection::ParameterInfoList params; osgIntrospection::CustomAttributeProvider *cap = getType(); sink(cap); #define BEGIN_VALUE_REFLECTOR(c) \ - namespace { struct OSG_RM_LINEID(reflector): public osgIntrospection::ValueReflector { OSG_RM_LINEID(reflector)(): inherited(#c, 0) { osgIntrospection::ParameterInfoList params; osgIntrospection::CustomAttributeProvider *cap = getType(); + namespace { \ + struct OSG_RM_LINEID(reflector): osgIntrospection::ValueReflector { OSG_RM_LINEID(reflector)(): inherited(#c) { osgIntrospection::ParameterInfoList params; osgIntrospection::CustomAttributeProvider *cap = getType(); sink(cap); #define BEGIN_OBJECT_REFLECTOR(c) \ - namespace { struct OSG_RM_LINEID(reflector): public osgIntrospection::ObjectReflector { OSG_RM_LINEID(reflector)(): inherited(#c) { osgIntrospection::ParameterInfoList params; osgIntrospection::CustomAttributeProvider *cap = getType(); + namespace { \ + struct OSG_RM_LINEID(reflector): osgIntrospection::ObjectReflector { OSG_RM_LINEID(reflector)(): inherited(#c) { osgIntrospection::ParameterInfoList params; osgIntrospection::CustomAttributeProvider *cap = getType(); sink(cap); #define BEGIN_ABSTRACT_OBJECT_REFLECTOR(c) \ - namespace { struct OSG_RM_LINEID(reflector): public osgIntrospection::AbstractObjectReflector { OSG_RM_LINEID(reflector)(): inherited(#c) { osgIntrospection::ParameterInfoList params; osgIntrospection::CustomAttributeProvider *cap = getType(); + namespace { \ + struct OSG_RM_LINEID(reflector): osgIntrospection::AbstractObjectReflector { OSG_RM_LINEID(reflector)(): inherited(#c) { osgIntrospection::ParameterInfoList params; osgIntrospection::CustomAttributeProvider *cap = getType(); sink(cap); #define END_REFLECTOR \ } } OSG_RM_LINEID(reflector_instance); } // -------------------------------------------------------------------------- -// ATTRIBUTES +// BASIC CONFIGURATION // -------------------------------------------------------------------------- #define Attribute(c) cap->addAttribute(new c); - -// -------------------------------------------------------------------------- -// BASE TYPES -// -------------------------------------------------------------------------- +#define ReaderWriter(x) setReaderWriter(new x); +#define Comparator(x) setComparator(new x); #define BaseType(x) addBaseType(typeof(x)); +#define EnumLabel(x) addEnumLabel(x, #x, true); // -------------------------------------------------------------------------- -// PROPERTIES +// SIMPLE PROPERTIES // -------------------------------------------------------------------------- #define Property(t, n) \ @@ -80,31 +133,84 @@ 0, \ Method1(void, set##n, IN, t, value))) +#define PropertyWithReturnType(t, n, r) \ + cap=addProperty(new osgIntrospection::PropertyInfo(osgIntrospection::Reflection::getType(typeid(reflected_type)), osgIntrospection::Reflection::getType(typeid(t)), #n, \ + Method0(t, get##n), \ + Method1(r, set##n, IN, t, value))) + +#define WriteOnlyPropertyWithReturnType(t, n, r) \ + cap=addProperty(new osgIntrospection::PropertyInfo(osgIntrospection::Reflection::getType(typeid(reflected_type)), osgIntrospection::Reflection::getType(typeid(t)), #n, \ + 0, \ + Method1(r, set##n, IN, t, value))) + #define PropertyWithCustomAccessors(t, n) \ cap=addProperty(new osgIntrospection::PropertyInfo(osgIntrospection::Reflection::getType(typeid(reflected_type)), osgIntrospection::Reflection::getType(typeid(t)), #n, \ 0, \ 0)) -#define ArrayProperty(t, n, np) \ - cap=addProperty(new osgIntrospection::PropertyInfo(osgIntrospection::Reflection::getType(typeid(reflected_type)), osgIntrospection::Reflection::getType(typeid(t)), #np, \ - Method1(t, get##n, IN, unsigned int, index), \ - Method2(void, set##n, IN, unsigned int, index, IN, t, value), \ - Method0(unsigned int, getNum##np), \ - Method1(void, add##n, IN, t, value))) -#define ArrayPropertyWithCustomAccessors(t, n, np) \ +// -------------------------------------------------------------------------- +// ARRAY PROPERTIES +// -------------------------------------------------------------------------- + +#define ArrayProperty_Custom(t, n, np, idxt, r) \ cap=addProperty(new osgIntrospection::PropertyInfo(osgIntrospection::Reflection::getType(typeid(reflected_type)), osgIntrospection::Reflection::getType(typeid(t)), #np, \ 0, \ 0, \ 0, \ + 0, \ 0)) -#define ArrayPropertyWithReturnType(t, n, np, r) \ - cap=addProperty(new osgIntrospection::PropertyInfo(osgIntrospection::Reflection::getType(typeid(reflected_type)), osgIntrospection::Reflection::getType(typeid(t)), #n, \ - Method1(t, get##n, IN, unsigned int, index), \ - Method2(r, set##n, IN, unsigned int, index, IN, t, value), \ - Method0(unsigned int, getNum##np), \ - Method1(r, add##n, IN, t, value))) +#define ArrayProperty_Full(t, n, np, idxt, r) \ + cap=addProperty(new osgIntrospection::PropertyInfo(osgIntrospection::Reflection::getType(typeid(reflected_type)), osgIntrospection::Reflection::getType(typeid(t)), #np, \ + Method1(t, get##n, IN, idxt, index), \ + Method2(r, set##n, IN, idxt, index, IN, t, value), \ + Method0(idxt, getNum##np), \ + Method1(r, add##n, IN, t, value), \ + Method1(r, remove##n, IN, idxt, index))) + +#define ArrayProperty_GSA(t, n, np, idxt, r) \ + cap=addProperty(new osgIntrospection::PropertyInfo(osgIntrospection::Reflection::getType(typeid(reflected_type)), osgIntrospection::Reflection::getType(typeid(t)), #np, \ + Method1(t, get##n, IN, idxt, index), \ + Method2(r, set##n, IN, idxt, index, IN, t, value), \ + Method0(idxt, getNum##np), \ + Method1(r, add##n, IN, t, value), \ + 0)) + +#define ArrayProperty_G(t, n, np, idxt, r) \ + cap=addProperty(new osgIntrospection::PropertyInfo(osgIntrospection::Reflection::getType(typeid(reflected_type)), osgIntrospection::Reflection::getType(typeid(t)), #np, \ + Method1(t, get##n, IN, idxt, index), \ + 0, \ + Method0(idxt, getNum##np), \ + 0, \ + 0)) + +#define ArrayProperty_GA(t, n, np, idxt, r) \ + cap=addProperty(new osgIntrospection::PropertyInfo(osgIntrospection::Reflection::getType(typeid(reflected_type)), osgIntrospection::Reflection::getType(typeid(t)), #np, \ + Method1(t, get##n, IN, idxt, index), \ + 0, \ + Method0(idxt, getNum##np), \ + Method1(r, add##n, IN, t, value), \ + 0)) + +#define ArrayProperty_GAR(t, n, np, idxt, r) \ + cap=addProperty(new osgIntrospection::PropertyInfo(osgIntrospection::Reflection::getType(typeid(reflected_type)), osgIntrospection::Reflection::getType(typeid(t)), #np, \ + Method1(t, get##n, IN, idxt, index), \ + 0, \ + Method0(idxt, getNum##np), \ + Method1(r, add##n, IN, t, value), \ + Method1(r, remove##n, IN, idxt, index))) + +#define ArrayProperty(t, n, np) ArrayProperty_Full(t, n, np, unsigned int, void) +#define ArrayProperty_int(t, n, np) ArrayProperty_Full(t, n, np, int, void) +#define CustomArrayProperty(t, n, np) ArrayProperty_Custom(t, n, np, unsigned int, void) +#define CustomArrayProperty_int(t, n, np) ArrayProperty_Custom(t, n, np, int, void) + + +// -------------------------------------------------------------------------- +// INDEXED PROPERTIES +// -------------------------------------------------------------------------- + #define IndexedProperty IndexedProperty1 @@ -116,25 +222,463 @@ #define IndexedProperty2(t, n, i0, n0, i1, n1) \ cap=addProperty(new osgIntrospection::PropertyInfo(osgIntrospection::Reflection::getType(typeid(reflected_type)), osgIntrospection::Reflection::getType(typeid(t)), #n, \ Method2(t, get##n, IN, i0, n0, IN, i1, n1), \ - Method3(void, set##n, IN, i0, n0, IN i1, n1, IN, t, value))) + Method3(void, set##n, IN, i0, n0, IN, i1, n1, IN, t, value))) #define IndexedProperty3(t, n, i0, n0, i1, n1, i2, n2) \ cap=addProperty(new osgIntrospection::PropertyInfo(osgIntrospection::Reflection::getType(typeid(reflected_type)), osgIntrospection::Reflection::getType(typeid(t)), #n, \ Method3(t, get##n, IN, i0, n0, IN, i1, n1, IN, i2, n2), \ - Method4(void, set##n, IN, i0, n0, IN i1, n1, IN, i2, n2, IN, t, value))) + Method4(void, set##n, IN, i0, n0, IN, i1, n1, IN, i2, n2, IN, t, value))) + +#define IndexedProperty4(t, n, i0, n0, i1, n1, i2, n2, i3, n3) \ + cap=addProperty(new osgIntrospection::PropertyInfo(osgIntrospection::Reflection::getType(typeid(reflected_type)), osgIntrospection::Reflection::getType(typeid(t)), #n, \ + Method4(t, get##n, IN, i0, n0, IN, i1, n1, IN, i2, n2, IN, i3, n3), \ + Method5(void, set##n, IN, i0, n0, IN, i1, n1, IN, i2, n2, IN, i3, n3, IN, t, value))) + +#define IndexedPropertyWithReturnType1(t, n, i0, n0, r) \ + cap=addProperty(new osgIntrospection::PropertyInfo(osgIntrospection::Reflection::getType(typeid(reflected_type)), osgIntrospection::Reflection::getType(typeid(t)), #n, \ + Method1(t, get##n, IN, i0, n0), \ + Method2(r, set##n, IN, i0, n0, IN, t, value))) + +#define IndexedPropertyWithReturnType2(t, n, i0, n0, i1, n1, r) \ + cap=addProperty(new osgIntrospection::PropertyInfo(osgIntrospection::Reflection::getType(typeid(reflected_type)), osgIntrospection::Reflection::getType(typeid(t)), #n, \ + Method2(t, get##n, IN, i0, n0, IN, i1, n1), \ + Method3(r, set##n, IN, i0, n0, IN, i1, n1, IN, t, value))) + +#define IndexedPropertyWithReturnType3(t, n, i0, n0, i1, n1, i2, n2, r) \ + cap=addProperty(new osgIntrospection::PropertyInfo(osgIntrospection::Reflection::getType(typeid(reflected_type)), osgIntrospection::Reflection::getType(typeid(t)), #n, \ + Method3(t, get##n, IN, i0, n0, IN, i1, n1, IN, i2, n2), \ + Method4(r, set##n, IN, i0, n0, IN, i1, n1, IN, i2, n2, IN, t, value))) + +#define IndexedPropertyWithReturnType4(t, n, i0, n0, i1, n1, i2, n2, i3, n3, r) \ + cap=addProperty(new osgIntrospection::PropertyInfo(osgIntrospection::Reflection::getType(typeid(reflected_type)), osgIntrospection::Reflection::getType(typeid(t)), #n, \ + Method4(t, get##n, IN, i0, n0, IN, i1, n1, IN, i2, n2, IN, i3, n3), \ + Method5(r, set##n, IN, i0, n0, IN, i1, n1, IN, i2, n2, IN, i3, n3, IN, t, value))) + // -------------------------------------------------------------------------- -// ENUM LABELS +// CONSTRUCTORS // -------------------------------------------------------------------------- -#define EnumLabel(x) addEnumLabel(x, #x, true); +#define Constructor Constructor0 +#define ConstructorWithDefaults ConstructorWithDefaults0 + +#define Constructor0() (\ + params.clear(), \ + addConstructor(new osgIntrospection::TypedConstructorInfo0(params))) + +#define Constructor1(A0, P0, N0) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + addConstructor(new osgIntrospection::TypedConstructorInfo1(params))) + +#define Constructor2(A0, P0, N0, A1, P1, N1) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + addConstructor(new osgIntrospection::TypedConstructorInfo2(params))) + +#define Constructor3(A0, P0, N0, A1, P1, N1, A2, P2, N2) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + addConstructor(new osgIntrospection::TypedConstructorInfo3(params))) + +#define Constructor4(A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + addConstructor(new osgIntrospection::TypedConstructorInfo4(params))) + +#define Constructor5(A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + addConstructor(new osgIntrospection::TypedConstructorInfo5(params))) + +#define Constructor6(A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + addConstructor(new osgIntrospection::TypedConstructorInfo6(params))) + +#define Constructor7(A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + addConstructor(new osgIntrospection::TypedConstructorInfo7(params))) + +#define Constructor8(A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + addConstructor(new osgIntrospection::TypedConstructorInfo8(params))) + +#define Constructor9(A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + addConstructor(new osgIntrospection::TypedConstructorInfo9(params))) + +#define Constructor10(A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + addConstructor(new osgIntrospection::TypedConstructorInfo10(params))) + +#define Constructor11(A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9, A10, P10, N10) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10)), \ + addConstructor(new osgIntrospection::TypedConstructorInfo11(params))) + +#define Constructor12(A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9, A10, P10, N10, A11, P11, N11) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11)), \ + addConstructor(new osgIntrospection::TypedConstructorInfo12(params))) + +#define Constructor13(A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9, A10, P10, N10, A11, P11, N11, A12, P12, N12) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12)), \ + addConstructor(new osgIntrospection::TypedConstructorInfo13(params))) + +#define Constructor14(A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9, A10, P10, N10, A11, P11, N11, A12, P12, N12, A13, P13, N13) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), osgIntrospection::ParameterInfo::A13)), \ + addConstructor(new osgIntrospection::TypedConstructorInfo14(params))) + +#define Constructor15(A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9, A10, P10, N10, A11, P11, N11, A12, P12, N12, A13, P13, N13, A14, P14, N14) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), osgIntrospection::ParameterInfo::A13)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N14, osgIntrospection::Reflection::getType(typeid(P14)), osgIntrospection::ParameterInfo::A14)), \ + addConstructor(new osgIntrospection::TypedConstructorInfo15(params))) + +#define Constructor16(A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9, A10, P10, N10, A11, P11, N11, A12, P12, N12, A13, P13, N13, A14, P14, N14, A15, P15, N15) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), osgIntrospection::ParameterInfo::A13)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N14, osgIntrospection::Reflection::getType(typeid(P14)), osgIntrospection::ParameterInfo::A14)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N15, osgIntrospection::Reflection::getType(typeid(P15)), osgIntrospection::ParameterInfo::A15)), \ + addConstructor(new osgIntrospection::TypedConstructorInfo16(params))) + +#define ConstructorWithDefaults0() (\ + params.clear(), \ + addConstructor(new osgIntrospection::TypedConstructorInfo0(params))) + +#define ConstructorWithDefaults1(A0, P0, N0, D0) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + addConstructor(new osgIntrospection::TypedConstructorInfo1(params))) + +#define ConstructorWithDefaults2(A0, P0, N0, D0, A1, P1, N1, D1) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + addConstructor(new osgIntrospection::TypedConstructorInfo2(params))) + +#define ConstructorWithDefaults3(A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + addConstructor(new osgIntrospection::TypedConstructorInfo3(params))) + +#define ConstructorWithDefaults4(A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + addConstructor(new osgIntrospection::TypedConstructorInfo4(params))) + +#define ConstructorWithDefaults5(A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + addConstructor(new osgIntrospection::TypedConstructorInfo5(params))) + +#define ConstructorWithDefaults6(A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + addConstructor(new osgIntrospection::TypedConstructorInfo6(params))) + +#define ConstructorWithDefaults7(A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + addConstructor(new osgIntrospection::TypedConstructorInfo7(params))) + +#define ConstructorWithDefaults8(A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + addConstructor(new osgIntrospection::TypedConstructorInfo8(params))) + +#define ConstructorWithDefaults9(A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + addConstructor(new osgIntrospection::TypedConstructorInfo9(params))) + +#define ConstructorWithDefaults10(A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + addConstructor(new osgIntrospection::TypedConstructorInfo10(params))) + +#define ConstructorWithDefaults11(A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9, A10, P10, N10, D10) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10, osgIntrospection::Value(D10))), \ + addConstructor(new osgIntrospection::TypedConstructorInfo11(params))) + +#define ConstructorWithDefaults12(A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9, A10, P10, N10, D10, A11, P11, N11, D11) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10, osgIntrospection::Value(D10))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11, osgIntrospection::Value(D11))), \ + addConstructor(new osgIntrospection::TypedConstructorInfo12(params))) + +#define ConstructorWithDefaults13(A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9, A10, P10, N10, D10, A11, P11, N11, D11, A12, P12, N12, D12) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10, osgIntrospection::Value(D10))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11, osgIntrospection::Value(D11))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12, osgIntrospection::Value(D12))), \ + addConstructor(new osgIntrospection::TypedConstructorInfo13(params))) + +#define ConstructorWithDefaults14(A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9, A10, P10, N10, D10, A11, P11, N11, D11, A12, P12, N12, D12, A13, P13, N13, D13) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10, osgIntrospection::Value(D10))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11, osgIntrospection::Value(D11))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12, osgIntrospection::Value(D12))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), osgIntrospection::ParameterInfo::A13, osgIntrospection::Value(D13))), \ + addConstructor(new osgIntrospection::TypedConstructorInfo14(params))) + +#define ConstructorWithDefaults15(A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9, A10, P10, N10, D10, A11, P11, N11, D11, A12, P12, N12, D12, A13, P13, N13, D13, A14, P14, N14, D14) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10, osgIntrospection::Value(D10))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11, osgIntrospection::Value(D11))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12, osgIntrospection::Value(D12))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), osgIntrospection::ParameterInfo::A13, osgIntrospection::Value(D13))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N14, osgIntrospection::Reflection::getType(typeid(P14)), osgIntrospection::ParameterInfo::A14, osgIntrospection::Value(D14))), \ + addConstructor(new osgIntrospection::TypedConstructorInfo15(params))) + +#define ConstructorWithDefaults16(A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9, A10, P10, N10, D10, A11, P11, N11, D11, A12, P12, N12, D12, A13, P13, N13, D13, A14, P14, N14, D14, A15, P15, N15, D15) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10, osgIntrospection::Value(D10))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11, osgIntrospection::Value(D11))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12, osgIntrospection::Value(D12))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), osgIntrospection::ParameterInfo::A13, osgIntrospection::Value(D13))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N14, osgIntrospection::Reflection::getType(typeid(P14)), osgIntrospection::ParameterInfo::A14, osgIntrospection::Value(D14))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N15, osgIntrospection::Reflection::getType(typeid(P15)), osgIntrospection::ParameterInfo::A15, osgIntrospection::Value(D15))), \ + addConstructor(new osgIntrospection::TypedConstructorInfo16(params))) // -------------------------------------------------------------------------- // METHODS // -------------------------------------------------------------------------- -#define Method Method0 +#define Method Method0 +#define StaticMethod StaticMethod0 +#define MethodWithDefaults MethodWithDefaults0 +#define StaticMethodWithDefaults StaticMethodWithDefaults0 #define Method0(ret, fn) (\ params.clear(), \ @@ -142,182 +686,814 @@ #define Method1(ret, fn, A0, P0, N0) (\ params.clear(), \ - params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), 0, osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ addMethod(new osgIntrospection::TypedMethodInfo1(qualifyName(#fn), &reflected_type::fn, params))) #define Method2(ret, fn, A0, P0, N0, A1, P1, N1) (\ params.clear(), \ - params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), 0, osgIntrospection::ParameterInfo::A0)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), 1, osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ addMethod(new osgIntrospection::TypedMethodInfo2(qualifyName(#fn), &reflected_type::fn, params))) #define Method3(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2) (\ params.clear(), \ - params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), 0, osgIntrospection::ParameterInfo::A0)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), 1, osgIntrospection::ParameterInfo::A1)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), 2, osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ addMethod(new osgIntrospection::TypedMethodInfo3(qualifyName(#fn), &reflected_type::fn, params))) #define Method4(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3) (\ params.clear(), \ - params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), 0, osgIntrospection::ParameterInfo::A0)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), 1, osgIntrospection::ParameterInfo::A1)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), 2, osgIntrospection::ParameterInfo::A2)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), 3, osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ addMethod(new osgIntrospection::TypedMethodInfo4(qualifyName(#fn), &reflected_type::fn, params))) #define Method5(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4) (\ params.clear(), \ - params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), 0, osgIntrospection::ParameterInfo::A0)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), 1, osgIntrospection::ParameterInfo::A1)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), 2, osgIntrospection::ParameterInfo::A2)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), 3, osgIntrospection::ParameterInfo::A3)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), 4, osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ addMethod(new osgIntrospection::TypedMethodInfo5(qualifyName(#fn), &reflected_type::fn, params))) #define Method6(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5) (\ params.clear(), \ - params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), 0, osgIntrospection::ParameterInfo::A0)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), 1, osgIntrospection::ParameterInfo::A1)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), 2, osgIntrospection::ParameterInfo::A2)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), 3, osgIntrospection::ParameterInfo::A3)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), 4, osgIntrospection::ParameterInfo::A4)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), 5, osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ addMethod(new osgIntrospection::TypedMethodInfo6(qualifyName(#fn), &reflected_type::fn, params))) #define Method7(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6) (\ params.clear(), \ - params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), 0, osgIntrospection::ParameterInfo::A0)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), 1, osgIntrospection::ParameterInfo::A1)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), 2, osgIntrospection::ParameterInfo::A2)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), 3, osgIntrospection::ParameterInfo::A3)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), 4, osgIntrospection::ParameterInfo::A4)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), 5, osgIntrospection::ParameterInfo::A5)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), 6, osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ addMethod(new osgIntrospection::TypedMethodInfo7(qualifyName(#fn), &reflected_type::fn, params))) #define Method8(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7) (\ params.clear(), \ - params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), 0, osgIntrospection::ParameterInfo::A0)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), 1, osgIntrospection::ParameterInfo::A1)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), 2, osgIntrospection::ParameterInfo::A2)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), 3, osgIntrospection::ParameterInfo::A3)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), 4, osgIntrospection::ParameterInfo::A4)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), 5, osgIntrospection::ParameterInfo::A5)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), 6, osgIntrospection::ParameterInfo::A6)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), 7, osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ addMethod(new osgIntrospection::TypedMethodInfo8(qualifyName(#fn), &reflected_type::fn, params))) #define Method9(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8) (\ params.clear(), \ - params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), 0, osgIntrospection::ParameterInfo::A0)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), 1, osgIntrospection::ParameterInfo::A1)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), 2, osgIntrospection::ParameterInfo::A2)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), 3, osgIntrospection::ParameterInfo::A3)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), 4, osgIntrospection::ParameterInfo::A4)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), 5, osgIntrospection::ParameterInfo::A5)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), 6, osgIntrospection::ParameterInfo::A6)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), 7, osgIntrospection::ParameterInfo::A7)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), 8, osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ addMethod(new osgIntrospection::TypedMethodInfo9(qualifyName(#fn), &reflected_type::fn, params))) #define Method10(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9) (\ params.clear(), \ - params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), 0, osgIntrospection::ParameterInfo::A0)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), 1, osgIntrospection::ParameterInfo::A1)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), 2, osgIntrospection::ParameterInfo::A2)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), 3, osgIntrospection::ParameterInfo::A3)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), 4, osgIntrospection::ParameterInfo::A4)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), 5, osgIntrospection::ParameterInfo::A5)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), 6, osgIntrospection::ParameterInfo::A6)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), 7, osgIntrospection::ParameterInfo::A7)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), 8, osgIntrospection::ParameterInfo::A8)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), 9, osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ addMethod(new osgIntrospection::TypedMethodInfo10(qualifyName(#fn), &reflected_type::fn, params))) #define Method11(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9, A10, P10, N10) (\ params.clear(), \ - params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), 0, osgIntrospection::ParameterInfo::A0)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), 1, osgIntrospection::ParameterInfo::A1)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), 2, osgIntrospection::ParameterInfo::A2)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), 3, osgIntrospection::ParameterInfo::A3)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), 4, osgIntrospection::ParameterInfo::A4)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), 5, osgIntrospection::ParameterInfo::A5)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), 6, osgIntrospection::ParameterInfo::A6)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), 7, osgIntrospection::ParameterInfo::A7)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), 8, osgIntrospection::ParameterInfo::A8)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), 9, osgIntrospection::ParameterInfo::A9)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), 10, osgIntrospection::ParameterInfo::A10)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10)), \ addMethod(new osgIntrospection::TypedMethodInfo11(qualifyName(#fn), &reflected_type::fn, params))) #define Method12(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9, A10, P10, N10, A11, P11, N11) (\ params.clear(), \ - params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), 0, osgIntrospection::ParameterInfo::A0)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), 1, osgIntrospection::ParameterInfo::A1)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), 2, osgIntrospection::ParameterInfo::A2)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), 3, osgIntrospection::ParameterInfo::A3)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), 4, osgIntrospection::ParameterInfo::A4)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), 5, osgIntrospection::ParameterInfo::A5)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), 6, osgIntrospection::ParameterInfo::A6)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), 7, osgIntrospection::ParameterInfo::A7)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), 8, osgIntrospection::ParameterInfo::A8)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), 9, osgIntrospection::ParameterInfo::A9)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), 10, osgIntrospection::ParameterInfo::A10)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), 11, osgIntrospection::ParameterInfo::A11)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11)), \ addMethod(new osgIntrospection::TypedMethodInfo12(qualifyName(#fn), &reflected_type::fn, params))) #define Method13(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9, A10, P10, N10, A11, P11, N11, A12, P12, N12) (\ params.clear(), \ - params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), 0, osgIntrospection::ParameterInfo::A0)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), 1, osgIntrospection::ParameterInfo::A1)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), 2, osgIntrospection::ParameterInfo::A2)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), 3, osgIntrospection::ParameterInfo::A3)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), 4, osgIntrospection::ParameterInfo::A4)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), 5, osgIntrospection::ParameterInfo::A5)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), 6, osgIntrospection::ParameterInfo::A6)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), 7, osgIntrospection::ParameterInfo::A7)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), 8, osgIntrospection::ParameterInfo::A8)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), 9, osgIntrospection::ParameterInfo::A9)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), 10, osgIntrospection::ParameterInfo::A10)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), 11, osgIntrospection::ParameterInfo::A11)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), 12, osgIntrospection::ParameterInfo::A12)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12)), \ addMethod(new osgIntrospection::TypedMethodInfo13(qualifyName(#fn), &reflected_type::fn, params))) #define Method14(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9, A10, P10, N10, A11, P11, N11, A12, P12, N12, A13, P13, N13) (\ params.clear(), \ - params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), 0, osgIntrospection::ParameterInfo::A0)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), 1, osgIntrospection::ParameterInfo::A1)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), 2, osgIntrospection::ParameterInfo::A2)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), 3, osgIntrospection::ParameterInfo::A3)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), 4, osgIntrospection::ParameterInfo::A4)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), 5, osgIntrospection::ParameterInfo::A5)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), 6, osgIntrospection::ParameterInfo::A6)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), 7, osgIntrospection::ParameterInfo::A7)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), 8, osgIntrospection::ParameterInfo::A8)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), 9, osgIntrospection::ParameterInfo::A9)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), 10, osgIntrospection::ParameterInfo::A10)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), 11, osgIntrospection::ParameterInfo::A11)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), 12, osgIntrospection::ParameterInfo::A12)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), 13, osgIntrospection::ParameterInfo::A13)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), osgIntrospection::ParameterInfo::A13)), \ addMethod(new osgIntrospection::TypedMethodInfo14(qualifyName(#fn), &reflected_type::fn, params))) #define Method15(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9, A10, P10, N10, A11, P11, N11, A12, P12, N12, A13, P13, N13, A14, P14, N14) (\ params.clear(), \ - params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), 0, osgIntrospection::ParameterInfo::A0)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), 1, osgIntrospection::ParameterInfo::A1)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), 2, osgIntrospection::ParameterInfo::A2)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), 3, osgIntrospection::ParameterInfo::A3)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), 4, osgIntrospection::ParameterInfo::A4)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), 5, osgIntrospection::ParameterInfo::A5)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), 6, osgIntrospection::ParameterInfo::A6)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), 7, osgIntrospection::ParameterInfo::A7)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), 8, osgIntrospection::ParameterInfo::A8)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), 9, osgIntrospection::ParameterInfo::A9)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), 10, osgIntrospection::ParameterInfo::A10)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), 11, osgIntrospection::ParameterInfo::A11)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), 12, osgIntrospection::ParameterInfo::A12)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), 13, osgIntrospection::ParameterInfo::A13)), \ - params.push_back(new osgIntrospection::ParameterInfo(#N14, osgIntrospection::Reflection::getType(typeid(P14)), 14, osgIntrospection::ParameterInfo::A14)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), osgIntrospection::ParameterInfo::A13)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N14, osgIntrospection::Reflection::getType(typeid(P14)), osgIntrospection::ParameterInfo::A14)), \ addMethod(new osgIntrospection::TypedMethodInfo15(qualifyName(#fn), &reflected_type::fn, params))) +#define Method16(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9, A10, P10, N10, A11, P11, N11, A12, P12, N12, A13, P13, N13, A14, P14, N14, A15, P15, N15) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), osgIntrospection::ParameterInfo::A13)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N14, osgIntrospection::Reflection::getType(typeid(P14)), osgIntrospection::ParameterInfo::A14)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N15, osgIntrospection::Reflection::getType(typeid(P15)), osgIntrospection::ParameterInfo::A15)), \ + addMethod(new osgIntrospection::TypedMethodInfo16(qualifyName(#fn), &reflected_type::fn, params))) + +#define MethodWithDefaults0(ret, fn) (\ + params.clear(), \ + addMethod(new osgIntrospection::TypedMethodInfo0(qualifyName(#fn), &reflected_type::fn, params))) + +#define MethodWithDefaults1(ret, fn, A0, P0, N0, D0) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + addMethod(new osgIntrospection::TypedMethodInfo1(qualifyName(#fn), &reflected_type::fn, params))) + +#define MethodWithDefaults2(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + addMethod(new osgIntrospection::TypedMethodInfo2(qualifyName(#fn), &reflected_type::fn, params))) + +#define MethodWithDefaults3(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + addMethod(new osgIntrospection::TypedMethodInfo3(qualifyName(#fn), &reflected_type::fn, params))) + +#define MethodWithDefaults4(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + addMethod(new osgIntrospection::TypedMethodInfo4(qualifyName(#fn), &reflected_type::fn, params))) + +#define MethodWithDefaults5(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + addMethod(new osgIntrospection::TypedMethodInfo5(qualifyName(#fn), &reflected_type::fn, params))) + +#define MethodWithDefaults6(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + addMethod(new osgIntrospection::TypedMethodInfo6(qualifyName(#fn), &reflected_type::fn, params))) + +#define MethodWithDefaults7(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + addMethod(new osgIntrospection::TypedMethodInfo7(qualifyName(#fn), &reflected_type::fn, params))) + +#define MethodWithDefaults8(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + addMethod(new osgIntrospection::TypedMethodInfo8(qualifyName(#fn), &reflected_type::fn, params))) + +#define MethodWithDefaults9(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + addMethod(new osgIntrospection::TypedMethodInfo9(qualifyName(#fn), &reflected_type::fn, params))) + +#define MethodWithDefaults10(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + addMethod(new osgIntrospection::TypedMethodInfo10(qualifyName(#fn), &reflected_type::fn, params))) + +#define MethodWithDefaults11(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9, A10, P10, N10, D10) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10, osgIntrospection::Value(D10))), \ + addMethod(new osgIntrospection::TypedMethodInfo11(qualifyName(#fn), &reflected_type::fn, params))) + +#define MethodWithDefaults12(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9, A10, P10, N10, D10, A11, P11, N11, D11) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10, osgIntrospection::Value(D10))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11, osgIntrospection::Value(D11))), \ + addMethod(new osgIntrospection::TypedMethodInfo12(qualifyName(#fn), &reflected_type::fn, params))) + +#define MethodWithDefaults13(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9, A10, P10, N10, D10, A11, P11, N11, D11, A12, P12, N12, D12) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10, osgIntrospection::Value(D10))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11, osgIntrospection::Value(D11))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12, osgIntrospection::Value(D12))), \ + addMethod(new osgIntrospection::TypedMethodInfo13(qualifyName(#fn), &reflected_type::fn, params))) + +#define MethodWithDefaults14(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9, A10, P10, N10, D10, A11, P11, N11, D11, A12, P12, N12, D12, A13, P13, N13, D13) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10, osgIntrospection::Value(D10))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11, osgIntrospection::Value(D11))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12, osgIntrospection::Value(D12))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), osgIntrospection::ParameterInfo::A13, osgIntrospection::Value(D13))), \ + addMethod(new osgIntrospection::TypedMethodInfo14(qualifyName(#fn), &reflected_type::fn, params))) + +#define MethodWithDefaults15(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9, A10, P10, N10, D10, A11, P11, N11, D11, A12, P12, N12, D12, A13, P13, N13, D13, A14, P14, N14, D14) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10, osgIntrospection::Value(D10))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11, osgIntrospection::Value(D11))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12, osgIntrospection::Value(D12))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), osgIntrospection::ParameterInfo::A13, osgIntrospection::Value(D13))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N14, osgIntrospection::Reflection::getType(typeid(P14)), osgIntrospection::ParameterInfo::A14, osgIntrospection::Value(D14))), \ + addMethod(new osgIntrospection::TypedMethodInfo15(qualifyName(#fn), &reflected_type::fn, params))) + +#define MethodWithDefaults16(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9, A10, P10, N10, D10, A11, P11, N11, D11, A12, P12, N12, D12, A13, P13, N13, D13, A14, P14, N14, D14, A15, P15, N15, D15) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10, osgIntrospection::Value(D10))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11, osgIntrospection::Value(D11))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12, osgIntrospection::Value(D12))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), osgIntrospection::ParameterInfo::A13, osgIntrospection::Value(D13))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N14, osgIntrospection::Reflection::getType(typeid(P14)), osgIntrospection::ParameterInfo::A14, osgIntrospection::Value(D14))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N15, osgIntrospection::Reflection::getType(typeid(P15)), osgIntrospection::ParameterInfo::A15, osgIntrospection::Value(D15))), \ + addMethod(new osgIntrospection::TypedMethodInfo16(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethod0(ret, fn) (\ + params.clear(), \ + addMethod(new osgIntrospection::StaticMethodInfo0(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethod1(ret, fn, A0, P0, N0) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + addMethod(new osgIntrospection::StaticMethodInfo1(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethod2(ret, fn, A0, P0, N0, A1, P1, N1) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + addMethod(new osgIntrospection::StaticMethodInfo2(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethod3(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + addMethod(new osgIntrospection::StaticMethodInfo3(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethod4(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + addMethod(new osgIntrospection::StaticMethodInfo4(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethod5(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + addMethod(new osgIntrospection::StaticMethodInfo5(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethod6(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + addMethod(new osgIntrospection::StaticMethodInfo6(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethod7(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + addMethod(new osgIntrospection::StaticMethodInfo7(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethod8(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + addMethod(new osgIntrospection::StaticMethodInfo8(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethod9(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + addMethod(new osgIntrospection::StaticMethodInfo9(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethod10(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + addMethod(new osgIntrospection::StaticMethodInfo10(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethod11(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9, A10, P10, N10) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10)), \ + addMethod(new osgIntrospection::StaticMethodInfo11(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethod12(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9, A10, P10, N10, A11, P11, N11) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11)), \ + addMethod(new osgIntrospection::StaticMethodInfo12(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethod13(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9, A10, P10, N10, A11, P11, N11, A12, P12, N12) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12)), \ + addMethod(new osgIntrospection::StaticMethodInfo13(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethod14(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9, A10, P10, N10, A11, P11, N11, A12, P12, N12, A13, P13, N13) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), osgIntrospection::ParameterInfo::A13)), \ + addMethod(new osgIntrospection::StaticMethodInfo14(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethod15(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9, A10, P10, N10, A11, P11, N11, A12, P12, N12, A13, P13, N13, A14, P14, N14) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), osgIntrospection::ParameterInfo::A13)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N14, osgIntrospection::Reflection::getType(typeid(P14)), osgIntrospection::ParameterInfo::A14)), \ + addMethod(new osgIntrospection::StaticMethodInfo15(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethod16(ret, fn, A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4, A5, P5, N5, A6, P6, N6, A7, P7, N7, A8, P8, N8, A9, P9, N9, A10, P10, N10, A11, P11, N11, A12, P12, N12, A13, P13, N13, A14, P14, N14, A15, P15, N15) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), osgIntrospection::ParameterInfo::A13)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N14, osgIntrospection::Reflection::getType(typeid(P14)), osgIntrospection::ParameterInfo::A14)), \ + params.push_back(new osgIntrospection::ParameterInfo(#N15, osgIntrospection::Reflection::getType(typeid(P15)), osgIntrospection::ParameterInfo::A15)), \ + addMethod(new osgIntrospection::StaticMethodInfo16(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethodWithDefaults0(ret, fn) (\ + params.clear(), \ + addMethod(new osgIntrospection::StaticMethodInfo0(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethodWithDefaults1(ret, fn, A0, P0, N0, D0) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + addMethod(new osgIntrospection::StaticMethodInfo1(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethodWithDefaults2(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + addMethod(new osgIntrospection::StaticMethodInfo2(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethodWithDefaults3(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + addMethod(new osgIntrospection::StaticMethodInfo3(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethodWithDefaults4(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + addMethod(new osgIntrospection::StaticMethodInfo4(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethodWithDefaults5(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + addMethod(new osgIntrospection::StaticMethodInfo5(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethodWithDefaults6(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + addMethod(new osgIntrospection::StaticMethodInfo6(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethodWithDefaults7(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + addMethod(new osgIntrospection::StaticMethodInfo7(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethodWithDefaults8(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + addMethod(new osgIntrospection::StaticMethodInfo8(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethodWithDefaults9(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + addMethod(new osgIntrospection::StaticMethodInfo9(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethodWithDefaults10(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + addMethod(new osgIntrospection::StaticMethodInfo10(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethodWithDefaults11(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9, A10, P10, N10, D10) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10, osgIntrospection::Value(D10))), \ + addMethod(new osgIntrospection::StaticMethodInfo11(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethodWithDefaults12(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9, A10, P10, N10, D10, A11, P11, N11, D11) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10, osgIntrospection::Value(D10))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11, osgIntrospection::Value(D11))), \ + addMethod(new osgIntrospection::StaticMethodInfo12(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethodWithDefaults13(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9, A10, P10, N10, D10, A11, P11, N11, D11, A12, P12, N12, D12) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10, osgIntrospection::Value(D10))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11, osgIntrospection::Value(D11))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12, osgIntrospection::Value(D12))), \ + addMethod(new osgIntrospection::StaticMethodInfo13(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethodWithDefaults14(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9, A10, P10, N10, D10, A11, P11, N11, D11, A12, P12, N12, D12, A13, P13, N13, D13) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10, osgIntrospection::Value(D10))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11, osgIntrospection::Value(D11))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12, osgIntrospection::Value(D12))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), osgIntrospection::ParameterInfo::A13, osgIntrospection::Value(D13))), \ + addMethod(new osgIntrospection::StaticMethodInfo14(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethodWithDefaults15(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9, A10, P10, N10, D10, A11, P11, N11, D11, A12, P12, N12, D12, A13, P13, N13, D13, A14, P14, N14, D14) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10, osgIntrospection::Value(D10))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11, osgIntrospection::Value(D11))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12, osgIntrospection::Value(D12))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), osgIntrospection::ParameterInfo::A13, osgIntrospection::Value(D13))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N14, osgIntrospection::Reflection::getType(typeid(P14)), osgIntrospection::ParameterInfo::A14, osgIntrospection::Value(D14))), \ + addMethod(new osgIntrospection::StaticMethodInfo15(qualifyName(#fn), &reflected_type::fn, params))) + +#define StaticMethodWithDefaults16(ret, fn, A0, P0, N0, D0, A1, P1, N1, D1, A2, P2, N2, D2, A3, P3, N3, D3, A4, P4, N4, D4, A5, P5, N5, D5, A6, P6, N6, D6, A7, P7, N7, D7, A8, P8, N8, D8, A9, P9, N9, D9, A10, P10, N10, D10, A11, P11, N11, D11, A12, P12, N12, D12, A13, P13, N13, D13, A14, P14, N14, D14, A15, P15, N15, D15) (\ + params.clear(), \ + params.push_back(new osgIntrospection::ParameterInfo(#N0, osgIntrospection::Reflection::getType(typeid(P0)), osgIntrospection::ParameterInfo::A0, osgIntrospection::Value(D0))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N1, osgIntrospection::Reflection::getType(typeid(P1)), osgIntrospection::ParameterInfo::A1, osgIntrospection::Value(D1))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N2, osgIntrospection::Reflection::getType(typeid(P2)), osgIntrospection::ParameterInfo::A2, osgIntrospection::Value(D2))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N3, osgIntrospection::Reflection::getType(typeid(P3)), osgIntrospection::ParameterInfo::A3, osgIntrospection::Value(D3))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N4, osgIntrospection::Reflection::getType(typeid(P4)), osgIntrospection::ParameterInfo::A4, osgIntrospection::Value(D4))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N5, osgIntrospection::Reflection::getType(typeid(P5)), osgIntrospection::ParameterInfo::A5, osgIntrospection::Value(D5))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N6, osgIntrospection::Reflection::getType(typeid(P6)), osgIntrospection::ParameterInfo::A6, osgIntrospection::Value(D6))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N7, osgIntrospection::Reflection::getType(typeid(P7)), osgIntrospection::ParameterInfo::A7, osgIntrospection::Value(D7))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N8, osgIntrospection::Reflection::getType(typeid(P8)), osgIntrospection::ParameterInfo::A8, osgIntrospection::Value(D8))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N9, osgIntrospection::Reflection::getType(typeid(P9)), osgIntrospection::ParameterInfo::A9, osgIntrospection::Value(D9))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N10, osgIntrospection::Reflection::getType(typeid(P10)), osgIntrospection::ParameterInfo::A10, osgIntrospection::Value(D10))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N11, osgIntrospection::Reflection::getType(typeid(P11)), osgIntrospection::ParameterInfo::A11, osgIntrospection::Value(D11))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N12, osgIntrospection::Reflection::getType(typeid(P12)), osgIntrospection::ParameterInfo::A12, osgIntrospection::Value(D12))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N13, osgIntrospection::Reflection::getType(typeid(P13)), osgIntrospection::ParameterInfo::A13, osgIntrospection::Value(D13))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N14, osgIntrospection::Reflection::getType(typeid(P14)), osgIntrospection::ParameterInfo::A14, osgIntrospection::Value(D14))), \ + params.push_back(new osgIntrospection::ParameterInfo(#N15, osgIntrospection::Reflection::getType(typeid(P15)), osgIntrospection::ParameterInfo::A15, osgIntrospection::Value(D15))), \ + addMethod(new osgIntrospection::StaticMethodInfo16(qualifyName(#fn), &reflected_type::fn, params))) + #endif diff --git a/include/osgIntrospection/Reflector b/include/osgIntrospection/Reflector index ef799fd0b..7303e9b01 100644 --- a/include/osgIntrospection/Reflector +++ b/include/osgIntrospection/Reflector @@ -3,17 +3,23 @@ #include #include +#include #include +#include +#include +#include #include +#include +#include #include #include +#include namespace osgIntrospection { class CustomAttribute; - class CustomAttributeProvider; class ReaderWriter; /// A Reflector is a proxy class that is used to create a new description @@ -42,15 +48,13 @@ namespace osgIntrospection protected: /// Direct initialization constructor. Parameter 'name' is the name - /// of the type being reflected, 'ns' is its namespace and 'rw' is - /// the ReaderWriter object associated to the type. - Reflector(const std::string &name, const std::string &ns, const ReaderWriter *rw); + /// of the type being reflected and 'ns' is its namespace. + Reflector(const std::string &name, const std::string &ns, bool abstract = false); /// Direct initialization constructor. Parameter 'qname' is the /// fully-qualified name of the type being reflected, i.e. containing - /// both the namespace and the name (separated by "::"). Parameter - /// 'rw' is the ReaderWriter object associated to the type. - Reflector(const std::string &qname, const ReaderWriter *rw); + /// both the namespace and the name (separated by "::"). + Reflector(const std::string &qname, bool abstract = false); protected: @@ -59,6 +63,9 @@ namespace osgIntrospection /// Declares a new base type for the current type. void addBaseType(const Type &type); + + /// Sets the comparator object for the current type. + void setComparator(const Comparator *cmp); /// Adds a property description to the current type. PropertyInfo *addProperty(PropertyInfo *pi); @@ -69,8 +76,11 @@ namespace osgIntrospection /// Adds an enumeration label to the current type. void addEnumLabel(int v, const std::string &label, bool strip_namespace = true); - /// Sets the instance creator for the current type. - void setInstanceCreator(const InstanceCreatorBase *icb); + /// Adds a constructor description to the current type. + /// As soon as a constructor is added through this method, + /// the automatically-generated default constructor is + /// removed. + ConstructorInfo *addConstructor(ConstructorInfo *ci); /// Returns a string containing the qualified version of 'name'. std::string qualifyName(const std::string name) const; @@ -82,8 +92,32 @@ namespace osgIntrospection void setReaderWriter(const ReaderWriter *rw); private: - void init(); + struct PtrConstructor: ConstructorInfo + { + PtrConstructor(const Type *pt) + : ConstructorInfo(*pt, ParameterInfoList()) + { + } + Value createInstance(ValueList &) const { T* x = 0; return x; } + }; + + struct ConstPtrConstructor: ConstructorInfo + { + ConstPtrConstructor(const Type *pt) + : ConstructorInfo(*pt, ParameterInfoList()) + { + } + + Value createInstance(ValueList &) const { const T *x = 0; return x; } + }; + + void init(); + static std::string purify(const std::string &s); + static void split_qualified_name(const std::string &q, std::string &n, std::string &ns); + + typedef std::vector TempMethodList; + TempMethodList temp_methods_; Type *type_; }; @@ -93,38 +127,38 @@ namespace osgIntrospection /// classes. The instance creator associated to types created through /// this reflector will create Value objects whose internal type is T. template - struct ValueReflector: public Reflector + struct ValueReflector: Reflector { typedef ValueReflector inherited; + typedef ValueInstanceCreator::reflected_type> instance_creator_type; - ValueReflector(const std::string &name, const std::string &ns, const ReaderWriter *rw = 0) - : Reflector(name, ns, rw) + ValueReflector(const std::string &name, const std::string &ns) + : Reflector(name, ns, false) { - setInstanceCreator(new ValueInstanceCreator); } - ValueReflector(const std::string &qname, const ReaderWriter *rw = 0) - : Reflector(qname, rw) + ValueReflector(const std::string &qname) + : Reflector(qname, false) { - setInstanceCreator(new ValueInstanceCreator); } }; /// This reflector is to be used to describe abstract types that can't - /// be created directly, and therefore can't have an InstanceCreator - /// object associated to them. + /// be instantiated. For this reason a DummyInstanceCreator is used in + /// order to avoid compiler errors. template - struct AbstractObjectReflector: public Reflector + struct AbstractObjectReflector: Reflector { typedef AbstractObjectReflector inherited; + typedef DummyInstanceCreator::reflected_type> instance_creator_type; AbstractObjectReflector(const std::string &name, const std::string &ns) - : Reflector(name, ns, 0) + : Reflector(name, ns, true) { } AbstractObjectReflector(const std::string &qname) - : Reflector(qname, 0) + : Reflector(qname, true) { } }; @@ -135,20 +169,19 @@ namespace osgIntrospection /// created through this reflector will create Value objects whose /// internal type is T*. template - struct ObjectReflector: public Reflector + struct ObjectReflector: Reflector { typedef ObjectReflector inherited; + typedef ObjectInstanceCreator::reflected_type> instance_creator_type; ObjectReflector(const std::string &name, const std::string &ns) - : Reflector(name, ns, 0) + : Reflector(name, ns, false) { - setInstanceCreator(new InstanceCreator); } ObjectReflector(const std::string &qname) - : Reflector(qname, 0) + : Reflector(qname, false) { - setInstanceCreator(new InstanceCreator); } }; @@ -157,16 +190,24 @@ namespace osgIntrospection /// types that can be read and written from/to streams using the << /// and >> operators. A StdReaderWriter is assigned by default. template - struct StdValueReflector: public ValueReflector + struct AtomicValueReflector: ValueReflector { - StdValueReflector(const std::string &name, const std::string &ns) - : ValueReflector(name, ns, new StdReaderWriter) + typedef typename ValueReflector::instance_creator_type instance_creator_type; + + AtomicValueReflector(const std::string &name, const std::string &ns) + : ValueReflector(name, ns) { + setReaderWriter(new StdReaderWriter); + setComparator(new PartialOrderComparator); + addConstructor(new TypedConstructorInfo0(ParameterInfoList())); } - StdValueReflector(const std::string &qname) - : ValueReflector(qname, new StdReaderWriter) + AtomicValueReflector(const std::string &qname) + : ValueReflector(qname) { + setReaderWriter(new StdReaderWriter); + setComparator(new PartialOrderComparator); + addConstructor(new TypedConstructorInfo0(ParameterInfoList())); } }; @@ -174,29 +215,44 @@ namespace osgIntrospection /// This reflector is a ValueReflector that should be used to define /// enumerations. It assigns an EnumReaderWriter by default. template - struct EnumReflector: public ValueReflector + struct EnumReflector: ValueReflector { typedef EnumReflector inherited; + typedef typename ValueReflector::instance_creator_type instance_creator_type; EnumReflector(const std::string &name, const std::string &ns) - : ValueReflector(name, ns, new EnumReaderWriter) + : ValueReflector(name, ns) { + setReaderWriter(new EnumReaderWriter); + setComparator(new TotalOrderComparator); + addConstructor(new TypedConstructorInfo0(ParameterInfoList())); } EnumReflector(const std::string &qname) - : ValueReflector(qname, new EnumReaderWriter) + : ValueReflector(qname) { - } + setReaderWriter(new EnumReaderWriter); + setComparator(new TotalOrderComparator); + addConstructor(new TypedConstructorInfo0(ParameterInfoList())); + } }; /// This class allows to define the means for reflecting STL containers /// such as std::deque and std::vector. template - struct StdContainerReflector: ValueReflector + struct StdVectorReflector: ValueReflector { + typedef typename ValueReflector::instance_creator_type instance_creator_type; + struct Getter: PropertyGetter { + virtual Value get(Value &instance, int i) const + { + T &ctr = variant_cast(instance); + return ctr.at(i); + } + virtual Value get(const Value &instance, int i) const { const T &ctr = variant_cast(instance); @@ -231,13 +287,189 @@ namespace osgIntrospection } }; - StdContainerReflector(const std::string &name): ValueReflector(name) + struct Remover: PropertyRemover { - PropertyInfo *pi = new PropertyInfo(typeof(T), typeof(typename T::value_type), "Items", 0, 0, 0, 0); + virtual void remove(Value &instance, int i) const + { + T &ctr = variant_cast(instance); + typename T::iterator j=ctr.begin(); + std::advance(j, i); + ctr.erase(j); + } + }; + + StdVectorReflector(const std::string &name): ValueReflector(name) + { + addConstructor(new TypedConstructorInfo0(ParameterInfoList())); + + PropertyInfo *pi = new PropertyInfo(typeof(T), typeof(typename T::value_type), "Items", 0, 0, 0, 0, 0); pi->addAttribute(new CustomPropertyGetAttribute(new Getter)); pi->addAttribute(new CustomPropertySetAttribute(new Setter)); pi->addAttribute(new CustomPropertyCountAttribute(new Counter)); pi->addAttribute(new CustomPropertyAddAttribute(new Adder)); + pi->addAttribute(new CustomPropertyRemoveAttribute(new Remover)); + + if (typeid(VT).before(typeid(typename T::value_type)) || + typeid(typename T::value_type).before(typeid(VT))) + { + pi->addAttribute(new PropertyTypeAttribute(typeof(VT))); + } + + this->addProperty(pi); + } + }; + + /// This class allows to define the means for reflecting STL containers + /// such as std::set and std::multiset. + template + struct StdSetReflector: ValueReflector + { + typedef typename ValueReflector::instance_creator_type instance_creator_type; + + struct Getter: PropertyGetter + { + virtual Value get(Value &instance, int i) const + { + T &ctr = variant_cast(instance); + typename T::iterator j=ctr.begin(); + std::advance(j, i); + return *j; + } + + virtual Value get(const Value &instance, int i) const + { + const T &ctr = variant_cast(instance); + typename T::const_iterator j=ctr.begin(); + std::advance(j, i); + return *j; + } + }; + + struct Counter: PropertyCounter + { + virtual int count(const Value &instance) const + { + const T &ctr = variant_cast(instance); + return static_cast(ctr.size()); + } + }; + + struct Adder: PropertyAdder + { + virtual void add(Value &instance, const Value &v) const + { + T &ctr = variant_cast(instance); + ctr.insert(variant_cast(v)); + } + }; + + struct Remover: PropertyRemover + { + virtual void remove(Value &instance, int i) const + { + T &ctr = variant_cast(instance); + typename T::iterator j=ctr.begin(); + std::advance(j, i); + ctr.erase(j); + } + }; + + StdSetReflector(const std::string &name): ValueReflector(name) + { + addConstructor(new TypedConstructorInfo0(ParameterInfoList())); + + PropertyInfo *pi = new PropertyInfo(typeof(T), typeof(typename T::value_type), "Items", 0, 0, 0, 0, 0); + pi->addAttribute(new CustomPropertyGetAttribute(new Getter)); + pi->addAttribute(new CustomPropertyCountAttribute(new Counter)); + pi->addAttribute(new CustomPropertyAddAttribute(new Adder)); + pi->addAttribute(new CustomPropertyRemoveAttribute(new Remover)); + + if (typeid(VT).before(typeid(typename T::value_type)) || + typeid(typename T::value_type).before(typeid(VT))) + { + pi->addAttribute(new PropertyTypeAttribute(typeof(VT))); + } + + this->addProperty(pi); + } + }; + + /// This class allows to define the means for reflecting STL containers + /// that cannot be indexed directly, such as std::list. + template + struct StdListReflector: ValueReflector + { + typedef typename ValueReflector::instance_creator_type instance_creator_type; + + struct Getter: PropertyGetter + { + virtual Value get(Value &instance, int i) const + { + T &ctr = variant_cast(instance); + typename T::iterator j=ctr.begin(); + std::advance(j, i); + return *j; + } + + virtual Value get(const Value &instance, int i) const + { + const T &ctr = variant_cast(instance); + typename T::const_iterator j=ctr.begin(); + std::advance(j, i); + return *j; + } + }; + + struct Setter: PropertySetter + { + virtual void set(Value &instance, int i, const Value &v) const + { + T &ctr = variant_cast(instance); + typename T::iterator j=ctr.begin(); + std::advance(j, i); + *j = variant_cast(v); + } + }; + + struct Counter: PropertyCounter + { + virtual int count(const Value &instance) const + { + const T &ctr = variant_cast(instance); + return static_cast(ctr.size()); + } + }; + + struct Adder: PropertyAdder + { + virtual void add(Value &instance, const Value &v) const + { + T &ctr = variant_cast(instance); + ctr.push_back(variant_cast(v)); + } + }; + + struct Remover: PropertyRemover + { + virtual void remove(Value &instance, int i) const + { + T &ctr = variant_cast(instance); + typename T::iterator j=ctr.begin(); + std::advance(j, i); + ctr.erase(j); + } + }; + + StdListReflector(const std::string &name): ValueReflector(name) + { + addConstructor(new TypedConstructorInfo0(ParameterInfoList())); + + PropertyInfo *pi = new PropertyInfo(typeof(T), typeof(typename T::value_type), "Items", 0, 0, 0, 0, 0); + pi->addAttribute(new CustomPropertyGetAttribute(new Getter)); + pi->addAttribute(new CustomPropertySetAttribute(new Setter)); + pi->addAttribute(new CustomPropertyCountAttribute(new Counter)); + pi->addAttribute(new CustomPropertyAddAttribute(new Adder)); + pi->addAttribute(new CustomPropertyRemoveAttribute(new Remover)); if (typeid(VT).before(typeid(typename T::value_type)) || typeid(typename T::value_type).before(typeid(VT))) @@ -254,12 +486,25 @@ namespace osgIntrospection template struct StdMapReflector: ValueReflector { + typedef typename ValueReflector::instance_creator_type instance_creator_type; + + typedef typename T::iterator iterator; typedef typename T::const_iterator const_iterator; typedef typename T::key_type key_type; typedef typename T::mapped_type mapped_type; struct Getter: PropertyGetter { + virtual Value get(Value &instance, const ValueList &indices) const + { + T& ctr = variant_cast(instance); + const key_type& key = variant_cast(indices.front()); + + iterator i = ctr.find(key); + if (i == ctr.end()) return Value(); + return i->second; + } + virtual Value get(const Value &instance, const ValueList &indices) const { const T& ctr = variant_cast(instance); @@ -301,7 +546,7 @@ namespace osgIntrospection return params_; } - virtual void getIndexValueSet(int whichindex, const Value &instance, ValueList &values) const + virtual void getIndexValueSet(int /*whichindex*/, const Value &instance, ValueList &values) const { const T &ctr = variant_cast(instance); for (const_iterator i=ctr.begin(); @@ -315,7 +560,9 @@ namespace osgIntrospection StdMapReflector(const std::string &name): ValueReflector(name) { - PropertyInfo *pi = new PropertyInfo(typeof(T), typeof(typename T::value_type), "Items", 0, 0); + addConstructor(new TypedConstructorInfo0(ParameterInfoList())); + + PropertyInfo *pi = new PropertyInfo(typeof(T), typeof(typename T::mapped_type), "Items", 0, 0); pi->addAttribute(new CustomPropertyGetAttribute(new Getter)); pi->addAttribute(new CustomPropertySetAttribute(new Setter)); pi->addAttribute(new CustomIndexAttribute(new Indexer)); @@ -333,11 +580,23 @@ namespace osgIntrospection template struct StdPairReflector: ValueReflector { + typedef typename ValueReflector::instance_creator_type instance_creator_type; + struct Accessor: PropertyGetter, PropertySetter { Accessor(int i): i_(i) {} virtual Value get(const Value &instance) const + { + switch (i_) + { + case 0: return variant_cast(instance).first; + case 1: return variant_cast(instance).second; + default: return Value(); + } + } + + virtual Value get(Value &instance) const { switch (i_) { @@ -363,6 +622,8 @@ namespace osgIntrospection StdPairReflector(const std::string &name): ValueReflector(name) { + addConstructor(new TypedConstructorInfo0(ParameterInfoList())); + PropertyInfo *pi1 = new PropertyInfo(typeof(T), typeof(typename T::first_type), "first", 0, 0); pi1->addAttribute(new CustomPropertyGetAttribute(new Accessor(0))); pi1->addAttribute(new CustomPropertySetAttribute(new Accessor(0))); @@ -389,30 +650,31 @@ namespace osgIntrospection // TEMPLATE METHODS template - Reflector::Reflector(const std::string &name, const std::string &ns, const ReaderWriter *rw) - : type_(Reflection::registerOrReplaceType(typeid(T))) + Reflector::Reflector(const std::string &name, const std::string &ns, bool abstract) + : type_(Reflection::getOrRegisterType(typeid(T), true)) { - type_->name_ = name; - type_->namespace_ = ns; - type_->rw_ = rw; - init(); + if (!type_->name_.empty()) + type_->aliases_.push_back(ns.empty()? purify(name): purify(ns+"::"+name)); + else + { + type_->name_ = purify(name); + type_->namespace_ = purify(ns); + } + type_->is_abstract_ = abstract; + init(); } template - Reflector::Reflector(const std::string &qname, const ReaderWriter *rw) - : type_(Reflection::registerOrReplaceType(typeid(T))) + Reflector::Reflector(const std::string &qname, bool abstract) + : type_(Reflection::getOrRegisterType(typeid(T), true)) { - std::string::size_type p = qname.rfind("::"); - if (p != std::string::npos) - { - type_->namespace_ = qname.substr(0, p); - type_->name_ = qname.substr(p+2); - } - else - { - type_->name_ = qname; - } - type_->rw_ = rw; + if (!type_->name_.empty()) + type_->aliases_.push_back(purify(qname)); + else + { + split_qualified_name(purify(qname), type_->name_, type_->namespace_); + } + type_->is_abstract_ = abstract; init(); } @@ -422,30 +684,73 @@ namespace osgIntrospection // pointer type if (!type_->pointed_type_) { - Type *ptype = Reflection::registerOrReplaceType(typeid(T*)); + Type *ptype = Reflection::getOrRegisterType(typeid(T*), true); ptype->name_ = type_->name_; ptype->namespace_ = type_->namespace_; ptype->pointed_type_ = type_; ptype->is_defined_ = true; - ptype->set_instance_creator(new ValueInstanceCreator); + ptype->cons_.push_back(new PtrConstructor(ptype)); ptype->rw_ = new PtrReaderWriter(); + ptype->cmp_ = new TotalOrderComparator(); } // const pointer type if (!type_->pointed_type_ || !type_->is_const_) { - Type *cptype = Reflection::registerOrReplaceType(typeid(const T*)); + Type *cptype = Reflection::getOrRegisterType(typeid(const T*), true); cptype->name_ = type_->name_; cptype->namespace_ = type_->namespace_; cptype->is_const_ = true; cptype->pointed_type_ = type_; cptype->is_defined_ = true; - cptype->set_instance_creator(new ValueInstanceCreator); + cptype->cons_.push_back(new ConstPtrConstructor(cptype)); cptype->rw_ = new PtrReaderWriter(); + cptype->cmp_ = new TotalOrderComparator(); } type_->is_defined_ = true; } + + template + std::string Reflector::purify(const std::string &s) + { + std::string r(s); + while (true) + { + std::string::size_type p = r.find(" COMMA "); + if (p == std::string::npos) break; + r.replace(p, 7, ", "); + }; + return r; + } + + template + void Reflector::split_qualified_name(const std::string &q, std::string &n, std::string &ns) + { + int templ = 0; + std::string::size_type split_point = std::string::npos; + std::string::size_type j = 0; + for (std::string::const_iterator i=q.begin(); i!=q.end(); ++i, ++j) + { + if (*i == '<') ++templ; + if (*i == '>') --templ; + if (templ == 0) + { + if (*i == ':' && (i+1)!=q.end() && *(i+1) == ':') + split_point = j; + } + } + if (split_point == std::string::npos) + { + ns.clear(); + n = q; + } + else + { + n = q.substr(split_point+2); + ns = q.substr(0, split_point); + } + } template void Reflector::addBaseType(const Type &type) @@ -463,6 +768,13 @@ namespace osgIntrospection template MethodInfo *Reflector::addMethod(MethodInfo *mi) { + for (TempMethodList::iterator i=temp_methods_.begin(); i!=temp_methods_.end(); ++i) + { + if (mi->overrides(*i)) + return *i; + } + + temp_methods_.push_back(mi); type_->methods_.push_back(mi); return mi; } @@ -483,9 +795,10 @@ namespace osgIntrospection } template - void Reflector::setInstanceCreator(const InstanceCreatorBase *icb) + ConstructorInfo *Reflector::addConstructor(ConstructorInfo *ci) { - type_->set_instance_creator(icb); + type_->cons_.push_back(ci); + return ci; } template @@ -517,6 +830,12 @@ namespace osgIntrospection { type_->rw_ = rw; } + + template + void Reflector::setComparator(const Comparator *cmp) + { + type_->cmp_ = cmp; + } } diff --git a/include/osgIntrospection/StaticMethodInfo b/include/osgIntrospection/StaticMethodInfo new file mode 100644 index 000000000..85760cad4 --- /dev/null +++ b/include/osgIntrospection/StaticMethodInfo @@ -0,0 +1,1209 @@ +#ifndef OSGINTROSPECTION_STATICMETHODINFO_ +#define OSGINTROSPECTION_STATICMETHODINFO_ + +#include +#include +#include + +namespace osgIntrospection +{ + + /// Class templates StaticMethodInfoN (where 0 <= N <= 16) are concrete + /// implementations of MethodInfo. They are used to keep information + /// about static class methods and to provide the means for calling them + /// dynamically. Each class template can handle methods with N arguments + /// and is parametrized by the class that declares the method and by the + /// return type. Both const and non-const methods are supported. + /// The invoke() methods allow to call the reflected method dynamically, + /// passing it the arguments as a list of Value objects. + /// + template + class StaticMethodInfo0: public MethodInfo + { + public: + typedef R (*FunctionType)(); + + StaticMethodInfo0(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList & /*args*/) const + { + + if (f_) return (*f_)(); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo1: public MethodInfo + { + public: + typedef R (*FunctionType)(P0); + + StaticMethodInfo1(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(1); + convertArgument(args, newargs, getParameters(), 0); + + if (f_) return (*f_)(variant_cast(newargs[0])); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo2: public MethodInfo + { + public: + typedef R (*FunctionType)(P0, P1); + + StaticMethodInfo2(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(2); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1])); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo3: public MethodInfo + { + public: + typedef R (*FunctionType)(P0, P1, P2); + + StaticMethodInfo3(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(3); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo4: public MethodInfo + { + public: + typedef R (*FunctionType)(P0, P1, P2, P3); + + StaticMethodInfo4(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(4); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo5: public MethodInfo + { + public: + typedef R (*FunctionType)(P0, P1, P2, P3, P4); + + StaticMethodInfo5(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(5); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo6: public MethodInfo + { + public: + typedef R (*FunctionType)(P0, P1, P2, P3, P4, P5); + + StaticMethodInfo6(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(6); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo7: public MethodInfo + { + public: + typedef R (*FunctionType)(P0, P1, P2, P3, P4, P5, P6); + + StaticMethodInfo7(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(7); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo8: public MethodInfo + { + public: + typedef R (*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7); + + StaticMethodInfo8(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(8); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo9: public MethodInfo + { + public: + typedef R (*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8); + + StaticMethodInfo9(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(9); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo10: public MethodInfo + { + public: + typedef R (*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9); + + StaticMethodInfo10(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(10); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo11: public MethodInfo + { + public: + typedef R (*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10); + + StaticMethodInfo11(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(11); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo12: public MethodInfo + { + public: + typedef R (*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11); + + StaticMethodInfo12(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(12); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo13: public MethodInfo + { + public: + typedef R (*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12); + + StaticMethodInfo13(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(13); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo14: public MethodInfo + { + public: + typedef R (*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13); + + StaticMethodInfo14(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(14); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo15: public MethodInfo + { + public: + typedef R (*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14); + + StaticMethodInfo15(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(15); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + convertArgument(args, newargs, getParameters(), 14); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo16: public MethodInfo + { + public: + typedef R (*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15); + + StaticMethodInfo16(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(16); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + convertArgument(args, newargs, getParameters(), 14); + convertArgument(args, newargs, getParameters(), 15); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo0: public MethodInfo + { + public: + typedef void (*FunctionType)(); + + StaticMethodInfo0(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList & /*args*/) const + { + + if (f_) return (*f_)(), Value(); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo1: public MethodInfo + { + public: + typedef void (*FunctionType)(P0); + + StaticMethodInfo1(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(1); + convertArgument(args, newargs, getParameters(), 0); + + if (f_) return (*f_)(variant_cast(newargs[0])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo2: public MethodInfo + { + public: + typedef void (*FunctionType)(P0, P1); + + StaticMethodInfo2(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(2); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo3: public MethodInfo + { + public: + typedef void (*FunctionType)(P0, P1, P2); + + StaticMethodInfo3(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(3); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo4: public MethodInfo + { + public: + typedef void (*FunctionType)(P0, P1, P2, P3); + + StaticMethodInfo4(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(4); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo5: public MethodInfo + { + public: + typedef void (*FunctionType)(P0, P1, P2, P3, P4); + + StaticMethodInfo5(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(5); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo6: public MethodInfo + { + public: + typedef void (*FunctionType)(P0, P1, P2, P3, P4, P5); + + StaticMethodInfo6(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(6); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo7: public MethodInfo + { + public: + typedef void (*FunctionType)(P0, P1, P2, P3, P4, P5, P6); + + StaticMethodInfo7(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(7); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo8: public MethodInfo + { + public: + typedef void (*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7); + + StaticMethodInfo8(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(8); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo9: public MethodInfo + { + public: + typedef void (*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8); + + StaticMethodInfo9(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(9); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo10: public MethodInfo + { + public: + typedef void (*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9); + + StaticMethodInfo10(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(10); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo11: public MethodInfo + { + public: + typedef void (*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10); + + StaticMethodInfo11(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(11); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo12: public MethodInfo + { + public: + typedef void (*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11); + + StaticMethodInfo12(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(12); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo13: public MethodInfo + { + public: + typedef void (*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12); + + StaticMethodInfo13(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(13); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo14: public MethodInfo + { + public: + typedef void (*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13); + + StaticMethodInfo14(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(14); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo15: public MethodInfo + { + public: + typedef void (*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14); + + StaticMethodInfo15(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(15); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + convertArgument(args, newargs, getParameters(), 14); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + + + template + class StaticMethodInfo16: public MethodInfo + { + public: + typedef void (*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15); + + StaticMethodInfo16(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), f_(f) + { + } + + bool isConst() const { return false; } + bool isStatic() const { return true; } + + Value invoke(ValueList &args) const + { + ValueList newargs(16); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + convertArgument(args, newargs, getParameters(), 14); + convertArgument(args, newargs, getParameters(), 15); + + if (f_) return (*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + FunctionType f_; + }; + +} + +#endif diff --git a/include/osgIntrospection/Type b/include/osgIntrospection/Type index f9a4f0167..fdd7cf72e 100644 --- a/include/osgIntrospection/Type +++ b/include/osgIntrospection/Type @@ -10,6 +10,7 @@ #include #include #include +#include namespace osgIntrospection { @@ -19,49 +20,18 @@ namespace osgIntrospection class PropertyInfo; class ParameterInfo; class ReaderWriter; + class ConstructorInfo; + struct Comparator; // typedefs for member info lists typedef std::vector MethodInfoList; typedef std::vector PropertyInfoList; typedef std::vector ParameterInfoList; + typedef std::vector ConstructorInfoList; // typedef for enum label map typedef std::map EnumLabelMap; - /// Base class for instance creators. An instance creator is - /// a lightweight object that creates a Value containing an - /// instance of some type. Every non-abstract Type object has - /// an instance creator that creates instances of that type. - /// This is an abstract interface, it must be derived to - /// provide the actual implementation of createInstance(). - struct InstanceCreatorBase - { - virtual Value createInstance() const = 0; - }; - - /// This is an instance creator to be used with types that ought to - /// be created on the heap, for example all classes derived from - /// osg::Referenced. - template - struct InstanceCreator: public InstanceCreatorBase - { - Value createInstance() const - { - return new T(); - } - }; - - /// This is an instance creator to be used with types that can be - /// created on the stack (for example: int, std::string, or other - /// possibly small user-defined structs or classes). - template - struct ValueInstanceCreator: public InstanceCreatorBase - { - Value createInstance() const - { - return T(); - } - }; /// Objects of class Type are used to maintain information about /// reflected types. They also provide a number of services, like @@ -96,6 +66,10 @@ namespace osgIntrospection /// name is formed by the namespace, if present, plus other modifiers /// like 'const' and/or '*' (pointer) where applicable. inline std::string getQualifiedName() const; + + /// Returns true if either the fully-qualified name or one of the + /// name aliases match the given argument + inline bool matchesName(const std::string &name) const; /// Returns the number of base types. /// This number is zero if the type is not derived from any other @@ -104,6 +78,12 @@ namespace osgIntrospection /// Returns the i-th base type. inline const Type &getBaseType(int i) const; + + /// Returns the number of type name aliases. + inline int getNumAliases() const; + + /// Returns the i-th name alias + const std::string &getAlias(int i) const; /// Returns whether the reflected type is abstract. inline bool isAbstract() const; @@ -140,6 +120,9 @@ namespace osgIntrospection /// Fills a list of properties that are either defined in this Type /// or in inherited types. void getAllProperties(PropertyInfoList &props) const; + + /// Returns the list of constructors defined for this type. + inline const ConstructorInfoList &getConstructors() const; /// Returns the list of methods defined for this type. The list /// does not include methods inherited from base types. @@ -153,6 +136,16 @@ namespace osgIntrospection /// enumeration, an empty map is returned. inline const EnumLabelMap &getEnumLabels() const; + /// Searches for a constructor that can be called with the given list + /// of arguments without raising type conversion errors. If more than + /// one constructors are suitable for calling, the best match is + /// returned. + const ConstructorInfo *getCompatibleConstructor(const ValueList &values) const; + + /// Searches for a constructor whose parameters match exactly the given + /// list of parameter descriptions. + const ConstructorInfo *getConstructor(const ParameterInfoList ¶ms) const; + /// Searches for a method that can be called with the given list of /// arguments without raising type conversion errors. If more than /// one method are suitable for calling, the best match is returned. @@ -180,20 +173,26 @@ namespace osgIntrospection /// Returns the instance of the reader/writer object assigned to /// this type, if any. Otherwise it returns the null pointer. inline const ReaderWriter *getReaderWriter() const; + + /// Returns the instance of the comparator object assigned to + /// this type, if any. Otherwise it returns the null pointer. + inline const Comparator *getComparator() const; /// Creates an instance of the reflected type. The returned Value /// can be casted to T*, where T is the reflected type. If the type /// is abstract, an exception is thrown. + Value createInstance(ValueList &args) const; inline Value createInstance() const; protected: Type(const std::type_info &ti) : ti_(ti), is_const_(false), + is_abstract_(false), pointed_type_(0), is_defined_(false), - icb_(0), - rw_(0) + rw_(0), + cmp_(0) { } @@ -202,14 +201,9 @@ namespace osgIntrospection virtual void getInheritedProviders(CustomAttributeProviderList &providers) const; - void set_instance_creator(const InstanceCreatorBase *icb) - { - delete icb_; - icb_ = icb; - } - private: template friend class Reflector; + template friend struct TypeNameAliasProxy; friend class Reflection; Type(const Type ©): CustomAttributeProvider(copy), ti_(copy.ti_) {} @@ -223,16 +217,21 @@ namespace osgIntrospection TypeList base_; bool is_const_; + bool is_abstract_; const Type *pointed_type_; + ConstructorInfoList cons_; PropertyInfoList props_; MethodInfoList methods_; EnumLabelMap labels_; bool is_defined_; - const InstanceCreatorBase *icb_; const ReaderWriter *rw_; + const Comparator *cmp_; + + typedef std::vector AliasList; + AliasList aliases_; }; // OPERATORS @@ -326,7 +325,7 @@ namespace osgIntrospection inline bool Type::isAbstract() const { check_defined(); - return icb_ == 0; + return is_abstract_; } inline bool Type::isAtomic() const @@ -340,6 +339,12 @@ namespace osgIntrospection check_defined(); return props_; } + + inline const ConstructorInfoList &Type::getConstructors() const + { + check_defined(); + return cons_; + } inline const MethodInfoList &Type::getMethods() const { @@ -389,6 +394,12 @@ namespace osgIntrospection return rw_; } + inline const Comparator *Type::getComparator() const + { + check_defined(); + return cmp_; + } + inline const Type &Type::getBaseType(int i) const { check_defined(); @@ -397,10 +408,27 @@ namespace osgIntrospection inline Value Type::createInstance() const { - check_defined(); - if (!icb_) - throw TypeIsAbstractException(ti_); - return icb_->createInstance(); + ValueList args; + return createInstance(args); + } + + inline int Type::getNumAliases() const + { + return static_cast(aliases_.size()); + } + + inline const std::string &Type::getAlias(int i) const + { + return aliases_[i]; + } + + inline bool Type::matchesName(const std::string &name) const + { + if (getQualifiedName() == name) + return true; + if (std::find(aliases_.begin(), aliases_.end(), name) != aliases_.end()) + return true; + return false; } } diff --git a/include/osgIntrospection/TypeNameAliasProxy b/include/osgIntrospection/TypeNameAliasProxy new file mode 100644 index 000000000..4e1867e24 --- /dev/null +++ b/include/osgIntrospection/TypeNameAliasProxy @@ -0,0 +1,26 @@ +#ifndef OSGINTROSPECTION_TYPENAMEALIASPROXY_ +#define OSGINTROSPECTION_TYPENAMEALIASPROXY_ + +#include +#include + +#include +#include + +namespace osgIntrospection +{ + + template + struct TypeNameAliasProxy + { + TypeNameAliasProxy(const std::string &name) + { + Type *type = Reflection::getOrRegisterType(typeid(C)); + if (std::find(type->aliases_.begin(), type->aliases_.end(), name) == type->aliases_.end()) + type->aliases_.push_back(name); + } + }; + +} + +#endif diff --git a/include/osgIntrospection/TypedConstructorInfo b/include/osgIntrospection/TypedConstructorInfo new file mode 100644 index 000000000..c56ce2a86 --- /dev/null +++ b/include/osgIntrospection/TypedConstructorInfo @@ -0,0 +1,454 @@ +#ifndef OSGINTROSPECTION_TYPEDCONSTRUCTORINFO_ +#define OSGINTROSPECTION_TYPEDCONSTRUCTORINFO_ + +#include +#include +#include + +namespace osgIntrospection +{ + + template + struct TypedConstructorInfo0: ConstructorInfo + { + TypedConstructorInfo0(const ParameterInfoList &plist) + : ConstructorInfo(typeof(C), plist) + { + } + + Value createInstance(ValueList & /*args*/) const + { + + return IC::create(); + } + + }; + + + template + struct TypedConstructorInfo1: ConstructorInfo + { + TypedConstructorInfo1(const ParameterInfoList &plist) + : ConstructorInfo(typeof(C), plist) + { + } + + Value createInstance(ValueList &args) const + { + ValueList newargs(1); + convertArgument(args, newargs, getParameters(), 0); + + return IC::template create(newargs[0]); + } + + }; + + + template + struct TypedConstructorInfo2: ConstructorInfo + { + TypedConstructorInfo2(const ParameterInfoList &plist) + : ConstructorInfo(typeof(C), plist) + { + } + + Value createInstance(ValueList &args) const + { + ValueList newargs(2); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + + return IC::template create(newargs[0], newargs[1]); + } + + }; + + + template + struct TypedConstructorInfo3: ConstructorInfo + { + TypedConstructorInfo3(const ParameterInfoList &plist) + : ConstructorInfo(typeof(C), plist) + { + } + + Value createInstance(ValueList &args) const + { + ValueList newargs(3); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + + return IC::template create(newargs[0], newargs[1], newargs[2]); + } + + }; + + + template + struct TypedConstructorInfo4: ConstructorInfo + { + TypedConstructorInfo4(const ParameterInfoList &plist) + : ConstructorInfo(typeof(C), plist) + { + } + + Value createInstance(ValueList &args) const + { + ValueList newargs(4); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + + return IC::template create(newargs[0], newargs[1], newargs[2], newargs[3]); + } + + }; + + + template + struct TypedConstructorInfo5: ConstructorInfo + { + TypedConstructorInfo5(const ParameterInfoList &plist) + : ConstructorInfo(typeof(C), plist) + { + } + + Value createInstance(ValueList &args) const + { + ValueList newargs(5); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + + return IC::template create(newargs[0], newargs[1], newargs[2], newargs[3], newargs[4]); + } + + }; + + + template + struct TypedConstructorInfo6: ConstructorInfo + { + TypedConstructorInfo6(const ParameterInfoList &plist) + : ConstructorInfo(typeof(C), plist) + { + } + + Value createInstance(ValueList &args) const + { + ValueList newargs(6); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + + return IC::template create(newargs[0], newargs[1], newargs[2], newargs[3], newargs[4], newargs[5]); + } + + }; + + + template + struct TypedConstructorInfo7: ConstructorInfo + { + TypedConstructorInfo7(const ParameterInfoList &plist) + : ConstructorInfo(typeof(C), plist) + { + } + + Value createInstance(ValueList &args) const + { + ValueList newargs(7); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + + return IC::template create(newargs[0], newargs[1], newargs[2], newargs[3], newargs[4], newargs[5], newargs[6]); + } + + }; + + + template + struct TypedConstructorInfo8: ConstructorInfo + { + TypedConstructorInfo8(const ParameterInfoList &plist) + : ConstructorInfo(typeof(C), plist) + { + } + + Value createInstance(ValueList &args) const + { + ValueList newargs(8); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + + return IC::template create(newargs[0], newargs[1], newargs[2], newargs[3], newargs[4], newargs[5], newargs[6], newargs[7]); + } + + }; + + + template + struct TypedConstructorInfo9: ConstructorInfo + { + TypedConstructorInfo9(const ParameterInfoList &plist) + : ConstructorInfo(typeof(C), plist) + { + } + + Value createInstance(ValueList &args) const + { + ValueList newargs(9); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + + return IC::template create(newargs[0], newargs[1], newargs[2], newargs[3], newargs[4], newargs[5], newargs[6], newargs[7], newargs[8]); + } + + }; + + + template + struct TypedConstructorInfo10: ConstructorInfo + { + TypedConstructorInfo10(const ParameterInfoList &plist) + : ConstructorInfo(typeof(C), plist) + { + } + + Value createInstance(ValueList &args) const + { + ValueList newargs(10); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + + return IC::template create(newargs[0], newargs[1], newargs[2], newargs[3], newargs[4], newargs[5], newargs[6], newargs[7], newargs[8], newargs[9]); + } + + }; + + + template + struct TypedConstructorInfo11: ConstructorInfo + { + TypedConstructorInfo11(const ParameterInfoList &plist) + : ConstructorInfo(typeof(C), plist) + { + } + + Value createInstance(ValueList &args) const + { + ValueList newargs(11); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + + return IC::template create(newargs[0], newargs[1], newargs[2], newargs[3], newargs[4], newargs[5], newargs[6], newargs[7], newargs[8], newargs[9], newargs[10]); + } + + }; + + + template + struct TypedConstructorInfo12: ConstructorInfo + { + TypedConstructorInfo12(const ParameterInfoList &plist) + : ConstructorInfo(typeof(C), plist) + { + } + + Value createInstance(ValueList &args) const + { + ValueList newargs(12); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + + return IC::template create(newargs[0], newargs[1], newargs[2], newargs[3], newargs[4], newargs[5], newargs[6], newargs[7], newargs[8], newargs[9], newargs[10], newargs[11]); + } + + }; + + + template + struct TypedConstructorInfo13: ConstructorInfo + { + TypedConstructorInfo13(const ParameterInfoList &plist) + : ConstructorInfo(typeof(C), plist) + { + } + + Value createInstance(ValueList &args) const + { + ValueList newargs(13); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + + return IC::template create(newargs[0], newargs[1], newargs[2], newargs[3], newargs[4], newargs[5], newargs[6], newargs[7], newargs[8], newargs[9], newargs[10], newargs[11], newargs[12]); + } + + }; + + + template + struct TypedConstructorInfo14: ConstructorInfo + { + TypedConstructorInfo14(const ParameterInfoList &plist) + : ConstructorInfo(typeof(C), plist) + { + } + + Value createInstance(ValueList &args) const + { + ValueList newargs(14); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + + return IC::template create(newargs[0], newargs[1], newargs[2], newargs[3], newargs[4], newargs[5], newargs[6], newargs[7], newargs[8], newargs[9], newargs[10], newargs[11], newargs[12], newargs[13]); + } + + }; + + + template + struct TypedConstructorInfo15: ConstructorInfo + { + TypedConstructorInfo15(const ParameterInfoList &plist) + : ConstructorInfo(typeof(C), plist) + { + } + + Value createInstance(ValueList &args) const + { + ValueList newargs(15); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + convertArgument(args, newargs, getParameters(), 14); + + return IC::template create(newargs[0], newargs[1], newargs[2], newargs[3], newargs[4], newargs[5], newargs[6], newargs[7], newargs[8], newargs[9], newargs[10], newargs[11], newargs[12], newargs[13], newargs[14]); + } + + }; + + + template + struct TypedConstructorInfo16: ConstructorInfo + { + TypedConstructorInfo16(const ParameterInfoList &plist) + : ConstructorInfo(typeof(C), plist) + { + } + + Value createInstance(ValueList &args) const + { + ValueList newargs(16); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + convertArgument(args, newargs, getParameters(), 14); + convertArgument(args, newargs, getParameters(), 15); + + return IC::template create(newargs[0], newargs[1], newargs[2], newargs[3], newargs[4], newargs[5], newargs[6], newargs[7], newargs[8], newargs[9], newargs[10], newargs[11], newargs[12], newargs[13], newargs[14], newargs[15]); + } + + }; + +} + +#endif + diff --git a/include/osgIntrospection/TypedMethodInfo b/include/osgIntrospection/TypedMethodInfo index 6e39cd931..2bd4681f1 100644 --- a/include/osgIntrospection/TypedMethodInfo +++ b/include/osgIntrospection/TypedMethodInfo @@ -3,6 +3,7 @@ #include #include +#include namespace osgIntrospection { @@ -28,2759 +29,2924 @@ namespace osgIntrospection /// a class' method on another class' instance, but of course that's a /// bad, bad idea... /// - template - class TypedMethodInfo0: public MethodInfo - { - public: - typedef R (C::*ConstFunctionType)() const; - typedef R (C::*FunctionType)(); - - TypedMethodInfo0(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo0(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(); - if (f_) return (variant_cast(instance)->*f_)(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(); - if (f_) return (variant_cast(instance)->*f_)(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(); - if (f_) return (variant_cast(instance).*f_)(); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo1: public MethodInfo - { - public: - typedef R (C::*ConstFunctionType)(P0) const; - typedef R (C::*FunctionType)(P0); - - TypedMethodInfo1(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo1(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0)); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0)); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo2: public MethodInfo - { - public: - typedef R (C::*ConstFunctionType)(P0, P1) const; - typedef R (C::*FunctionType)(P0, P1); - - TypedMethodInfo2(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo2(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1)); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1)); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo3: public MethodInfo - { - public: - typedef R (C::*ConstFunctionType)(P0, P1, P2) const; - typedef R (C::*FunctionType)(P0, P1, P2); - - TypedMethodInfo3(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo3(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2)); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2)); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo4: public MethodInfo - { - public: - typedef R (C::*ConstFunctionType)(P0, P1, P2, P3) const; - typedef R (C::*FunctionType)(P0, P1, P2, P3); - - TypedMethodInfo4(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo4(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo5: public MethodInfo - { - public: - typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4) const; - typedef R (C::*FunctionType)(P0, P1, P2, P3, P4); - - TypedMethodInfo5(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo5(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo6: public MethodInfo - { - public: - typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5) const; - typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5); - - TypedMethodInfo6(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo6(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo7: public MethodInfo - { - public: - typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6) const; - typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6); - - TypedMethodInfo7(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo7(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo8: public MethodInfo - { - public: - typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7) const; - typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7); - - TypedMethodInfo8(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo8(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo9: public MethodInfo - { - public: - typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8) const; - typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8); - - TypedMethodInfo9(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo9(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo10: public MethodInfo - { - public: - typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) const; - typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9); - - TypedMethodInfo10(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo10(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo11: public MethodInfo - { - public: - typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) const; - typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10); - - TypedMethodInfo11(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo11(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo12: public MethodInfo - { - public: - typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) const; - typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11); - - TypedMethodInfo12(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo12(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo13: public MethodInfo - { - public: - typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) const; - typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12); - - TypedMethodInfo13(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo13(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - Value a12(args[12].convertTo(typeof(P12))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - Value a12(args[12].convertTo(typeof(P12))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo14: public MethodInfo - { - public: - typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) const; - typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13); - - TypedMethodInfo14(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo14(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - Value a12(args[12].convertTo(typeof(P12))); - Value a13(args[13].convertTo(typeof(P13))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - Value a12(args[12].convertTo(typeof(P12))); - Value a13(args[13].convertTo(typeof(P13))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo15: public MethodInfo - { - public: - typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) const; - typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14); - - TypedMethodInfo15(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo15(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - Value a12(args[12].convertTo(typeof(P12))); - Value a13(args[13].convertTo(typeof(P13))); - Value a14(args[14].convertTo(typeof(P14))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - Value a12(args[12].convertTo(typeof(P12))); - Value a13(args[13].convertTo(typeof(P13))); - Value a14(args[14].convertTo(typeof(P14))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo16: public MethodInfo - { - public: - typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) const; - typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15); - - TypedMethodInfo16(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo16(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - Value a12(args[12].convertTo(typeof(P12))); - Value a13(args[13].convertTo(typeof(P13))); - Value a14(args[14].convertTo(typeof(P14))); - Value a15(args[15].convertTo(typeof(P15))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - Value a12(args[12].convertTo(typeof(P12))); - Value a13(args[13].convertTo(typeof(P13))); - Value a14(args[14].convertTo(typeof(P14))); - Value a15(args[15].convertTo(typeof(P15))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo0: public MethodInfo - { - public: - typedef void (C::*ConstFunctionType)() const; - typedef void (C::*FunctionType)(); - - TypedMethodInfo0(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo0(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(), Value(); - if (f_) return (variant_cast(instance)->*f_)(), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(), Value(); - if (f_) return (variant_cast(instance)->*f_)(), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(), Value(); - if (f_) return (variant_cast(instance).*f_)(), Value(); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo1: public MethodInfo - { - public: - typedef void (C::*ConstFunctionType)(P0) const; - typedef void (C::*FunctionType)(P0); - - TypedMethodInfo1(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo1(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0)), Value(); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0)), Value(); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo2: public MethodInfo - { - public: - typedef void (C::*ConstFunctionType)(P0, P1) const; - typedef void (C::*FunctionType)(P0, P1); - - TypedMethodInfo2(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo2(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1)), Value(); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1)), Value(); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo3: public MethodInfo - { - public: - typedef void (C::*ConstFunctionType)(P0, P1, P2) const; - typedef void (C::*FunctionType)(P0, P1, P2); - - TypedMethodInfo3(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo3(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2)), Value(); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2)), Value(); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo4: public MethodInfo - { - public: - typedef void (C::*ConstFunctionType)(P0, P1, P2, P3) const; - typedef void (C::*FunctionType)(P0, P1, P2, P3); - - TypedMethodInfo4(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo4(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)), Value(); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3)), Value(); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo5: public MethodInfo - { - public: - typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4) const; - typedef void (C::*FunctionType)(P0, P1, P2, P3, P4); - - TypedMethodInfo5(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo5(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)), Value(); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4)), Value(); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo6: public MethodInfo - { - public: - typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5) const; - typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5); - - TypedMethodInfo6(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo6(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)), Value(); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5)), Value(); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo7: public MethodInfo - { - public: - typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6) const; - typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6); - - TypedMethodInfo7(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo7(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)), Value(); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6)), Value(); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo8: public MethodInfo - { - public: - typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7) const; - typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7); - - TypedMethodInfo8(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo8(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)), Value(); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7)), Value(); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo9: public MethodInfo - { - public: - typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8) const; - typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8); - - TypedMethodInfo9(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo9(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)), Value(); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8)), Value(); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo10: public MethodInfo - { - public: - typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) const; - typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9); - - TypedMethodInfo10(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo10(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)), Value(); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9)), Value(); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo11: public MethodInfo - { - public: - typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) const; - typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10); - - TypedMethodInfo11(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo11(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)), Value(); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10)), Value(); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo12: public MethodInfo - { - public: - typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) const; - typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11); - - TypedMethodInfo12(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo12(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)), Value(); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11)), Value(); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo13: public MethodInfo - { - public: - typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) const; - typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12); - - TypedMethodInfo13(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo13(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - Value a12(args[12].convertTo(typeof(P12))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - Value a12(args[12].convertTo(typeof(P12))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)), Value(); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12)), Value(); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo14: public MethodInfo - { - public: - typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) const; - typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13); - - TypedMethodInfo14(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo14(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - Value a12(args[12].convertTo(typeof(P12))); - Value a13(args[13].convertTo(typeof(P13))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - Value a12(args[12].convertTo(typeof(P12))); - Value a13(args[13].convertTo(typeof(P13))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)), Value(); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13)), Value(); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo15: public MethodInfo - { - public: - typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) const; - typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14); - - TypedMethodInfo15(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo15(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - Value a12(args[12].convertTo(typeof(P12))); - Value a13(args[13].convertTo(typeof(P13))); - Value a14(args[14].convertTo(typeof(P14))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - Value a12(args[12].convertTo(typeof(P12))); - Value a13(args[13].convertTo(typeof(P13))); - Value a14(args[14].convertTo(typeof(P14))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)), Value(); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14)), Value(); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - - - template - class TypedMethodInfo16: public MethodInfo - { - public: - typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) const; - typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15); - - TypedMethodInfo16(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) - { - } - - TypedMethodInfo16(const std::string &qname, FunctionType f, const ParameterInfoList &plist) - : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) - { - } - - bool isConst() const { return cf_; } - - Value invoke(const Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - Value a12(args[12].convertTo(typeof(P12))); - Value a13(args[13].convertTo(typeof(P13))); - Value a14(args[14].convertTo(typeof(P14))); - Value a15(args[15].convertTo(typeof(P15))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - - Value invoke(Value &instance, ValueList &args) const - { - Value a0(args[0].convertTo(typeof(P0))); - Value a1(args[1].convertTo(typeof(P1))); - Value a2(args[2].convertTo(typeof(P2))); - Value a3(args[3].convertTo(typeof(P3))); - Value a4(args[4].convertTo(typeof(P4))); - Value a5(args[5].convertTo(typeof(P5))); - Value a6(args[6].convertTo(typeof(P6))); - Value a7(args[7].convertTo(typeof(P7))); - Value a8(args[8].convertTo(typeof(P8))); - Value a9(args[9].convertTo(typeof(P9))); - Value a10(args[10].convertTo(typeof(P10))); - Value a11(args[11].convertTo(typeof(P11))); - Value a12(args[12].convertTo(typeof(P12))); - Value a13(args[13].convertTo(typeof(P13))); - Value a14(args[14].convertTo(typeof(P14))); - Value a15(args[15].convertTo(typeof(P15))); - const Type &type = instance.getType(); - if (type.isPointer()) - { - if (type.isConstPointer()) - { - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)), Value(); - if (f_) throw ConstIsConstException(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)), Value(); - if (f_) return (variant_cast(instance)->*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)), Value(); - throw InvalidFunctionPointerException(); - } - if (cf_) return (variant_cast(instance).*cf_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)), Value(); - if (f_) return (variant_cast(instance).*f_)(variant_cast(a0), variant_cast(a1), variant_cast(a2), variant_cast(a3), variant_cast(a4), variant_cast(a5), variant_cast(a6), variant_cast(a7), variant_cast(a8), variant_cast(a9), variant_cast(a10), variant_cast(a11), variant_cast(a12), variant_cast(a13), variant_cast(a14), variant_cast(a15)), Value(); - throw InvalidFunctionPointerException(); - } - - private: - ConstFunctionType cf_; - FunctionType f_; - }; - + template + class TypedMethodInfo0: public MethodInfo + { + public: + typedef R (C::*ConstFunctionType)() const; + typedef R (C::*FunctionType)(); + + TypedMethodInfo0(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo0(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList & /*args*/) const + { + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(); + if (f_) return (variant_cast(instance)->*f_)(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList & /*args*/) const + { + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(); + if (f_) return (variant_cast(instance)->*f_)(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(); + if (f_) return (variant_cast(instance).*f_)(); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo1: public MethodInfo + { + public: + typedef R (C::*ConstFunctionType)(P0) const; + typedef R (C::*FunctionType)(P0); + + TypedMethodInfo1(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo1(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(1); + convertArgument(args, newargs, getParameters(), 0); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(1); + convertArgument(args, newargs, getParameters(), 0); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0])); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0])); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo2: public MethodInfo + { + public: + typedef R (C::*ConstFunctionType)(P0, P1) const; + typedef R (C::*FunctionType)(P0, P1); + + TypedMethodInfo2(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo2(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(2); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(2); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1])); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1])); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo3: public MethodInfo + { + public: + typedef R (C::*ConstFunctionType)(P0, P1, P2) const; + typedef R (C::*FunctionType)(P0, P1, P2); + + TypedMethodInfo3(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo3(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(3); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(3); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo4: public MethodInfo + { + public: + typedef R (C::*ConstFunctionType)(P0, P1, P2, P3) const; + typedef R (C::*FunctionType)(P0, P1, P2, P3); + + TypedMethodInfo4(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo4(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(4); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(4); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo5: public MethodInfo + { + public: + typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4) const; + typedef R (C::*FunctionType)(P0, P1, P2, P3, P4); + + TypedMethodInfo5(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo5(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(5); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(5); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo6: public MethodInfo + { + public: + typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5) const; + typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5); + + TypedMethodInfo6(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo6(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(6); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(6); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo7: public MethodInfo + { + public: + typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6) const; + typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6); + + TypedMethodInfo7(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo7(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(7); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(7); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo8: public MethodInfo + { + public: + typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7) const; + typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7); + + TypedMethodInfo8(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo8(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(8); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(8); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo9: public MethodInfo + { + public: + typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8) const; + typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8); + + TypedMethodInfo9(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo9(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(9); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(9); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo10: public MethodInfo + { + public: + typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) const; + typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9); + + TypedMethodInfo10(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo10(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(10); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(10); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo11: public MethodInfo + { + public: + typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) const; + typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10); + + TypedMethodInfo11(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo11(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(11); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(11); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo12: public MethodInfo + { + public: + typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) const; + typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11); + + TypedMethodInfo12(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo12(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(12); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(12); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo13: public MethodInfo + { + public: + typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) const; + typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12); + + TypedMethodInfo13(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo13(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(13); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(13); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo14: public MethodInfo + { + public: + typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) const; + typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13); + + TypedMethodInfo14(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo14(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(14); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(14); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo15: public MethodInfo + { + public: + typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) const; + typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14); + + TypedMethodInfo15(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo15(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(15); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + convertArgument(args, newargs, getParameters(), 14); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(15); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + convertArgument(args, newargs, getParameters(), 14); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo16: public MethodInfo + { + public: + typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) const; + typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15); + + TypedMethodInfo16(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo16(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(16); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + convertArgument(args, newargs, getParameters(), 14); + convertArgument(args, newargs, getParameters(), 15); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(16); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + convertArgument(args, newargs, getParameters(), 14); + convertArgument(args, newargs, getParameters(), 15); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo0: public MethodInfo + { + public: + typedef void (C::*ConstFunctionType)() const; + typedef void (C::*FunctionType)(); + + TypedMethodInfo0(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo0(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList & /*args*/) const + { + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(), Value(); + if (f_) return (variant_cast(instance)->*f_)(), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList & /*args*/) const + { + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(), Value(); + if (f_) return (variant_cast(instance)->*f_)(), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(), Value(); + if (f_) return (variant_cast(instance).*f_)(), Value(); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo1: public MethodInfo + { + public: + typedef void (C::*ConstFunctionType)(P0) const; + typedef void (C::*FunctionType)(P0); + + TypedMethodInfo1(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo1(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(1); + convertArgument(args, newargs, getParameters(), 0); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(1); + convertArgument(args, newargs, getParameters(), 0); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0])), Value(); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo2: public MethodInfo + { + public: + typedef void (C::*ConstFunctionType)(P0, P1) const; + typedef void (C::*FunctionType)(P0, P1); + + TypedMethodInfo2(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo2(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(2); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(2); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1])), Value(); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo3: public MethodInfo + { + public: + typedef void (C::*ConstFunctionType)(P0, P1, P2) const; + typedef void (C::*FunctionType)(P0, P1, P2); + + TypedMethodInfo3(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo3(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(3); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(3); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])), Value(); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo4: public MethodInfo + { + public: + typedef void (C::*ConstFunctionType)(P0, P1, P2, P3) const; + typedef void (C::*FunctionType)(P0, P1, P2, P3); + + TypedMethodInfo4(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo4(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(4); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(4); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])), Value(); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo5: public MethodInfo + { + public: + typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4) const; + typedef void (C::*FunctionType)(P0, P1, P2, P3, P4); + + TypedMethodInfo5(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo5(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(5); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(5); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])), Value(); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo6: public MethodInfo + { + public: + typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5) const; + typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5); + + TypedMethodInfo6(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo6(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(6); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(6); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])), Value(); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo7: public MethodInfo + { + public: + typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6) const; + typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6); + + TypedMethodInfo7(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo7(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(7); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(7); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])), Value(); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo8: public MethodInfo + { + public: + typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7) const; + typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7); + + TypedMethodInfo8(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo8(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(8); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(8); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])), Value(); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo9: public MethodInfo + { + public: + typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8) const; + typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8); + + TypedMethodInfo9(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo9(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(9); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(9); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])), Value(); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo10: public MethodInfo + { + public: + typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) const; + typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9); + + TypedMethodInfo10(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo10(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(10); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(10); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])), Value(); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo11: public MethodInfo + { + public: + typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) const; + typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10); + + TypedMethodInfo11(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo11(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(11); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(11); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])), Value(); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo12: public MethodInfo + { + public: + typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) const; + typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11); + + TypedMethodInfo12(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo12(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(12); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(12); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])), Value(); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo13: public MethodInfo + { + public: + typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) const; + typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12); + + TypedMethodInfo13(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo13(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(13); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(13); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])), Value(); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo14: public MethodInfo + { + public: + typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) const; + typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13); + + TypedMethodInfo14(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo14(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(14); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(14); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])), Value(); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo15: public MethodInfo + { + public: + typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) const; + typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14); + + TypedMethodInfo15(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo15(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(15); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + convertArgument(args, newargs, getParameters(), 14); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(15); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + convertArgument(args, newargs, getParameters(), 14); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])), Value(); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; + + + template + class TypedMethodInfo16: public MethodInfo + { + public: + typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) const; + typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15); + + TypedMethodInfo16(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0) + { + } + + TypedMethodInfo16(const std::string &qname, FunctionType f, const ParameterInfoList &plist) + : MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f) + { + } + + bool isConst() const { return cf_; } + bool isStatic() const { return false; } + + Value invoke(const Value &instance, ValueList &args) const + { + ValueList newargs(16); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + convertArgument(args, newargs, getParameters(), 14); + convertArgument(args, newargs, getParameters(), 15); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + + Value invoke(Value &instance, ValueList &args) const + { + ValueList newargs(16); + convertArgument(args, newargs, getParameters(), 0); + convertArgument(args, newargs, getParameters(), 1); + convertArgument(args, newargs, getParameters(), 2); + convertArgument(args, newargs, getParameters(), 3); + convertArgument(args, newargs, getParameters(), 4); + convertArgument(args, newargs, getParameters(), 5); + convertArgument(args, newargs, getParameters(), 6); + convertArgument(args, newargs, getParameters(), 7); + convertArgument(args, newargs, getParameters(), 8); + convertArgument(args, newargs, getParameters(), 9); + convertArgument(args, newargs, getParameters(), 10); + convertArgument(args, newargs, getParameters(), 11); + convertArgument(args, newargs, getParameters(), 12); + convertArgument(args, newargs, getParameters(), 13); + convertArgument(args, newargs, getParameters(), 14); + convertArgument(args, newargs, getParameters(), 15); + + const Type &type = instance.getType(); + if (type.isPointer()) + { + if (type.isConstPointer()) + { + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])), Value(); + if (f_) throw ConstIsConstException(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance)->*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])), Value(); + if (f_) return (variant_cast(instance)->*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])), Value(); + throw InvalidFunctionPointerException(); + } + if (cf_) return (variant_cast(instance).*cf_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])), Value(); + if (f_) return (variant_cast(instance).*f_)(variant_cast(newargs[0]), variant_cast(newargs[1]), variant_cast(newargs[2]), variant_cast(newargs[3]), variant_cast(newargs[4]), variant_cast(newargs[5]), variant_cast(newargs[6]), variant_cast(newargs[7]), variant_cast(newargs[8]), variant_cast(newargs[9]), variant_cast(newargs[10]), variant_cast(newargs[11]), variant_cast(newargs[12]), variant_cast(newargs[13]), variant_cast(newargs[14]), variant_cast(newargs[15])), Value(); + throw InvalidFunctionPointerException(); + } + + private: + ConstFunctionType cf_; + FunctionType f_; + }; } diff --git a/include/osgIntrospection/Utility b/include/osgIntrospection/Utility new file mode 100644 index 000000000..1a1b63102 --- /dev/null +++ b/include/osgIntrospection/Utility @@ -0,0 +1,37 @@ +#ifndef OSGINTROSPECTION_UTILITY_ +#define OSGINTROSPECTION_UTILITY_ + +#include +#include +#include +#include +#include + +#include + +namespace osgIntrospection +{ + + bool OSGINTROSPECTION_EXPORT areParametersCompatible(const ParameterInfoList &pl1, const ParameterInfoList &pl2); + bool OSGINTROSPECTION_EXPORT areArgumentsCompatible(const ValueList &vl, const ParameterInfoList &pl, float &match); + + template + void convertArgument(ValueList &src, ValueList &dest, const ParameterInfoList &pl, int index) + { + if (index >= static_cast(src.size())) + { + dest[index] = pl[index]->getDefaultValue(); + } + else + { + Value &sv = src[index]; + if (requires_conversion(sv)) + dest[index] = sv.convertTo(pl[index]->getParameterType()); + else + dest[index].swap(sv); + } + } + +} + +#endif diff --git a/include/osgIntrospection/Value b/include/osgIntrospection/Value index fa4672079..f37efdce6 100644 --- a/include/osgIntrospection/Value +++ b/include/osgIntrospection/Value @@ -90,18 +90,24 @@ namespace osgIntrospection /// getType(). inline const Type &getInstanceType() const; - /// Equality test operator. Returns true if the value passed - /// as parameter is equal to this instance. The compare() method - /// is used to perform the actual comparison. - inline bool operator==(const Value &other) const; + /// Equal to operator. + bool operator==(const Value &other) const; - /// Inequality test operator. Returns !operator==(other). - inline bool operator!=(const Value &other) const; - - /// Conversion to bool operator. Returns true if the value is - /// not empty, false otherwise. - inline operator bool() const; + /// Less than or equal to operator. + bool operator<=(const Value &other) const; + /// Inequality test operator. Returns !operator==(other). + bool operator!=(const Value &other) const; + + /// Greater than operator. Returns !operator<=(other). + bool operator>(const Value &other) const; + + /// Less than operator. Returns !operator==(other) && operator<=(other). + bool operator<(const Value &other) const; + + /// Greater than or equal to operator. Returns operator==(other) || !operator<=(other) + bool operator>=(const Value &other) const; + /// Tries to convert this instance to a Value of the given type. /// The conversion is performed by rendering to a temporary stream /// in the source format and trying to read back from the stream @@ -126,15 +132,15 @@ namespace osgIntrospection /// associated to it. If the conversion can't be completed, an /// exception is thrown. std::string toString() const; + + /// Swaps the content of this Value with another Value + void swap(Value &v); - /// Compares two values for equality. Two empty values are considered - /// equal. If the two values' types are different, a conversion is - /// attempted and then the equality test is performed again. - static bool compare(const Value &v1, const Value &v2); private: // It's good to have friends! template friend T variant_cast(const Value &v); + template friend bool requires_conversion(const Value &v); template friend T *extract_raw_data(Value &v); template friend const T *extract_raw_data(const Value &v); @@ -188,8 +194,6 @@ namespace osgIntrospection virtual const Type *type() const = 0; // returns the actual pointed type if applicable virtual const Type *ptype() const { return 0; } - // tests for equality - virtual bool equal(const Value &v) const = 0; // returns whether the data is a null pointer virtual bool nullptr() const = 0; @@ -234,12 +238,6 @@ namespace osgIntrospection return &typeof(static_cast *>(inst_)->data_); } - virtual bool equal(const Value &v) const - { - return static_cast *>(static_cast *>(v.inbox_)->inst_)->data_ == - static_cast *>(inst_)->data_; - } - virtual bool nullptr() const { return nullptr_; @@ -292,12 +290,6 @@ namespace osgIntrospection return &typeof(*static_cast *>(inst_)->data_); } - virtual bool equal(const Value &v) const - { - return static_cast *>(static_cast *>(v.inbox_)->inst_)->data_ == - static_cast *>(inst_)->data_; - } - virtual bool nullptr() const { return static_cast *>(inst_)->data_ == 0; @@ -312,8 +304,8 @@ namespace osgIntrospection /// A vector of values. typedef std::vector ValueList; - - + + // INLINE METHODS inline Value::Value() @@ -375,21 +367,6 @@ namespace osgIntrospection return *this; } - inline bool Value::operator==(const Value &other) const - { - return compare(*this, other); - } - - inline bool Value::operator!=(const Value &other) const - { - return !compare(*this, other); - } - - inline Value::operator bool() const - { - return !isEmpty(); - } - inline Value::~Value() { delete inbox_; diff --git a/include/osgIntrospection/variant_cast b/include/osgIntrospection/variant_cast index 0ce5ee3c0..f209d086b 100644 --- a/include/osgIntrospection/variant_cast +++ b/include/osgIntrospection/variant_cast @@ -37,6 +37,27 @@ namespace osgIntrospection // try to convert v to type T and restart return variant_cast(v.convertTo(typeof(T))); } + + + /// Returns true if the Value passed as parameter can't be casted to + /// the specified type without a (potentially slow) conversion. + /// Returns false otherwise. + template bool requires_conversion(const Value &v) + { + // direct value + Value::Instance *i = dynamic_cast *>(v.inbox_->inst_); + if (i) return false; + + // reference to value + i = dynamic_cast *>(v.inbox_->ref_inst_); + if (i) return false; + + // const reference to value + i = dynamic_cast *>(v.inbox_->const_ref_inst_); + if (i) return false; + + return true; + } /// Returns a typed pointer to the data contained in a Value /// instance. If the value's type is not identical to type T, diff --git a/src/osgIntrospection/ConstructorInfo.cpp b/src/osgIntrospection/ConstructorInfo.cpp new file mode 100644 index 000000000..a916d9555 --- /dev/null +++ b/src/osgIntrospection/ConstructorInfo.cpp @@ -0,0 +1,15 @@ +#include + +using namespace osgIntrospection; + +void ConstructorInfo::getInheritedProviders(CustomAttributeProviderList &providers) const +{ + for (int i=0; iisConst()) return false; + if (decltype_ != other->decltype_) return false; + if (rtype_ != other->rtype_) return false; + if (name_ != other->name_) return false; + if (params_.size() != other->params_.size()) return false; + + ParameterInfoList::const_iterator i=params_.begin(); + ParameterInfoList::const_iterator j=other->params_.begin(); + for (; i!=params_.end(); ++i, ++j) + { + if (&(*i)->getParameterType() != &(*j)->getParameterType()) + return false; + } + + return true; + +/* + std::size_t num_fixed_1 = 0; + std::size_t num_optional_1 = 0; + for (ParameterInfoList::const_iterator i=params_.begin(); i!=params_.end(); ++i) + { + if ((*i)->getDefaultValue().isEmpty()) + ++num_fixed_1; + else + ++num_optional_1; + } + + std::size_t num_fixed_2 = 0; + std::size_t num_optional_2 = 0; + for (ParameterInfoList::const_iterator i=other->params_.begin(); i!=other->params_.end(); ++i) + { + if ((*i)->getDefaultValue().isEmpty()) + ++num_fixed_2; + else + ++num_optional_2; + } + + if (num_fixed_1 > num_fixed_2) + { + } +*/ +} diff --git a/src/osgIntrospection/PropertyInfo.cpp b/src/osgIntrospection/PropertyInfo.cpp index af2b46d2a..e1477b25c 100644 --- a/src/osgIntrospection/PropertyInfo.cpp +++ b/src/osgIntrospection/PropertyInfo.cpp @@ -36,6 +36,26 @@ Value PropertyInfo::getValue(const Value &instance) const return getm_->invoke(instance); } +Value PropertyInfo::getValue(Value &instance) const +{ + const PropertyTypeAttribute *pta = getAttribute(false); + const CustomPropertyGetAttribute *cget = getAttribute(false); + + if (cget) + { + if (pta) + return cget->getGetter()->get(instance).convertTo(pta->getPropertyType()); + return cget->getGetter()->get(instance); + } + + if (!getm_) + throw PropertyAccessException(decltype_.getQualifiedName() + "::" + name_, PropertyAccessException::GET); + + if (pta) + return getm_->invoke(instance).convertTo(pta->getPropertyType()); + return getm_->invoke(instance); +} + void PropertyInfo::setValue(Value &instance, const Value &value) const { const CustomPropertySetAttribute *cset = getAttribute(false); @@ -74,6 +94,26 @@ Value PropertyInfo::getIndexedValue(const Value &instance, ValueList &args) cons return getm_->invoke(instance, args); } +Value PropertyInfo::getIndexedValue(Value &instance, ValueList &args) const +{ + const PropertyTypeAttribute *pta = getAttribute(false); + const CustomPropertyGetAttribute *cget = getAttribute(false); + + if (cget) + { + if (pta) + return cget->getGetter()->get(instance, args).convertTo(pta->getPropertyType()); + return cget->getGetter()->get(instance, args); + } + + if (!getm_) + throw PropertyAccessException(decltype_.getQualifiedName() + "::" + name_, PropertyAccessException::IGET); + + if (pta) + return getm_->invoke(instance, args).convertTo(pta->getPropertyType()); + return getm_->invoke(instance, args); +} + void PropertyInfo::setIndexedValue(Value &instance, ValueList &args, const Value &value) const { const CustomPropertySetAttribute *cset = getAttribute(false); @@ -125,6 +165,29 @@ Value PropertyInfo::getArrayItem(const Value &instance, int i) const return getm_->invoke(instance, args); } +Value PropertyInfo::getArrayItem(Value &instance, int i) const +{ + const PropertyTypeAttribute *pta = getAttribute(false); + const CustomPropertyGetAttribute *cget = getAttribute(false); + + if (cget) + { + if (pta) + return cget->getGetter()->get(instance, i).convertTo(pta->getPropertyType()); + return cget->getGetter()->get(instance, i); + } + + if (!getm_) + throw PropertyAccessException(decltype_.getQualifiedName() + "::" + name_, PropertyAccessException::AGET); + + ValueList args; + args.push_back(i); + + if (pta) + return getm_->invoke(instance, args).convertTo(pta->getPropertyType()); + return getm_->invoke(instance, args); +} + void PropertyInfo::setArrayItem(Value &instance, int i, const Value &value) const { const CustomPropertySetAttribute *cset = getAttribute(false); @@ -160,6 +223,23 @@ void PropertyInfo::addArrayItem(Value &instance, const Value &value) const addm_->invoke(instance, args); } +void PropertyInfo::removeArrayItem(Value &instance, int i) const +{ + const CustomPropertyRemoveAttribute *crem = getAttribute(false); + if (crem) + { + crem->getRemover()->remove(instance, i); + return; + } + + if (!remm_) + throw PropertyAccessException(decltype_.getQualifiedName() + "::" + name_, PropertyAccessException::REMOVE); + + ValueList args; + args.push_back(i); + remm_->invoke(instance, args); +} + Value PropertyInfo::getDefaultValue() const { if (isArray() || isIndexed()) return Value(); diff --git a/src/osgIntrospection/Reflection.cpp b/src/osgIntrospection/Reflection.cpp index 35ce9acab..8736059d7 100644 --- a/src/osgIntrospection/Reflection.cpp +++ b/src/osgIntrospection/Reflection.cpp @@ -48,8 +48,13 @@ const Type &Reflection::getType(const std::string &qname) const TypeMap &types = getTypes(); for (TypeMap::const_iterator i=types.begin(); i!=types.end(); ++i) + { if (i->second->isDefined() && i->second->getQualifiedName().compare(qname) == 0) return *i->second; + for (int j=0; jsecond->getNumAliases(); ++j) + if (i->second->getAlias(j).compare(qname) == 0) + return *i->second; + } throw TypeNotFoundException(qname); } @@ -66,13 +71,28 @@ Type *Reflection::registerType(const std::type_info &ti) return type.release(); } -Type *Reflection::registerOrReplaceType(const std::type_info &ti) +Type *Reflection::getOrRegisterType(const std::type_info &ti, bool replace_if_defined) { TypeMap &tm = getOrCreateStaticData().typemap; TypeMap::iterator i = tm.find(&ti); if (i != tm.end()) - return new (i->second) Type(ti); + { + if (replace_if_defined && i->second->isDefined()) + { + std::string old_name = i->second->getName(); + std::string old_namespace = i->second->getNamespace(); + std::vector old_aliases = i->second->aliases_; + + Type *newtype = new (i->second) Type(ti); + newtype->name_ = old_name; + newtype->namespace_ = old_namespace; + newtype->aliases_.swap(old_aliases); + + return newtype; + } + return i->second; + } return registerType(ti); } diff --git a/src/osgIntrospection/Type.cpp b/src/osgIntrospection/Type.cpp index c490dece3..8f0ac8928 100644 --- a/src/osgIntrospection/Type.cpp +++ b/src/osgIntrospection/Type.cpp @@ -4,6 +4,9 @@ #include #include #include +#include +#include +#include #include #include @@ -13,21 +16,25 @@ using namespace osgIntrospection; namespace { - struct MethodMatch + template + struct ObjectMatch { int list_pos; - int exact_args; - const MethodInfo *method; + float match; + const T *object; - bool operator < (const MethodMatch &m) const + bool operator < (const ObjectMatch &m) const { - if (exact_args > m.exact_args) return true; - if (exact_args < m.exact_args) return false; + if (match > m.match) return true; + if (match < m.match) return false; if (list_pos < m.list_pos) return true; return false; } }; + typedef ObjectMatch MethodMatch; + typedef ObjectMatch ConstructorMatch; + } Type::~Type() @@ -36,8 +43,11 @@ Type::~Type() delete *i; for (MethodInfoList::const_iterator i=methods_.begin(); i!=methods_.end(); ++i) delete *i; - delete icb_; + for (ConstructorInfoList::const_iterator i=cons_.begin(); i!=cons_.end(); ++i) + delete *i; + delete rw_; + delete cmp_; } bool Type::isSubclassOf(const Type &type) const @@ -76,44 +86,22 @@ const MethodInfo *Type::getCompatibleMethod(const std::string &name, const Value const MethodInfo *mi = *j; if (mi->getName().compare(name) == 0) { - const ParameterInfoList &other_params = mi->getParameters(); - if (values.size() == other_params.size()) - { - if (values.empty()) - return mi; - ParameterInfoList::const_iterator i1 = other_params.begin(); - ValueList::const_iterator i2 = values.begin(); - bool candidate = true; - int exact_args = 0; - for (; i1getParameterType() != i2->getType()) - { - if (i2->tryConvertTo((*i1)->getParameterType()).isEmpty()) - { - candidate = false; - break; - } - } - else - ++exact_args; - } - if (candidate) - { - MethodMatch mm; - mm.list_pos = pos; - mm.exact_args = exact_args; - mm.method = mi; - matches.push_back(mm); - } - } + float match; + if (areArgumentsCompatible(values, mi->getParameters(), match)) + { + MethodMatch mm; + mm.list_pos = pos; + mm.match = match; + mm.object = mi; + matches.push_back(mm); + } } } if (!matches.empty()) { std::sort(matches.begin(), matches.end()); - return matches.front().method; + return matches.front().object; } return 0; @@ -124,28 +112,13 @@ const MethodInfo *Type::getMethod(const std::string &name, const ParameterInfoLi check_defined(); for (MethodInfoList::const_iterator j=methods_.begin(); j!=methods_.end(); ++j) { - const MethodInfo &mi = **j; - if (mi.getName().compare(name) == 0) + const MethodInfo *mi = *j; + if (mi->getName().compare(name) == 0) { - const ParameterInfoList &other_params = mi.getParameters(); - if (params.size() == other_params.size()) - { - if (params.empty()) - return &mi; - ParameterInfoList::const_iterator i1 = params.begin(); - ParameterInfoList::const_iterator i2 = other_params.begin(); - for (; i1getParameters())) + { + return mi; + } } } @@ -172,28 +145,13 @@ const PropertyInfo *Type::getProperty(const std::string &name, const Type &ptype check_defined(); for (PropertyInfoList::const_iterator i=props_.begin(); i!=props_.end(); ++i) { - const PropertyInfo &pi = **i; - if (pi.getName() == name && pi.getPropertyType() == ptype) + const PropertyInfo *pi = *i; + if (pi->getName() == name && pi->getPropertyType() == ptype) { - const ParameterInfoList &other_indices = pi.getIndexParameters(); - if (indices.size() == other_indices.size()) - { - if (indices.empty()) - return π - ParameterInfoList::const_iterator i1 = indices.begin(); - ParameterInfoList::const_iterator i2 = other_indices.begin(); - for (; i1getIndexParameters())) + { + return pi; + } } } @@ -225,7 +183,6 @@ Value Type::invokeMethod(const std::string &name, Value &instance, ValueList &ar return mi->invoke(instance, args); } - void Type::getAllProperties(PropertyInfoList &props) const { check_defined(); @@ -245,3 +202,58 @@ void Type::getAllMethods(MethodInfoList &methods) const (*i)->getAllMethods(methods); } } + +Value Type::createInstance(ValueList &args) const +{ + if (isAbstract()) + throw TypeIsAbstractException(ti_); + + const ConstructorInfo *ci = getCompatibleConstructor(args); + if (!ci) + throw ConstructorNotFoundException(ti_); + + return ci->createInstance(args); +} + +const ConstructorInfo *Type::getCompatibleConstructor(const ValueList &values) const +{ + check_defined(); + + typedef std::vector MatchList; + MatchList matches; + + int pos = 0; + for (ConstructorInfoList::const_iterator j=cons_.begin(); j!=cons_.end(); ++j, ++pos) + { + float match; + if (areArgumentsCompatible(values, (*j)->getParameters(), match)) + { + ConstructorMatch mm; + mm.list_pos = pos; + mm.match = match; + mm.object = *j; + matches.push_back(mm); + } + } + + if (!matches.empty()) + { + std::sort(matches.begin(), matches.end()); + return matches.front().object; + } + + return 0; +} + +const ConstructorInfo *Type::getConstructor(const ParameterInfoList ¶ms) const +{ + check_defined(); + + for (ConstructorInfoList::const_iterator j=cons_.begin(); j!=cons_.end(); ++j) + { + if (areParametersCompatible(params, (*j)->getParameters())) + return *j; + } + + return 0; +} diff --git a/src/osgIntrospection/Utility.cpp b/src/osgIntrospection/Utility.cpp new file mode 100644 index 000000000..a75ff2b0b --- /dev/null +++ b/src/osgIntrospection/Utility.cpp @@ -0,0 +1,71 @@ +#include + +using namespace osgIntrospection; + +bool osgIntrospection::areParametersCompatible(const ParameterInfoList &pl1, const ParameterInfoList &pl2) +{ + if (pl1.size() == pl2.size()) + { + if (pl1.empty()) + return true; + + ParameterInfoList::const_iterator i1 = pl1.begin(); + ParameterInfoList::const_iterator i2 = pl2.begin(); + for (; i1getDefaultValue().isEmpty()) + return false; + continue; + } + + if ((*i1)->getParameterType() != i2->getType()) + { + if (i2->tryConvertTo((*i1)->getParameterType()).isEmpty()) + { + return false; + } + } + else + ++exact_args; + + ++i2; + } + + match = static_cast(exact_args) / pl.size(); + return true; +} + diff --git a/src/osgIntrospection/Value.cpp b/src/osgIntrospection/Value.cpp index 331cecf29..15365576d 100644 --- a/src/osgIntrospection/Value.cpp +++ b/src/osgIntrospection/Value.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #include #include @@ -71,17 +72,115 @@ std::string Value::toString() const throw StreamingNotSupportedException(StreamingNotSupportedException::ANY, type_->getStdTypeInfo()); } -bool Value::compare(const Value &v1, const Value &v2) -{ - if (v1.isEmpty() && v2.isEmpty()) return true; - if (v1.isEmpty() || v2.isEmpty()) return false; - if (v1.type_ == v2.type_) return v1.inbox_->equal(v2); - Value temp(v2.convertTo(v1.getType())); - return compare(v1, temp); -} - void Value::check_empty() const { if (!type_ || !inbox_) throw EmptyValueException(); } + +void Value::swap(Value &v) +{ + std::swap(inbox_, v.inbox_); + std::swap(type_, v.type_); + std::swap(ptype_, v.ptype_); +} + +bool Value::operator ==(const Value &other) const +{ + if (isEmpty() && other.isEmpty()) + return true; + + if (isEmpty() ^ other.isEmpty()) + return false; + + const Comparator *cmp1 = type_->getComparator(); + const Comparator *cmp2 = other.type_->getComparator(); + + const Comparator *cmp = cmp1? cmp1: cmp2; + + if (!cmp) + throw ComparisonNotPermittedException(type_->getStdTypeInfo()); + + if (cmp1 == cmp2) + return cmp->isEqualTo(*this, other); + + if (cmp1) + return cmp1->isEqualTo(*this, other.convertTo(*type_)); + + return cmp2->isEqualTo(convertTo(*other.type_), other); +} + +bool Value::operator <=(const Value &other) const +{ + const Comparator *cmp1 = type_->getComparator(); + const Comparator *cmp2 = other.type_->getComparator(); + + const Comparator *cmp = cmp1? cmp1: cmp2; + + if (!cmp) + throw ComparisonNotPermittedException(type_->getStdTypeInfo()); + + if (cmp1 == cmp2) + return cmp->isLessThanOrEqualTo(*this, other); + + if (cmp1) + return cmp1->isLessThanOrEqualTo(*this, other.convertTo(*type_)); + + return cmp2->isLessThanOrEqualTo(convertTo(*other.type_), other); +} + +bool Value::operator !=(const Value &other) const +{ + return !operator==(other); +} + +bool Value::operator >(const Value &other) const +{ + return !operator<=(other); +} + +bool Value::operator <(const Value &other) const +{ + const Comparator *cmp1 = type_->getComparator(); + const Comparator *cmp2 = other.type_->getComparator(); + + const Comparator *cmp = cmp1? cmp1: cmp2; + + if (!cmp) + throw ComparisonNotPermittedException(type_->getStdTypeInfo()); + + if (cmp1 == cmp2) + return cmp->isLessThanOrEqualTo(*this, other) && !cmp->isEqualTo(*this, other); + + if (cmp1) + { + Value temp(other.convertTo(*type_)); + return cmp1->isLessThanOrEqualTo(*this, temp) && !cmp1->isEqualTo(*this, temp); + } + + Value temp(convertTo(*other.type_)); + return cmp2->isLessThanOrEqualTo(temp, other) && !cmp2->isEqualTo(temp, other); +} + +bool Value::operator >=(const Value &other) const +{ + const Comparator *cmp1 = type_->getComparator(); + const Comparator *cmp2 = other.type_->getComparator(); + + const Comparator *cmp = cmp1? cmp1: cmp2; + + if (!cmp) + throw ComparisonNotPermittedException(type_->getStdTypeInfo()); + + if (cmp1 == cmp2) + return !cmp->isLessThanOrEqualTo(*this, other) || cmp->isEqualTo(*this, other); + + if (cmp1) + { + Value temp(other.convertTo(*type_)); + return !cmp1->isLessThanOrEqualTo(*this, temp) || cmp1->isEqualTo(*this, temp); + } + + Value temp(convertTo(*other.type_)); + return !cmp2->isLessThanOrEqualTo(temp, other) || cmp2->isEqualTo(temp, other); +}