From f2d696f871e220faa064746ffd98589aa2034c7c Mon Sep 17 00:00:00 2001 From: Robert Osfield Date: Fri, 29 Apr 2005 11:19:58 +0000 Subject: [PATCH] Moved osgIntrospection across to standard OSG coding style. --- include/osgIntrospection/Attributes | 116 +- include/osgIntrospection/Comparator | 12 +- include/osgIntrospection/ConstructorInfo | 52 +- include/osgIntrospection/Converter | 104 +- include/osgIntrospection/ConverterProxy | 18 +- .../osgIntrospection/CustomAttributeProvider | 14 +- include/osgIntrospection/Exceptions | 58 +- include/osgIntrospection/InstanceCreator | 536 +- include/osgIntrospection/MethodInfo | 110 +- include/osgIntrospection/ParameterInfo | 30 +- include/osgIntrospection/PropertyInfo | 146 +- include/osgIntrospection/ReaderWriter | 40 +- include/osgIntrospection/Reflection | 36 +- include/osgIntrospection/ReflectionMacros | 160 +- include/osgIntrospection/Reflector | 572 +- include/osgIntrospection/StaticMethodInfo | 2370 +++---- include/osgIntrospection/Type | 226 +- include/osgIntrospection/TypeNameAliasProxy | 20 +- include/osgIntrospection/TypedConstructorInfo | 878 +-- include/osgIntrospection/TypedMethodInfo | 5836 ++++++++--------- include/osgIntrospection/Utility | 38 +- include/osgIntrospection/Value | 168 +- include/osgIntrospection/variant_cast | 34 +- src/osgIntrospection/ConstructorInfo.cpp | 6 +- .../CustomAttributeProvider.cpp | 6 +- src/osgIntrospection/MethodInfo.cpp | 76 +- src/osgIntrospection/PropertyInfo.cpp | 138 +- src/osgIntrospection/Reflection.cpp | 54 +- src/osgIntrospection/Type.cpp | 124 +- src/osgIntrospection/Utility.cpp | 44 +- src/osgIntrospection/Value.cpp | 92 +- 31 files changed, 6057 insertions(+), 6057 deletions(-) diff --git a/include/osgIntrospection/Attributes b/include/osgIntrospection/Attributes index cebd1e558..5c5a137bc 100644 --- a/include/osgIntrospection/Attributes +++ b/include/osgIntrospection/Attributes @@ -33,10 +33,10 @@ namespace osgIntrospection class DefaultValueAttribute: public CustomAttribute { public: - DefaultValueAttribute(const Value &v): v_(v) {} - const Value &getDefaultValue() const { return v_; } + DefaultValueAttribute(const Value& v): _v(v) {} + const Value& getDefaultValue() const { return _v; } private: - Value v_; + Value _v; }; /// Base struct for custom property getters. Descendants may override @@ -46,12 +46,12 @@ namespace osgIntrospection /// last one is used with array properties. struct PropertyGetter { - 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 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() {} }; @@ -61,18 +61,18 @@ namespace osgIntrospection class CustomPropertyGetAttribute: public CustomAttribute { public: - CustomPropertyGetAttribute(const PropertyGetter *getter) - : CustomAttribute(), getter_(getter) {} + CustomPropertyGetAttribute(const PropertyGetter* getter) + : CustomAttribute(), _getter(getter) {} - const PropertyGetter *getGetter() const { return getter_; } + const PropertyGetter* getGetter() const { return _getter; } ~CustomPropertyGetAttribute() { - delete getter_; + delete _getter; } private: - const PropertyGetter *getter_; + const PropertyGetter* _getter; }; /// Base struct for custom property setters. Descendants may override @@ -82,9 +82,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() {} }; @@ -94,18 +94,18 @@ namespace osgIntrospection class CustomPropertySetAttribute: public CustomAttribute { public: - CustomPropertySetAttribute(const PropertySetter *setter) - : CustomAttribute(), setter_(setter) {} + CustomPropertySetAttribute(const PropertySetter* setter) + : CustomAttribute(), _setter(setter) {} - const PropertySetter *getSetter() const { return setter_; } + const PropertySetter* getSetter() const { return _setter; } ~CustomPropertySetAttribute() { - delete setter_; + delete _setter; } private: - const PropertySetter *setter_; + const PropertySetter* _setter; }; /// Base struct for custom array property counters. Descendants should @@ -113,7 +113,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() {} }; @@ -122,18 +122,18 @@ namespace osgIntrospection class CustomPropertyCountAttribute: public CustomAttribute { public: - CustomPropertyCountAttribute(const PropertyCounter *counter) - : CustomAttribute(), counter_(counter) {} + CustomPropertyCountAttribute(const PropertyCounter* counter) + : CustomAttribute(), _counter(counter) {} - const PropertyCounter *getCounter() const { return counter_; } + const PropertyCounter* getCounter() const { return _counter; } ~CustomPropertyCountAttribute() { - delete counter_; + delete _counter; } private: - const PropertyCounter *counter_; + const PropertyCounter* _counter; }; /// Base struct for custom array property adders. Descendants should @@ -150,18 +150,18 @@ namespace osgIntrospection class CustomPropertyAddAttribute: public CustomAttribute { public: - CustomPropertyAddAttribute(const PropertyAdder *adder) - : CustomAttribute(), adder_(adder) {} + CustomPropertyAddAttribute(const PropertyAdder* adder) + : CustomAttribute(), _adder(adder) {} - const PropertyAdder *getAdder() const { return adder_; } + const PropertyAdder* getAdder() const { return _adder; } ~CustomPropertyAddAttribute() { - delete adder_; + delete _adder; } private: - const PropertyAdder *adder_; + const PropertyAdder* _adder; }; @@ -179,18 +179,18 @@ namespace osgIntrospection class CustomPropertyRemoveAttribute: public CustomAttribute { public: - CustomPropertyRemoveAttribute(const PropertyRemover *remover) - : CustomAttribute(), remover_(remover) {} + CustomPropertyRemoveAttribute(const PropertyRemover* remover) + : CustomAttribute(), _remover(remover) {} - const PropertyRemover *getRemover() const { return remover_; } + const PropertyRemover* getRemover() const { return _remover; } ~CustomPropertyRemoveAttribute() { - delete remover_; + delete _remover; } private: - const PropertyRemover *remover_; + const PropertyRemover* _remover; }; @@ -203,8 +203,8 @@ namespace osgIntrospection /// See CustomIndexAttribute for details. struct IndexInfo { - virtual const ParameterInfoList &getIndexParameters() const = 0; - virtual void getIndexValueSet(int whichindex, const Value &instance, ValueList &values) const = 0; + virtual const ParameterInfoList& getIndexParameters() const = 0; + virtual void getIndexValueSet(int whichindex, const Value& instance, ValueList& values) const = 0; virtual ~IndexInfo() {} }; @@ -220,21 +220,21 @@ namespace osgIntrospection class CustomIndexAttribute: public CustomAttribute { public: - CustomIndexAttribute(const IndexInfo *ii) - : CustomAttribute(), ii_(ii) {} + CustomIndexAttribute(const IndexInfo* ii) + : CustomAttribute(), _ii(ii) {} - const IndexInfo *getIndexInfo() const + const IndexInfo* getIndexInfo() const { - return ii_; + return _ii; } ~CustomIndexAttribute() { - delete ii_; + delete _ii; } private: - const IndexInfo *ii_; + const IndexInfo* _ii; }; /// Attribute for overriding the type of a property with a custom @@ -249,16 +249,16 @@ namespace osgIntrospection class PropertyTypeAttribute: public CustomAttribute { public: - PropertyTypeAttribute(const Type &type) - : CustomAttribute(), type_(type) {} + PropertyTypeAttribute(const Type& type) + : CustomAttribute(), _type(type) {} - const Type &getPropertyType() const + const Type& getPropertyType() const { - return type_; + return _type; } private: - const Type &type_; + const Type& _type; }; /// Attribute for overriding the type of an index (of an indexed @@ -270,22 +270,22 @@ namespace osgIntrospection class IndexTypeAttribute: public CustomAttribute { public: - IndexTypeAttribute(int whichindex, const Type &type) - : CustomAttribute(), wi_(whichindex), type_(type) {} + IndexTypeAttribute(int whichindex, const Type& type) + : CustomAttribute(), _wi(whichindex), _type(type) {} int getWhichIndex() const { - return wi_; + return _wi; } - const Type &getIndexType() const + const Type& getIndexType() const { - return type_; + return _type; } private: - int wi_; - const Type &type_; + int _wi; + const Type& _type; }; } diff --git a/include/osgIntrospection/Comparator b/include/osgIntrospection/Comparator index 1e3193c66..85fc28c02 100644 --- a/include/osgIntrospection/Comparator +++ b/include/osgIntrospection/Comparator @@ -23,21 +23,21 @@ namespace osgIntrospection struct Comparator { - virtual bool isEqualTo(const Value &l, const Value &r) const = 0; - virtual bool isLessThanOrEqualTo(const Value &l, const Value &r) const = 0; + 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 + 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 + virtual bool isLessThanOrEqualTo(const Value& l, const Value& r) const { return variant_cast(l) <= variant_cast(r); } @@ -46,12 +46,12 @@ namespace osgIntrospection template struct PartialOrderComparator: Comparator { - virtual bool isEqualTo(const Value &l, const Value &r) const + 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 + virtual bool isLessThanOrEqualTo(const Value& , const Value& ) const { throw ComparisonOperatorNotSupportedException(typeid(T), "less than or equal to"); } diff --git a/include/osgIntrospection/ConstructorInfo b/include/osgIntrospection/ConstructorInfo index 57429f502..951d2eb98 100644 --- a/include/osgIntrospection/ConstructorInfo +++ b/include/osgIntrospection/ConstructorInfo @@ -26,36 +26,36 @@ namespace osgIntrospection class OSGINTROSPECTION_EXPORT ConstructorInfo: public CustomAttributeProvider { public: - ConstructorInfo(const Type &decltype, const ParameterInfoList ¶ms) - : decltype_(decltype), - params_(params) - { - } + ConstructorInfo(const Type& decltype, const ParameterInfoList& params) + : _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; + virtual ~ConstructorInfo() + { + for (ParameterInfoList::iterator i=_params.begin(); i!=_params.end(); ++i) + delete *i; + } - protected: - virtual void getInheritedProviders(CustomAttributeProviderList &providers) const; + 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_; + const Type& _decltype; + ParameterInfoList _params; }; } diff --git a/include/osgIntrospection/Converter b/include/osgIntrospection/Converter index 2561aba04..62fba87bd 100644 --- a/include/osgIntrospection/Converter +++ b/include/osgIntrospection/Converter @@ -21,62 +21,62 @@ namespace osgIntrospection { - struct Converter - { - virtual Value convert(const Value &) const = 0; - virtual ~Converter() {} - }; - - typedef std::vector ConverterList; - - class CompositeConverter: public Converter - { - public: - CompositeConverter(const ConverterList &cvt): cvt_(cvt) {} - CompositeConverter(ConverterList &cvt) { cvt_.swap(cvt); } - virtual ~CompositeConverter() {} - - virtual Value convert(const Value &src) const - { - Value accum(src); - for (ConverterList::const_iterator i=cvt_.begin(); i!=cvt_.end(); ++i) - accum = (*i)->convert(accum); - return accum; - } + struct Converter + { + virtual Value convert(const Value& ) const = 0; + virtual ~Converter() {} + }; + + typedef std::vector ConverterList; + + class CompositeConverter: public Converter + { + public: + CompositeConverter(const ConverterList& cvt): cvt_(cvt) {} + CompositeConverter(ConverterList& cvt) { cvt_.swap(cvt); } + virtual ~CompositeConverter() {} + + virtual Value convert(const Value& src) const + { + Value accum(src); + for (ConverterList::const_iterator i=cvt_.begin(); i!=cvt_.end(); ++i) + accum = (*i)->convert(accum); + return accum; + } - private: - ConverterList cvt_; - }; + private: + ConverterList cvt_; + }; - template - struct StaticConverter: Converter - { - virtual ~StaticConverter() {} - virtual Value convert(const Value &src) const - { - return static_cast(variant_cast(src)); - } - }; + template + struct StaticConverter: Converter + { + virtual ~StaticConverter() {} + virtual Value convert(const Value& src) const + { + return static_cast(variant_cast(src)); + } + }; - template - struct DynamicConverter: Converter - { - virtual ~DynamicConverter() {} - virtual Value convert(const Value &src) const - { - return dynamic_cast(variant_cast(src)); - } - }; + template + struct DynamicConverter: Converter + { + virtual ~DynamicConverter() {} + virtual Value convert(const Value& src) const + { + return dynamic_cast(variant_cast(src)); + } + }; - template - struct ReinterpretConverter: Converter - { - virtual ~ReinterpretConverter() {} - virtual Value convert(const Value &src) const - { - return reinterpret_cast(variant_cast(src)); - } - }; + template + struct ReinterpretConverter: Converter + { + virtual ~ReinterpretConverter() {} + virtual Value convert(const Value& src) const + { + return reinterpret_cast(variant_cast(src)); + } + }; } diff --git a/include/osgIntrospection/ConverterProxy b/include/osgIntrospection/ConverterProxy index 2ee9d1f1c..fe16b00c4 100644 --- a/include/osgIntrospection/ConverterProxy +++ b/include/osgIntrospection/ConverterProxy @@ -20,16 +20,16 @@ namespace osgIntrospection { - struct Converter; + struct Converter; - struct ConverterProxy - { - ConverterProxy(const Type &source, const Type &dest, const Converter *cvt) - { - Reflection::registerConverter(source, dest, cvt); - } - }; - + struct ConverterProxy + { + ConverterProxy(const Type& source, const Type& dest, const Converter* cvt) + { + Reflection::registerConverter(source, dest, cvt); + } + }; + } #endif diff --git a/include/osgIntrospection/CustomAttributeProvider b/include/osgIntrospection/CustomAttributeProvider index 810353186..77c7d3c50 100644 --- a/include/osgIntrospection/CustomAttributeProvider +++ b/include/osgIntrospection/CustomAttributeProvider @@ -30,7 +30,7 @@ namespace osgIntrospection class CustomAttributeProvider; // vector of attributes - typedef std::vector CustomAttributeList; + typedef std::vector CustomAttributeList; // vector of attribute providers typedef std::vector CustomAttributeProviderList; @@ -44,19 +44,19 @@ namespace osgIntrospection { public: /// Returns the const list of custom attributes. - inline const CustomAttributeList &getCustomAttributes() const + inline const CustomAttributeList& getCustomAttributes() const { return attribs_; } /// Returns the list of custom attributes. - inline CustomAttributeList &getCustomAttributes() + inline CustomAttributeList& getCustomAttributes() { return attribs_; } /// Adds a new attribute to the list. - inline CustomAttributeProvider *addAttribute(const CustomAttribute *attr) + inline CustomAttributeProvider *addAttribute(const CustomAttribute* attr) { attribs_.push_back(attr); return this; @@ -65,7 +65,7 @@ namespace osgIntrospection /// Returns whether at least one attribute of the given type is /// present in the attribute list. If the inherit parameter is /// set to true, the search is forwarded to base types. - bool isDefined(const Type &type, bool inherit) const; + bool isDefined(const Type& type, bool inherit) const; /// Returns whether at least one attribute of the given type is /// present in the attribute list. If the inherit parameter is @@ -90,7 +90,7 @@ namespace osgIntrospection /// Searchs for an attribute of the given type and returns a pointer /// to it if found, a null pointer otherwise. If the inherit parameter /// is set to true, the search is forwarded to base types. - const CustomAttribute *getAttribute(const Type &type, bool inherit) const; + const CustomAttribute* getAttribute(const Type& type, bool inherit) const; /// Searchs for an attribute of the given type and returns a pointer /// to it if found, a null pointer otherwise. If the inherit parameter @@ -114,7 +114,7 @@ namespace osgIntrospection } protected: - virtual void getInheritedProviders(CustomAttributeProviderList &providers) const = 0; + virtual void getInheritedProviders(CustomAttributeProviderList& providers) const = 0; virtual ~CustomAttributeProvider() {} private: diff --git a/include/osgIntrospection/Exceptions b/include/osgIntrospection/Exceptions index af1df22ce..171110df1 100644 --- a/include/osgIntrospection/Exceptions +++ b/include/osgIntrospection/Exceptions @@ -24,8 +24,8 @@ namespace osgIntrospection class Exception { public: - Exception(const std::string &msg): msg_(msg) {} - const std::string &what() const throw() { return msg_; } + Exception(const std::string& msg): msg_(msg) {} + const std::string& what() const throw() { return msg_; } private: std::string msg_; @@ -33,12 +33,12 @@ namespace osgIntrospection struct ReflectionException: public Exception { - ReflectionException(const std::string &msg): Exception(msg) {} + ReflectionException(const std::string& msg): Exception(msg) {} }; struct TypeNotDefinedException: public ReflectionException { - TypeNotDefinedException(const std::type_info &ti) + TypeNotDefinedException(const std::type_info& ti) : ReflectionException("type `" + std::string(ti.name()) + "' is declared but not defined") { } @@ -46,7 +46,7 @@ namespace osgIntrospection struct TypeIsAbstractException: public ReflectionException { - TypeIsAbstractException(const std::type_info &ti) + TypeIsAbstractException(const std::type_info& ti) : ReflectionException("cannot create instances of abstract type `" + std::string(ti.name()) + "'") { } @@ -54,18 +54,18 @@ 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()) + "'") - { - } + 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") - { - } + InvokeNotImplementedException() + : ReflectionException("invoke() not implemented") + { + } }; struct InvalidFunctionPointerException: public ReflectionException @@ -94,7 +94,7 @@ namespace osgIntrospection struct TypeNotFoundException: public ReflectionException { - TypeNotFoundException(const std::string &qname) + TypeNotFoundException(const std::string& qname) : ReflectionException("type `" + qname + "' not found") { } @@ -102,7 +102,7 @@ namespace osgIntrospection struct MethodNotFoundException: public ReflectionException { - MethodNotFoundException(const std::string &name, const std::string &cname) + MethodNotFoundException(const std::string& name, const std::string& cname) : ReflectionException("could not find a suitable method of name `" + name + "' in class `" + cname + "'") { } @@ -136,13 +136,13 @@ namespace osgIntrospection BINARY_READ }; - StreamingNotSupportedException(OperationType op, const std::type_info &type) + StreamingNotSupportedException(OperationType op, const std::type_info& type) : ReflectionException(build_msg(op, type)) { } private: - std::string build_msg(OperationType op, const std::type_info &type) + std::string build_msg(OperationType op, const std::type_info& type) { std::string opstr; switch (op) @@ -160,7 +160,7 @@ namespace osgIntrospection struct TypeConversionException: public ReflectionException { - TypeConversionException(const std::type_info &type1, const std::type_info &type2) + TypeConversionException(const std::type_info& type1, const std::type_info& type2) : ReflectionException("cannot convert from type `" + std::string(type1.name()) + "' to type `" + std::string(type2.name()) + "'") { } @@ -182,13 +182,13 @@ namespace osgIntrospection COUNT }; - PropertyAccessException(const std::string &pname, AccessType denied) + PropertyAccessException(const std::string& pname, AccessType denied) : ReflectionException(build_msg(pname, denied)) { } private: - std::string build_msg(const std::string &pname, AccessType denied) const + std::string build_msg(const std::string& pname, AccessType denied) const { std::string msg; switch (denied) @@ -210,7 +210,7 @@ namespace osgIntrospection struct IndexValuesNotDefinedException: ReflectionException { - IndexValuesNotDefinedException(const std::string &name, const std::string &iname) + IndexValuesNotDefinedException(const std::string& name, const std::string& iname) : ReflectionException("couldn't determine a finite set of values for index `" + iname + "' of property `" + name + "'. Make sure that either: 1) the index is an enumeration, or 2) a valid custom indexing attribute was assigned to the property.") { } @@ -218,18 +218,18 @@ namespace osgIntrospection struct ComparisonNotPermittedException: ReflectionException { - ComparisonNotPermittedException(const std::type_info &ti) - : ReflectionException("comparison not permitted on type `" + std::string(ti.name()) + "'") - { - } + 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()) + "'") - { - } + 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 index e2e40a4e8..c1b0fb51e 100644 --- a/include/osgIntrospection/InstanceCreator +++ b/include/osgIntrospection/InstanceCreator @@ -21,327 +21,327 @@ 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)); - } + /// 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, Value& a1) + { + return new T(variant_cast(a0), variant_cast(a1)); + } - template - static Value create(Value &a0) - { - return new T(variant_cast(a0)); - } + template + static Value create(Value& a0) + { + return new T(variant_cast(a0)); + } - static Value create() - { - return new T(); - } + 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 + 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, Value& a1) + { + return T(variant_cast(a0), variant_cast(a1)); + } - template - static Value create(Value &a0) - { - return T(variant_cast(a0)); - } + template + static Value create(Value& a0) + { + return T(variant_cast(a0)); + } - static Value create() - { - return T(); - } + 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 + 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& , 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& , 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& , 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& , 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& , 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& , 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& , 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& , 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& , Value& ) + { + return Value(); + } - template - static Value create(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& , Value& ) + { + return Value(); + } - template - static Value create(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& , Value& ) + { + return Value(); + } - template - static Value create(Value &, Value &) - { - return Value(); - } + template + static Value create(Value& , Value& ) + { + return Value(); + } - template - static Value create(Value &) - { - return Value(); - } + template + static Value create(Value& ) + { + return Value(); + } - static Value create() - { - return Value(); - } + static Value create() + { + return Value(); + } - }; + }; } diff --git a/include/osgIntrospection/MethodInfo b/include/osgIntrospection/MethodInfo index 8faeacb32..b592e425c 100644 --- a/include/osgIntrospection/MethodInfo +++ b/include/osgIntrospection/MethodInfo @@ -38,24 +38,24 @@ namespace osgIntrospection { public: /// Direct initialization constructor. - inline MethodInfo(const std::string &qname, const Type &decltype, const Type &rtype, const ParameterInfoList &plist); + 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. - inline virtual const Type &getDeclaringType() const; + inline virtual const Type& getDeclaringType() const; /// Returns the name of the reflected method. - inline virtual const std::string &getName() const; + inline virtual const std::string& getName() const; /// Returns the return type of the reflected method. - inline const Type &getReturnType() const; + inline const Type& getReturnType() const; /// Returns a list of objects that describe the reflected /// method's parameters. - inline const ParameterInfoList &getParameters() const; + inline const ParameterInfoList& getParameters() const; /// Returns whether the reflected method is const or not. virtual bool isConst() const = 0; @@ -65,54 +65,54 @@ namespace osgIntrospection /// Returns whether this method would override the given /// method. - bool overrides(const MethodInfo *other) const; + 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. - inline virtual Value invoke(const Value &instance, ValueList &args) const; + 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. - inline virtual Value invoke(Value &instance, ValueList &args) const; + 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; + inline virtual Value invoke(ValueList& args) const; /// Invokes the reflected method dynamically on the given const /// instance, without arguments. - inline Value invoke(const Value &instance) const; + inline Value invoke(const Value& instance) const; /// Invokes the reflected method dynamically on the given /// instance, without arguments. - inline Value invoke(Value &instance) const; + 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; + inline std::string strip_namespace(const std::string& s) const; - virtual void getInheritedProviders(CustomAttributeProviderList &providers) const; + virtual void getInheritedProviders(CustomAttributeProviderList& providers) const; - std::string name_; - const Type &decltype_; - const Type &rtype_; - ParameterInfoList params_; + std::string _name; + const Type& _decltype; + const Type& _rtype; + ParameterInfoList _params; }; // INLINE METHODS - inline MethodInfo::MethodInfo(const std::string &qname, const Type &decltype, const Type &rtype, const ParameterInfoList &plist) + inline MethodInfo::MethodInfo(const std::string& qname, const Type& decltype, const Type& rtype, const ParameterInfoList& plist) : CustomAttributeProvider(), - decltype_(decltype), - rtype_(rtype), - params_(plist) + _decltype(decltype), + _rtype(rtype), + _params(plist) { - name_ = strip_namespace(qname); + _name = strip_namespace(qname); } - inline std::string MethodInfo::strip_namespace(const std::string &s) const + inline std::string MethodInfo::strip_namespace(const std::string& s) const { std::string::size_type p = s.rfind("::"); if (p != std::string::npos) @@ -120,64 +120,64 @@ namespace osgIntrospection return s; } - inline const std::string &MethodInfo::getName() const + inline const std::string& MethodInfo::getName() const { - return name_; + return _name; } - inline const Type &MethodInfo::getDeclaringType() const + inline const Type& MethodInfo::getDeclaringType() const { - return decltype_; + return _decltype; } - inline const Type &MethodInfo::getReturnType() const + inline const Type& MethodInfo::getReturnType() const { - return rtype_; + return _rtype; } - inline const ParameterInfoList &MethodInfo::getParameters() const + inline const ParameterInfoList& MethodInfo::getParameters() const { - return params_; + return _params; } - inline Value MethodInfo::invoke(const Value &, ValueList &) const - { - throw InvokeNotImplementedException(); - } + inline Value MethodInfo::invoke(const Value& , ValueList& ) const + { + throw InvokeNotImplementedException(); + } - inline Value MethodInfo::invoke(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(ValueList& ) const + { + throw InvokeNotImplementedException(); + } - inline Value MethodInfo::invoke(const Value &instance) const + inline Value MethodInfo::invoke(const Value& instance) const { ValueList args; return invoke(instance, args); } - inline Value MethodInfo::invoke(Value &instance) const + inline Value MethodInfo::invoke(Value& instance) const { ValueList args; return invoke(instance, args); } - inline Value MethodInfo::invoke() const - { + 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; - } + 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 f92c443f5..0557ba17f 100644 --- a/include/osgIntrospection/ParameterInfo +++ b/include/osgIntrospection/ParameterInfo @@ -43,19 +43,19 @@ namespace osgIntrospection }; /// Direct initialization constructor. - inline ParameterInfo(const std::string &name, const Type &type, int attribs, const Value &defval = Value()); + 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; + inline const std::string& getName() const; /// Returns the parameter's type. - inline const Type &getParameterType() const; + inline const Type& getParameterType() const; /// Returns the parameter's attributes. inline int getAttributes() const; /// Returns the default value. - inline const Value &getDefaultValue() const; + inline const Value& getDefaultValue() const; /// Returns whether the parameter has the IN attribute. inline bool isIn() const { return (attribs_ & IN) != 0; } @@ -68,30 +68,30 @@ namespace osgIntrospection inline bool isInOut() const { return isIn() && isOut(); } private: - std::string name_; - const Type &type_; + std::string _name; + const Type& _type; int attribs_; Value default_; }; // INLINE METHODS - inline ParameterInfo::ParameterInfo(const std::string &name, const Type &type, int attribs, const Value &defval) - : name_(name), - type_(type), + inline ParameterInfo::ParameterInfo(const std::string& name, const Type& type, int attribs, const Value& defval) + : _name(name), + _type(type), attribs_(attribs), default_(defval) { } - inline const std::string &ParameterInfo::getName() const + inline const std::string& ParameterInfo::getName() const { - return name_; + return _name; } - inline const Type &ParameterInfo::getParameterType() const + inline const Type& ParameterInfo::getParameterType() const { - return type_; + return _type; } inline int ParameterInfo::getAttributes() const @@ -99,9 +99,9 @@ namespace osgIntrospection return attribs_; } - inline const Value &ParameterInfo::getDefaultValue() const + inline const Value& ParameterInfo::getDefaultValue() const { - return default_; + return default_; } } diff --git a/include/osgIntrospection/PropertyInfo b/include/osgIntrospection/PropertyInfo index 4031c1c7c..75448d86c 100644 --- a/include/osgIntrospection/PropertyInfo +++ b/include/osgIntrospection/PropertyInfo @@ -60,29 +60,29 @@ namespace osgIntrospection /// If the getter method has parameters, the property is considered /// 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) + PropertyInfo(const Type& decltype, const Type& ptype, const std::string& name, const MethodInfo* getm, const MethodInfo* setm) : CustomAttributeProvider(), - decltype_(decltype), - ptype_(ptype), - name_(name), - getm_(getm), - setm_(setm), - numm_(0), - addm_(0), - remm_(0), - is_array_(false) + _decltype(decltype), + _ptype(ptype), + _name(name), + _getm(getm), + _setm(setm), + _numm(0), + _addm(0), + _remm(0), + _is_array(false) { - if (getm_) + if (_getm) { - for (ParameterInfoList::size_type i=0; igetParameters().size(); ++i) - indices_.push_back(getm_->getParameters().at(i)); + for (ParameterInfoList::size_type i=0; i<_getm->getParameters().size(); ++i) + _indices.push_back(_getm->getParameters().at(i)); } else { - if (setm_) + if (_setm) { - for (ParameterInfoList::size_type i=0; i<(setm_->getParameters().size()-1); ++i) - indices_.push_back(setm_->getParameters().at(i)); + for (ParameterInfoList::size_type i=0; i<(_setm->getParameters().size()-1); ++i) + _indices.push_back(_setm->getParameters().at(i)); } } } @@ -92,17 +92,17 @@ namespace osgIntrospection /// declares the property, the Type object that describes the /// type of the property's value, the property name and the /// 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) + 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), - getm_(getm), - setm_(setm), - numm_(numm), - addm_(addm), - remm_(remm), - is_array_(true) + _decltype(decltype), + _ptype(ptype), + _name(name), + _getm(getm), + _setm(setm), + _numm(numm), + _addm(addm), + _remm(remm), + _is_array(true) { } @@ -113,83 +113,83 @@ namespace osgIntrospection } /// Returns the name of the property being described. - inline virtual const std::string &getName() const + inline virtual const std::string& getName() const { - return name_; + return _name; } /// Returns the type that declares the property. - inline virtual const Type &getDeclaringType() const + inline virtual const Type& getDeclaringType() const { - return decltype_; + return _decltype; } /// Returns the type of the reflected property. - inline const Type &getPropertyType() const + inline const Type& getPropertyType() const { const PropertyTypeAttribute *pta = getAttribute(false); if (pta) return pta->getPropertyType(); - return ptype_; + return _ptype; } /// Returns the getter method. - inline const MethodInfo *getGetMethod() const + inline const MethodInfo* getGetMethod() const { - return getm_; + return _getm; } /// Returns the setter method. - inline const MethodInfo *getSetMethod() const + inline const MethodInfo* getSetMethod() const { - return setm_; + return _setm; } /// Returns the counter method. - inline const MethodInfo *getCountMethod() const + inline const MethodInfo* getCountMethod() const { - return numm_; + return _numm; } /// Returns the adder method. - inline const MethodInfo *getAddMethod() const + inline const MethodInfo* getAddMethod() const { - return addm_; + return _addm; } /// Returns the remover method. - inline const MethodInfo *getRemoveMethod() const + inline const MethodInfo* getRemoveMethod() const { - return remm_; + return _remm; } /// Returns whether the property's value can be retrieved. inline bool canGet() const { - return (getm_ != 0) || isDefined(false); + return (_getm != 0) || isDefined(false); } /// Returns whether the property's value can be set. inline bool canSet() const { - return setm_ != 0 || isDefined(false); + return _setm != 0 || isDefined(false); } /// Returns whether the property's array of values can be counted. inline bool canCount() const { - return numm_ != 0 || isDefined(false); + return _numm != 0 || isDefined(false); } /// Returns whether items can be added to the array property. inline bool canAdd() const { - return addm_ != 0 || isDefined(false); + return _addm != 0 || isDefined(false); } /// Returns whether items can be removed from the array property. inline bool canRemove() const { - return remm_ != 0 || isDefined(false); + return _remm != 0 || isDefined(false); } @@ -208,81 +208,81 @@ namespace osgIntrospection /// Returns whether the property is an array. inline bool isArray() const { - return is_array_; + return _is_array; } /// Returns the list of index parameters. /// If the property is not indexed, this list is empty. If neither /// the get method nor the set method are defined, this list is /// empty unless a custom indexing attribute is defined. - const ParameterInfoList &getIndexParameters() const; + const ParameterInfoList& getIndexParameters() const; /// Returns a list of valid values that can be used for the specified /// index. If a custom indexing attribute is defined for this property, /// then it will be queried for the index set, otherwise the index /// will be treated as an enumeration and the set of enumeration /// values will be returned. - void getIndexValueSet(int whichindex, const Value &instance, ValueList &values) const; + void getIndexValueSet(int whichindex, const Value& instance, ValueList& values) const; /// 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; + 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; + 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; + 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; + 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. - Value getIndexedValue(const Value &instance, ValueList &indices) const; + Value getIndexedValue(const Value& instance, ValueList& indices) const; /// Invokes the setter method on the given instance passing a list /// of indices and sets the indexed property's value. If a custom /// setter attribute is defined, it will be invoked instead. - void setIndexedValue(Value &instance, ValueList &indices, const Value &value) const; + void setIndexedValue(Value& instance, ValueList& indices, const Value& value) const; /// Invokes the counter method on the given instance and returns /// the number of items of the array property. If a custom counter /// attribute is defined, it will be invoked instead. - int getNumArrayItems(const Value &instance) const; + int getNumArrayItems(const Value& instance) const; /// 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; + 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; + 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. - void setArrayItem(Value &instance, int i, const Value &value) const; + void setArrayItem(Value& instance, int i, const Value& value) const; /// Invokes the adder method on the given instance and adds /// 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; + 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; + 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 @@ -292,19 +292,19 @@ namespace osgIntrospection Value getDefaultValue() const; protected: - virtual void getInheritedProviders(CustomAttributeProviderList &providers) const; + virtual void getInheritedProviders(CustomAttributeProviderList& providers) const; private: - const Type &decltype_; - const Type &ptype_; - std::string name_; - const MethodInfo *getm_; - const MethodInfo *setm_; - const MethodInfo *numm_; - const MethodInfo *addm_; - const MethodInfo *remm_; - ParameterInfoList indices_; - bool is_array_; + const Type& _decltype; + const Type& _ptype; + std::string _name; + const MethodInfo* _getm; + 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 29a996e0e..b71bed212 100644 --- a/include/osgIntrospection/ReaderWriter +++ b/include/osgIntrospection/ReaderWriter @@ -56,16 +56,16 @@ namespace osgIntrospection }; /// Writes a textual representation of the value's content to a stream. - virtual std::ostream &writeTextValue(std::ostream &, const Value &v, const Options* = 0) const { throw StreamingNotSupportedException(StreamingNotSupportedException::TEXT_WRITE, v.getType().getStdTypeInfo()); } + virtual std::ostream &writeTextValue(std::ostream &, const Value& v, const Options* = 0) const { throw StreamingNotSupportedException(StreamingNotSupportedException::TEXT_WRITE, v.getType().getStdTypeInfo()); } /// Reads a textual representation of the value's content from a stream. - virtual std::istream &readTextValue(std::istream &, Value &v, const Options* = 0) const { throw StreamingNotSupportedException(StreamingNotSupportedException::TEXT_READ, v.getType().getStdTypeInfo()); } + virtual std::istream &readTextValue(std::istream &, Value& v, const Options* = 0) const { throw StreamingNotSupportedException(StreamingNotSupportedException::TEXT_READ, v.getType().getStdTypeInfo()); } /// Writes a binary representation of the value's content to a stream. - virtual std::ostream &writeBinaryValue(std::ostream &, const Value &v, const Options* = 0) const { throw StreamingNotSupportedException(StreamingNotSupportedException::BINARY_WRITE, v.getType().getStdTypeInfo()); } + virtual std::ostream &writeBinaryValue(std::ostream &, const Value& v, const Options* = 0) const { throw StreamingNotSupportedException(StreamingNotSupportedException::BINARY_WRITE, v.getType().getStdTypeInfo()); } /// Reads a binary representation of the value's content from a stream. - virtual std::istream &readBinaryValue(std::istream &, Value &v, const Options* = 0) const { throw StreamingNotSupportedException(StreamingNotSupportedException::BINARY_READ, v.getType().getStdTypeInfo()); } + virtual std::istream &readBinaryValue(std::istream &, Value& v, const Options* = 0) const { throw StreamingNotSupportedException(StreamingNotSupportedException::BINARY_READ, v.getType().getStdTypeInfo()); } /// Virtual destructor. virtual ~ReaderWriter() {} @@ -83,23 +83,23 @@ namespace osgIntrospection class StdReaderWriter: public ReaderWriter { public: - virtual std::ostream &writeTextValue(std::ostream &os, const Value &v, const Options * = 0) const + virtual std::ostream &writeTextValue(std::ostream &os, const Value& v, const Options * = 0) const { return (os << variant_cast(v)); } - virtual std::istream &readTextValue(std::istream &is, Value &v, const Options * = 0) const + virtual std::istream &readTextValue(std::istream &is, Value& v, const Options * = 0) const { if (v.isEmpty()) v = Value(T()); return (is >> variant_cast(v)); } - virtual std::ostream &writeBinaryValue(std::ostream &os, const Value &v, const 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 * = 0) const + virtual std::istream &readBinaryValue(std::istream &is, Value& v, const Options * = 0) const { if (v.isEmpty()) v = Value(T()); return is.read(reinterpret_cast(extract_raw_data(v)), sizeof(T)); @@ -114,14 +114,14 @@ namespace osgIntrospection template class EnumReaderWriter: public ReaderWriter { - virtual std::ostream &writeTextValue(std::ostream &os, const Value &v, const Options *options = 0) const + virtual std::ostream &writeTextValue(std::ostream &os, const Value& v, const Options *options = 0) const { int numeric = static_cast(variant_cast(v)); if (!options || !options->getForceNumericOutput()) { - const Type &type = v.getType(); - const EnumLabelMap &elm = type.getEnumLabels(); + const Type& type = v.getType(); + const EnumLabelMap& elm = type.getEnumLabels(); EnumLabelMap::const_iterator i = elm.find(numeric); if (i != elm.end()) { @@ -158,7 +158,7 @@ namespace osgIntrospection return os << numeric; } - virtual std::istream &readTextValue(std::istream &is, Value &v, const Options * = 0) const + virtual std::istream &readTextValue(std::istream &is, Value& v, const Options * = 0) const { if (v.isEmpty()) v = Value(T()); @@ -174,8 +174,8 @@ namespace osgIntrospection std::string s; if (is >> s) { - const Type &type = v.getType(); - const EnumLabelMap &elm = type.getEnumLabels(); + const Type& type = v.getType(); + const EnumLabelMap& elm = type.getEnumLabels(); for (EnumLabelMap::const_iterator i=elm.begin(); i!=elm.end(); ++i) { if (i->second.compare(s) == 0) @@ -189,12 +189,12 @@ namespace osgIntrospection return is; } - virtual std::ostream &writeBinaryValue(std::ostream &os, const Value &v, const 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 * = 0) const + virtual std::istream &readBinaryValue(std::istream &is, Value& v, const Options * = 0) const { if (v.isEmpty()) v = Value(T()); @@ -209,12 +209,12 @@ namespace osgIntrospection class PtrReaderWriter: public ReaderWriter { public: - virtual std::ostream &writeTextValue(std::ostream &os, const Value &v, const Options* = 0) const + virtual std::ostream &writeTextValue(std::ostream &os, const Value& v, const Options* = 0) const { return (os << (void*)variant_cast(v)); } - virtual std::istream &readTextValue(std::istream &is, Value &v, const Options* = 0) const + virtual std::istream &readTextValue(std::istream &is, Value& v, const Options* = 0) const { void *ptr; is >> ptr; @@ -222,12 +222,12 @@ namespace osgIntrospection return is; } - virtual std::ostream &writeBinaryValue(std::ostream &os, const Value &v, const 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* = 0) const + virtual std::istream &readBinaryValue(std::istream &is, Value& v, const Options* = 0) const { T ptr; is.read(reinterpret_cast(&ptr), sizeof(T)); diff --git a/include/osgIntrospection/Reflection b/include/osgIntrospection/Reflection index 61c995402..8704c14c7 100644 --- a/include/osgIntrospection/Reflection +++ b/include/osgIntrospection/Reflection @@ -32,7 +32,7 @@ namespace osgIntrospection class Type; struct Converter; - typedef std::vector ConverterList; + typedef std::vector ConverterList; /// This predicate compares two instances of std::type_info for equality. /// Note that we can't rely on default pointer comparison because it is @@ -40,14 +40,14 @@ namespace osgIntrospection /// given T (thanks Andrew Koenig). struct TypeInfoCmp { - bool operator()(const std::type_info *t1, const std::type_info *t2) const + bool operator()(const std::type_info* t1, const std::type_info* t2) const { return t1->before(*t2) != 0; } }; /// A map of types, indexed by their associated type_info structure. - typedef std::map TypeMap; + typedef std::map TypeMap; /// This class provides basic reflection services such as registration @@ -61,24 +61,24 @@ namespace osgIntrospection /// Please note that such type will have the status of /// "declared", you still need to give details about it through /// a Reflector class before you can query it. - static const Type &getType(const std::type_info &ti); + static const Type& getType(const std::type_info& ti); /// Finds a Type object given its qualified name, which must /// be identical to the qualified name returned by that Type's /// getQualifiedName() method. If the type hasn't been created /// yet, an exception is thrown. - static const Type &getType(const std::string &qname); + static const Type& getType(const std::string& qname); /// Returns the global map of types. - static const TypeMap &getTypes(); + static const TypeMap& getTypes(); /// Return the Type object associated to the C++ type 'void'. /// This is a shortcut for typeof(void), which may be slow if /// the type map is large. - static const Type &type_void(); + static const Type& type_void(); - static const Converter *getConverter(const Type &source, const Type &dest); - static bool getConversionPath(const Type &source, const Type &dest, ConverterList &conv); + static const Converter* getConverter(const Type& source, const Type& dest); + static bool getConversionPath(const Type& source, const Type& dest, ConverterList& conv); private: template friend class Reflector; @@ -88,23 +88,23 @@ namespace osgIntrospection struct StaticData { TypeMap typemap; - const Type *type_void; + const Type* type_void; - typedef std::map ConverterMap; - typedef std::map ConverterMapMap; + typedef std::map ConverterMap; + typedef std::map ConverterMapMap; ConverterMapMap convmap; ~StaticData(); }; - static StaticData &getOrCreateStaticData(); - static Type *registerType(const std::type_info &ti); - static Type *getOrRegisterType(const std::type_info &ti, bool replace_if_defined = false); - static void registerConverter(const Type &source, const Type &dest, const Converter *cvt); + static StaticData& getOrCreateStaticData(); + static Type* registerType(const std::type_info& ti); + static Type* getOrRegisterType(const std::type_info& ti, bool replace_if_defined = false); + static void registerConverter(const Type& source, const Type& dest, const Converter* cvt); private: - static bool accum_conv_path(const Type &source, const Type &dest, ConverterList &conv, std::vector &chain); - static StaticData *staticdata__; + static bool accum_conv_path(const Type& source, const Type& dest, ConverterList& conv, std::vector &chain); + static StaticData* _static_data; }; } diff --git a/include/osgIntrospection/ReflectionMacros b/include/osgIntrospection/ReflectionMacros index fea69cf36..3af9dcf76 100644 --- a/include/osgIntrospection/ReflectionMacros +++ b/include/osgIntrospection/ReflectionMacros @@ -36,24 +36,24 @@ // -------------------------------------------------------------------------- #define TYPE_NAME_ALIAS(t, n) \ - namespace { osgIntrospection::TypeNameAliasProxy OSG_RM_LINEID(tnalias) (#n); } - + namespace { osgIntrospection::TypeNameAliasProxy OSG_RM_LINEID(tnalias) (#n); } + // -------------------------------------------------------------------------- // TYPE CONVERTERS // -------------------------------------------------------------------------- #define Converter(s, d, c) \ - namespace { osgIntrospection::ConverterProxy OSG_RM_LINEID(cvt) (s, d, new c); } + namespace { osgIntrospection::ConverterProxy OSG_RM_LINEID(cvt) (s, d, new c); } #define StaticConverter(s, d) \ - Converter(s, d, osgIntrospection::StaticConverter); + Converter(s, d, osgIntrospection::StaticConverter); #define DynamicConverter(s, d) \ - Converter(s, d, osgIntrospection::DynamicConverter); - + Converter(s, d, osgIntrospection::DynamicConverter); + #define ReinterpretConverter(s, d) \ - Converter(s, d, osgIntrospection::ReinterpretConverter); + Converter(s, d, osgIntrospection::ReinterpretConverter); // -------------------------------------------------------------------------- @@ -61,40 +61,40 @@ // -------------------------------------------------------------------------- #define ABSTRACT_OBJECT_REFLECTOR(t) \ - namespace { osgIntrospection::AbstractObjectReflector OSG_RM_LINEID(reflector) (#t); } + namespace { osgIntrospection::AbstractObjectReflector OSG_RM_LINEID(reflector) (#t); } #define ATOMIC_VALUE_REFLECTOR(t) \ - namespace { osgIntrospection::AtomicValueReflector OSG_RM_LINEID(reflector) (#t); } + namespace { osgIntrospection::AtomicValueReflector OSG_RM_LINEID(reflector) (#t); } #define STD_PAIR_REFLECTOR(t) \ - namespace { osgIntrospection::StdPairReflector OSG_RM_LINEID(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); } + namespace { osgIntrospection::StdPairReflector OSG_RM_LINEID(reflector) (#t); } #define STD_VECTOR_REFLECTOR(t) \ - namespace { osgIntrospection::StdVectorReflector OSG_RM_LINEID(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); } + namespace { osgIntrospection::StdVectorReflector OSG_RM_LINEID(reflector) (#t); } #define STD_LIST_REFLECTOR(t) \ - namespace { osgIntrospection::StdListReflector OSG_RM_LINEID(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); } + namespace { osgIntrospection::StdListReflector OSG_RM_LINEID(reflector) (#t); } #define STD_SET_REFLECTOR(t) \ - namespace { osgIntrospection::StdSetReflector OSG_RM_LINEID(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); } + namespace { osgIntrospection::StdSetReflector OSG_RM_LINEID(reflector) (#t); } #define STD_MAP_REFLECTOR(t) \ - namespace { osgIntrospection::StdMapReflector OSG_RM_LINEID(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); } + namespace { osgIntrospection::StdMapReflector OSG_RM_LINEID(reflector) (#t); } // -------------------------------------------------------------------------- @@ -109,10 +109,10 @@ // out because it seems to confuse the MSVC++ compiler. // Anyway, static should be ok. //namespace -//{ - static inline void sink(const osgIntrospection::CustomAttributeProvider *) - { - } +//{ + static inline void sink(const osgIntrospection::CustomAttributeProvider *) + { + } //} @@ -146,31 +146,31 @@ #define Comparator(x) setComparator(new x); #define BaseType(x) \ - { \ - addBaseType(typeof(x)); \ - const osgIntrospection::Type &st = typeof(reflected_type *); \ - const osgIntrospection::Type &cst = typeof(const reflected_type *); \ - const osgIntrospection::Type &dt = typeof(x *); \ - const osgIntrospection::Type &cdt = typeof(const x *); \ - osgIntrospection::ConverterProxy cp1(st, dt, new osgIntrospection::StaticConverter); \ - osgIntrospection::ConverterProxy cp2(cst, cdt, new osgIntrospection::StaticConverter); \ - osgIntrospection::ConverterProxy cp1c(st, cdt, new osgIntrospection::StaticConverter); \ - osgIntrospection::ConverterProxy cp3(dt, st, new osgIntrospection::StaticConverter); \ - osgIntrospection::ConverterProxy cp4(cdt, cst, new osgIntrospection::StaticConverter); \ - osgIntrospection::ConverterProxy cp3c(dt, cst, new osgIntrospection::StaticConverter); \ - } + { \ + addBaseType(typeof(x)); \ + const osgIntrospection::Type& st = typeof(reflected_type* ); \ + const osgIntrospection::Type& cst = typeof(const reflected_type* ); \ + const osgIntrospection::Type& dt = typeof(x *); \ + const osgIntrospection::Type& cdt = typeof(const x *); \ + osgIntrospection::ConverterProxy cp1(st, dt, new osgIntrospection::StaticConverter); \ + osgIntrospection::ConverterProxy cp2(cst, cdt, new osgIntrospection::StaticConverter); \ + osgIntrospection::ConverterProxy cp1c(st, cdt, new osgIntrospection::StaticConverter); \ + osgIntrospection::ConverterProxy cp3(dt, st, new osgIntrospection::StaticConverter); \ + osgIntrospection::ConverterProxy cp4(cdt, cst, new osgIntrospection::StaticConverter); \ + osgIntrospection::ConverterProxy cp3c(dt, cst, new osgIntrospection::StaticConverter); \ + } #define VirtualBaseType(x) \ - { \ - addBaseType(typeof(x)); \ - const osgIntrospection::Type &st = typeof(reflected_type *); \ - const osgIntrospection::Type &cst = typeof(const reflected_type *); \ - const osgIntrospection::Type &dt = typeof(x *); \ - const osgIntrospection::Type &cdt = typeof(const x *); \ - osgIntrospection::ConverterProxy cp1(st, dt, new osgIntrospection::StaticConverter); \ - osgIntrospection::ConverterProxy cp2(cst, cdt, new osgIntrospection::StaticConverter); \ - osgIntrospection::ConverterProxy cp1c(st, cdt, new osgIntrospection::StaticConverter); \ - } + { \ + addBaseType(typeof(x)); \ + const osgIntrospection::Type& st = typeof(reflected_type* ); \ + const osgIntrospection::Type& cst = typeof(const reflected_type* ); \ + const osgIntrospection::Type& dt = typeof(x *); \ + const osgIntrospection::Type& cdt = typeof(const x *); \ + osgIntrospection::ConverterProxy cp1(st, dt, new osgIntrospection::StaticConverter); \ + osgIntrospection::ConverterProxy cp2(cst, cdt, new osgIntrospection::StaticConverter); \ + osgIntrospection::ConverterProxy cp1c(st, cdt, new osgIntrospection::StaticConverter); \ + } #define EnumLabel(x) addEnumLabel(x, #x, true); @@ -325,25 +325,25 @@ #define Constructor0() (\ params.clear(), \ - addConstructor(new osgIntrospection::TypedConstructorInfo0(params))) + 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))) + 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))) + 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))) + addConstructor(new osgIntrospection::TypedConstructorInfo3(params))) #define Constructor4(A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3) (\ params.clear(), \ @@ -351,7 +351,7 @@ 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))) + addConstructor(new osgIntrospection::TypedConstructorInfo4(params))) #define Constructor5(A0, P0, N0, A1, P1, N1, A2, P2, N2, A3, P3, N3, A4, P4, N4) (\ params.clear(), \ @@ -360,7 +360,7 @@ 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))) + 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(), \ @@ -370,7 +370,7 @@ 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))) + 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(), \ @@ -381,7 +381,7 @@ 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))) + 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(), \ @@ -393,7 +393,7 @@ 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))) + 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(), \ @@ -406,7 +406,7 @@ 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))) + 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(), \ @@ -420,7 +420,7 @@ 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))) + 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(), \ @@ -435,7 +435,7 @@ 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))) + 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(), \ @@ -451,7 +451,7 @@ 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))) + 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(), \ @@ -468,7 +468,7 @@ 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))) + 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(), \ @@ -486,7 +486,7 @@ 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))) + 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(), \ @@ -505,7 +505,7 @@ 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))) + 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(), \ @@ -525,29 +525,29 @@ 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))) + addConstructor(new osgIntrospection::TypedConstructorInfo16(params))) #define ConstructorWithDefaults0() (\ params.clear(), \ - addConstructor(new osgIntrospection::TypedConstructorInfo0(params))) + 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))) + 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))) + 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))) + 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(), \ @@ -555,7 +555,7 @@ 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))) + 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(), \ @@ -564,7 +564,7 @@ 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))) + 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(), \ @@ -574,7 +574,7 @@ 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))) + 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(), \ @@ -585,7 +585,7 @@ 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))) + 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(), \ @@ -597,7 +597,7 @@ 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))) + 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(), \ @@ -610,7 +610,7 @@ 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))) + 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(), \ @@ -624,7 +624,7 @@ 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))) + 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(), \ @@ -639,7 +639,7 @@ 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))) + 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(), \ @@ -655,7 +655,7 @@ 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))) + 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(), \ @@ -672,7 +672,7 @@ 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))) + 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(), \ @@ -690,7 +690,7 @@ 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))) + 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(), \ @@ -709,7 +709,7 @@ 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))) + 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(), \ @@ -729,7 +729,7 @@ 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))) + addConstructor(new osgIntrospection::TypedConstructorInfo16(params))) // -------------------------------------------------------------------------- diff --git a/include/osgIntrospection/Reflector b/include/osgIntrospection/Reflector index 9fc934454..9ecdf2717 100644 --- a/include/osgIntrospection/Reflector +++ b/include/osgIntrospection/Reflector @@ -63,76 +63,76 @@ namespace osgIntrospection protected: /// Direct initialization constructor. Parameter 'name' is the name /// of the type being reflected and 'ns' is its namespace. - Reflector(const std::string &name, const std::string &ns, bool abstract = false); + 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 "::"). - Reflector(const std::string &qname, bool abstract = false); + Reflector(const std::string& qname, bool abstract = false); protected: /// Returns the Type object being described. - Type *getType() { return type_; } + Type* getType() { return _type; } /// Declares a new base type for the current type. - void addBaseType(const Type &type); + void addBaseType(const Type& type); /// Sets the comparator object for the current type. - void setComparator(const Comparator *cmp); + void setComparator(const Comparator* cmp); /// Adds a property description to the current type. - PropertyInfo *addProperty(PropertyInfo *pi); + PropertyInfo* addProperty(PropertyInfo* pi); /// Adds a method description to the current type. - MethodInfo *addMethod(MethodInfo *mi); + MethodInfo* addMethod(MethodInfo* mi); /// Adds an enumeration label to the current type. - void addEnumLabel(int v, const std::string &label, bool strip_namespace = true); + void addEnumLabel(int v, const std::string& label, bool strip_namespace = true); /// 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); + ConstructorInfo* addConstructor(ConstructorInfo* ci); /// Returns a string containing the qualified version of 'name'. - std::string qualifyName(const std::string name) const; + std::string qualifyName(const std::string& name) const; /// Adds a custom attribute to the type being described. - CustomAttributeProvider *addAttribute(const CustomAttribute *attrib); + CustomAttributeProvider *addAttribute(const CustomAttribute* attrib); /// Sets the current type's ReaderWriter object. - void setReaderWriter(const ReaderWriter *rw); + void setReaderWriter(const ReaderWriter* rw); private: - struct PtrConstructor: ConstructorInfo - { - PtrConstructor(const Type *pt) - : ConstructorInfo(*pt, ParameterInfoList()) - { - } + 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; } - }; - + 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); + 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_; + typedef std::vector TempMethodList; + TempMethodList _temp_methods; + Type* _type; }; /// This reflector ought to be used to describe types that can be @@ -144,14 +144,14 @@ namespace osgIntrospection struct ValueReflector: Reflector { typedef ValueReflector inherited; - typedef ValueInstanceCreator::reflected_type> instance_creator_type; + typedef ValueInstanceCreator::reflected_type> instance_creato_rtype; - ValueReflector(const std::string &name, const std::string &ns) + ValueReflector(const std::string& name, const std::string& ns) : Reflector(name, ns, false) { } - ValueReflector(const std::string &qname) + ValueReflector(const std::string& qname) : Reflector(qname, false) { } @@ -164,14 +164,14 @@ namespace osgIntrospection struct AbstractObjectReflector: Reflector { typedef AbstractObjectReflector inherited; - typedef DummyInstanceCreator::reflected_type> instance_creator_type; + typedef DummyInstanceCreator::reflected_type> instance_creato_rtype; - AbstractObjectReflector(const std::string &name, const std::string &ns) + AbstractObjectReflector(const std::string& name, const std::string& ns) : Reflector(name, ns, true) { } - AbstractObjectReflector(const std::string &qname) + AbstractObjectReflector(const std::string& qname) : Reflector(qname, true) { } @@ -186,14 +186,14 @@ namespace osgIntrospection struct ObjectReflector: Reflector { typedef ObjectReflector inherited; - typedef ObjectInstanceCreator::reflected_type> instance_creator_type; + typedef ObjectInstanceCreator::reflected_type> instance_creato_rtype; - ObjectReflector(const std::string &name, const std::string &ns) + ObjectReflector(const std::string& name, const std::string& ns) : Reflector(name, ns, false) { } - ObjectReflector(const std::string &qname) + ObjectReflector(const std::string& qname) : Reflector(qname, false) { } @@ -206,22 +206,22 @@ namespace osgIntrospection template struct AtomicValueReflector: ValueReflector { - typedef typename ValueReflector::instance_creator_type instance_creator_type; - - AtomicValueReflector(const std::string &name, const std::string &ns) + typedef typename ValueReflector::instance_creato_rtype instance_creato_rtype; + + AtomicValueReflector(const std::string& name, const std::string& ns) : ValueReflector(name, ns) { - setReaderWriter(new StdReaderWriter); - setComparator(new PartialOrderComparator); - addConstructor(new TypedConstructorInfo0(ParameterInfoList())); + setReaderWriter(new StdReaderWriter); + setComparator(new PartialOrderComparator); + addConstructor(new TypedConstructorInfo0(ParameterInfoList())); } - AtomicValueReflector(const std::string &qname) + AtomicValueReflector(const std::string& qname) : ValueReflector(qname) { - setReaderWriter(new StdReaderWriter); - setComparator(new PartialOrderComparator); - addConstructor(new TypedConstructorInfo0(ParameterInfoList())); + setReaderWriter(new StdReaderWriter); + setComparator(new PartialOrderComparator); + addConstructor(new TypedConstructorInfo0(ParameterInfoList())); } }; @@ -232,22 +232,22 @@ namespace osgIntrospection struct EnumReflector: ValueReflector { typedef EnumReflector inherited; - typedef typename ValueReflector::instance_creator_type instance_creator_type; + typedef typename ValueReflector::instance_creato_rtype instance_creato_rtype; - EnumReflector(const std::string &name, const std::string &ns) + EnumReflector(const std::string& name, const std::string& ns) : ValueReflector(name, ns) { - setReaderWriter(new EnumReaderWriter); - setComparator(new TotalOrderComparator); - addConstructor(new TypedConstructorInfo0(ParameterInfoList())); + setReaderWriter(new EnumReaderWriter); + setComparator(new TotalOrderComparator); + addConstructor(new TypedConstructorInfo0(ParameterInfoList())); } - EnumReflector(const std::string &qname) + EnumReflector(const std::string& qname) : ValueReflector(qname) { - setReaderWriter(new EnumReaderWriter); - setComparator(new TotalOrderComparator); - addConstructor(new TypedConstructorInfo0(ParameterInfoList())); + setReaderWriter(new EnumReaderWriter); + setComparator(new TotalOrderComparator); + addConstructor(new TypedConstructorInfo0(ParameterInfoList())); } }; @@ -257,66 +257,66 @@ namespace osgIntrospection template struct StdVectorReflector: ValueReflector { - typedef typename ValueReflector::instance_creator_type instance_creator_type; - + typedef typename ValueReflector::instance_creato_rtype instance_creato_rtype; + struct Getter: PropertyGetter { - virtual Value get(Value &instance, int i) const + virtual Value get(Value& instance, int i) const { - T &ctr = variant_cast(instance); + T& ctr = variant_cast(instance); return ctr.at(i); } - virtual Value get(const Value &instance, int i) const + virtual Value get(const Value& instance, int i) const { - const T &ctr = variant_cast(instance); + const T& ctr = variant_cast(instance); return ctr.at(i); } }; struct Setter: PropertySetter { - virtual void set(Value &instance, int i, const Value &v) const + virtual void set(Value& instance, int i, const Value& v) const { - T &ctr = variant_cast(instance); - ctr.at(i) = variant_cast(v); + T& ctr = variant_cast(instance); + ctr.at(i) = variant_cast(v); } }; struct Counter: PropertyCounter { - virtual int count(const Value &instance) const + virtual int count(const Value& instance) const { - const T &ctr = variant_cast(instance); + const T& ctr = variant_cast(instance); return static_cast(ctr.size()); } }; struct Adder: PropertyAdder { - virtual void add(Value &instance, const Value &v) const + virtual void add(Value& instance, const Value& v) const { - T &ctr = variant_cast(instance); - ctr.push_back(variant_cast(v)); + 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); - } + 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) + 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); + 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)); @@ -338,21 +338,21 @@ namespace osgIntrospection template struct StdSetReflector: ValueReflector { - typedef typename ValueReflector::instance_creator_type instance_creator_type; - + typedef typename ValueReflector::instance_creato_rtype instance_creato_rtype; + struct Getter: PropertyGetter { - virtual Value get(Value &instance, int i) const + virtual Value get(Value& instance, int i) const { - T &ctr = variant_cast(instance); + 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 + virtual Value get(const Value& instance, int i) const { - const T &ctr = variant_cast(instance); + const T& ctr = variant_cast(instance); typename T::const_iterator j=ctr.begin(); std::advance(j, i); return *j; @@ -361,38 +361,38 @@ namespace osgIntrospection struct Counter: PropertyCounter { - virtual int count(const Value &instance) const + virtual int count(const Value& instance) const { - const T &ctr = variant_cast(instance); + const T& ctr = variant_cast(instance); return static_cast(ctr.size()); } }; struct Adder: PropertyAdder { - virtual void add(Value &instance, const Value &v) const + virtual void add(Value& instance, const Value& v) const { - T &ctr = variant_cast(instance); - ctr.insert(variant_cast(v)); + 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); - } + 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) + 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); + 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)); @@ -413,21 +413,21 @@ namespace osgIntrospection template struct StdListReflector: ValueReflector { - typedef typename ValueReflector::instance_creator_type instance_creator_type; - + typedef typename ValueReflector::instance_creato_rtype instance_creato_rtype; + struct Getter: PropertyGetter { - virtual Value get(Value &instance, int i) const + virtual Value get(Value& instance, int i) const { - T &ctr = variant_cast(instance); + 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 + virtual Value get(const Value& instance, int i) const { - const T &ctr = variant_cast(instance); + const T& ctr = variant_cast(instance); typename T::const_iterator j=ctr.begin(); std::advance(j, i); return *j; @@ -436,49 +436,49 @@ namespace osgIntrospection struct Setter: PropertySetter { - virtual void set(Value &instance, int i, const Value &v) const + virtual void set(Value& instance, int i, const Value& v) const { - T &ctr = variant_cast(instance); + T& ctr = variant_cast(instance); typename T::iterator j=ctr.begin(); std::advance(j, i); - *j = variant_cast(v); + *j = variant_cast(v); } }; struct Counter: PropertyCounter { - virtual int count(const Value &instance) const + virtual int count(const Value& instance) const { - const T &ctr = variant_cast(instance); + const T& ctr = variant_cast(instance); return static_cast(ctr.size()); } }; struct Adder: PropertyAdder { - virtual void add(Value &instance, const Value &v) const + virtual void add(Value& instance, const Value& v) const { - T &ctr = variant_cast(instance); - ctr.push_back(variant_cast(v)); + 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); - } + 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) + 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); + 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)); @@ -500,29 +500,29 @@ namespace osgIntrospection template struct StdMapReflector: ValueReflector { - typedef typename ValueReflector::instance_creator_type instance_creator_type; - - typedef typename T::iterator iterator; + typedef typename ValueReflector::instance_creato_rtype instance_creato_rtype; + + 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 + virtual Value get(Value& instance, const ValueList& indices) const { - T& ctr = variant_cast(instance); - const key_type& key = variant_cast(indices.front()); + 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 + virtual Value get(const Value& instance, const ValueList& indices) const { - const T& ctr = variant_cast(instance); - const key_type& key = variant_cast(indices.front()); + const T& ctr = variant_cast(instance); + const key_type& key = variant_cast(indices.front()); const_iterator i = ctr.find(key); if (i == ctr.end()) return Value(); @@ -532,51 +532,51 @@ namespace osgIntrospection struct Setter: PropertySetter { - virtual void set(Value &instance, const ValueList &indices, const Value &v) const + virtual void set(Value& instance, const ValueList& indices, const Value& v) const { - T &ctr = variant_cast(instance); - ctr.insert(std::make_pair(variant_cast(indices.front()), variant_cast(v))); + T& ctr = variant_cast(instance); + ctr.insert(std::make_pair(variant_cast(indices.front()), variant_cast(v))); } }; struct Indexer: IndexInfo { - ParameterInfoList params_; - const Type &itype_; + ParameterInfoList _params; + const Type& _itype; Indexer() - : itype_(typeof(IT)) + : _itype(typeof(IT)) { - params_.push_back(new ParameterInfo("key", typeof(key_type), 0, ParameterInfo::IN)); + _params.push_back(new ParameterInfo("key", typeof(key_type), 0, ParameterInfo::IN)); } virtual ~Indexer() { - delete params_.front(); + delete _params.front(); } - virtual const ParameterInfoList &getIndexParameters() const + virtual const ParameterInfoList& getIndexParameters() const { - return params_; + 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); + const T& ctr = variant_cast(instance); for (const_iterator i=ctr.begin(); i!=ctr.end(); ++i) { - values.push_back(Value(i->first).convertTo(itype_)); + values.push_back(Value(i->first).convertTo(_itype)); } } }; - StdMapReflector(const std::string &name): ValueReflector(name) + StdMapReflector(const std::string& name): ValueReflector(name) { - addConstructor(new TypedConstructorInfo0(ParameterInfoList())); - - PropertyInfo *pi = new PropertyInfo(typeof(T), typeof(typename T::mapped_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)); @@ -594,51 +594,51 @@ namespace osgIntrospection template struct StdPairReflector: ValueReflector { - typedef typename ValueReflector::instance_creator_type instance_creator_type; - + typedef typename ValueReflector::instance_creato_rtype instance_creato_rtype; + struct Accessor: PropertyGetter, PropertySetter { - Accessor(int i): i_(i) {} + Accessor(int i): _i(i) {} - virtual Value get(const Value &instance) const + virtual Value get(const Value& instance) const { - switch (i_) + switch (_i) { - case 0: return variant_cast(instance).first; - case 1: return variant_cast(instance).second; + case 0: return variant_cast(instance).first; + case 1: return variant_cast(instance).second; default: return Value(); } } - virtual Value get(Value &instance) const + virtual Value get(Value& instance) const { - switch (i_) + switch (_i) { - case 0: return variant_cast(instance).first; - case 1: return variant_cast(instance).second; + case 0: return variant_cast(instance).first; + case 1: return variant_cast(instance).second; default: return Value(); } } - virtual void set(const Value &instance, const Value &v) const + virtual void set(const Value& instance, const Value& v) const { - T &ctr = variant_cast(instance); + T& ctr = variant_cast(instance); - switch (i_) + switch (_i) { - case 0: ctr.first = variant_cast(v); break; - case 1: ctr.second = variant_cast(v); break; + case 0: ctr.first = variant_cast(v); break; + case 1: ctr.second = variant_cast(v); break; } } - int i_; + int _i; }; - StdPairReflector(const std::string &name): ValueReflector(name) + 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); + 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))); @@ -648,7 +648,7 @@ namespace osgIntrospection this->addProperty(pi1); - PropertyInfo *pi2 = new PropertyInfo(typeof(T), typeof(typename T::second_type), "second", 0, 0); + PropertyInfo* pi2 = new PropertyInfo(typeof(T), typeof(typename T::second_type), "second", 0, 0); pi2->addAttribute(new CustomPropertyGetAttribute(new Accessor(1))); pi2->addAttribute(new CustomPropertySetAttribute(new Accessor(1))); @@ -664,31 +664,31 @@ namespace osgIntrospection // TEMPLATE METHODS template - Reflector::Reflector(const std::string &name, const std::string &ns, bool abstract) - : type_(Reflection::getOrRegisterType(typeid(T), true)) + Reflector::Reflector(const std::string& name, const std::string& ns, bool abstract) + : _type(Reflection::getOrRegisterType(typeid(T), true)) { - 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; + 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, bool abstract) - : type_(Reflection::getOrRegisterType(typeid(T), true)) + Reflector::Reflector(const std::string& qname, bool abstract) + : _type(Reflection::getOrRegisterType(typeid(T), true)) { - if (!type_->name_.empty()) - type_->aliases_.push_back(purify(qname)); - else - { - split_qualified_name(purify(qname), type_->name_, type_->namespace_); - } - type_->is_abstract_ = abstract; + 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(); } @@ -696,137 +696,137 @@ namespace osgIntrospection void Reflector::init() { // pointer type - if (!type_->pointed_type_) + if (!_type->_pointed_type) { - Type *ptype = Reflection::getOrRegisterType(typeid(T*), true); - ptype->name_ = type_->name_; - ptype->namespace_ = type_->namespace_; - ptype->pointed_type_ = type_; - ptype->is_defined_ = true; - ptype->cons_.push_back(new PtrConstructor(ptype)); - ptype->rw_ = new PtrReaderWriter(); - ptype->cmp_ = new TotalOrderComparator(); + Type* ptype = Reflection::getOrRegisterType(typeid(T*), true); + ptype->_name = _type->_name; + ptype->_namespace = _type->_namespace; + ptype->_pointed_type = _type; + ptype->_is_defined = true; + 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_) + if (!_type->_pointed_type || !_type->_is_const) { - 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->cons_.push_back(new ConstPtrConstructor(cptype)); - cptype->rw_ = new PtrReaderWriter(); - cptype->cmp_ = new TotalOrderComparator(); + 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->_cons.push_back(new ConstPtrConstructor(cptype)); + cptype->_rw = new PtrReaderWriter(); + cptype->_cmp = new TotalOrderComparator(); } - type_->is_defined_ = true; + _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; + 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) + 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); - } + 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) + void Reflector::addBaseType(const Type& type) { - type_->base_.push_back(&type); + _type->_base.push_back(&type); } template - PropertyInfo *Reflector::addProperty(PropertyInfo *pi) + PropertyInfo* Reflector::addProperty(PropertyInfo* pi) { - type_->props_.push_back(pi); + _type->_props.push_back(pi); return pi; } template - MethodInfo *Reflector::addMethod(MethodInfo *mi) + 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); + 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; } template - void Reflector::addEnumLabel(int v, const std::string &label, bool strip_namespace) + void Reflector::addEnumLabel(int v, const std::string& label, bool strip_namespace) { if (strip_namespace) { std::string::size_type p = label.rfind("::"); if (p != std::string::npos) { - type_->labels_.insert(std::make_pair(v, label.substr(p+2))); + _type->_labels.insert(std::make_pair(v, label.substr(p+2))); return; } } - type_->labels_.insert(std::make_pair(v, label)); + _type->_labels.insert(std::make_pair(v, label)); } template - ConstructorInfo *Reflector::addConstructor(ConstructorInfo *ci) + ConstructorInfo* Reflector::addConstructor(ConstructorInfo* ci) { - type_->cons_.push_back(ci); + _type->_cons.push_back(ci); return ci; } template - std::string Reflector::qualifyName(const std::string name) const + std::string Reflector::qualifyName(const std::string& name) const { std::string s; - if (!type_->namespace_.empty()) + if (!_type->_namespace.empty()) { - s.append(type_->namespace_); + s.append(_type->_namespace); s.append("::"); } - if (!type_->name_.empty()) + if (!_type->_name.empty()) { - s.append(type_->name_); + s.append(_type->_name); s.append("::"); } s.append(name); @@ -834,21 +834,21 @@ namespace osgIntrospection } template - CustomAttributeProvider *Reflector::addAttribute(const CustomAttribute *attrib) + CustomAttributeProvider *Reflector::addAttribute(const CustomAttribute* attrib) { - return type_->addAttribute(attrib); + return _type->addAttribute(attrib); } template - void Reflector::setReaderWriter(const ReaderWriter *rw) + void Reflector::setReaderWriter(const ReaderWriter* rw) { - type_->rw_ = rw; + _type->_rw = rw; } template - void Reflector::setComparator(const Comparator *cmp) + void Reflector::setComparator(const Comparator* cmp) { - type_->cmp_ = cmp; + _type->_cmp = cmp; } } diff --git a/include/osgIntrospection/StaticMethodInfo b/include/osgIntrospection/StaticMethodInfo index 8bf2d05ca..c98fdb414 100644 --- a/include/osgIntrospection/StaticMethodInfo +++ b/include/osgIntrospection/StaticMethodInfo @@ -31,1192 +31,1192 @@ namespace osgIntrospection /// 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; } + 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_; - }; + 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_; + }; } diff --git a/include/osgIntrospection/Type b/include/osgIntrospection/Type index 385b6f3c6..2e63cd0c4 100644 --- a/include/osgIntrospection/Type +++ b/include/osgIntrospection/Type @@ -11,8 +11,8 @@ * OpenSceneGraph Public License for more details. */ //osgIntrospection - Copyright (C) 2005 Marco Jez -#ifndef OSGINTROSPECTION_TYPE_ -#define OSGINTROSPECTION_TYPE_ +#ifndef OSGINTROSPECTION__type +#define OSGINTROSPECTION__type #include #include @@ -37,10 +37,10 @@ namespace osgIntrospection struct Comparator; // typedefs for member info lists - typedef std::vector MethodInfoList; - typedef std::vector PropertyInfoList; - typedef std::vector ParameterInfoList; - typedef std::vector ConstructorInfoList; + 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; @@ -63,17 +63,17 @@ namespace osgIntrospection /// Returns a reference to the std::type_info instance associated /// to this Type. - inline const std::type_info &getStdTypeInfo() const; + inline const std::type_info& getStdTypeInfo() const; /// Returns true if this Type is defined, false if it's just /// declared. See class Reflector if you want to create a new Type. inline bool isDefined() const; /// Returns the name of the reflected type. - inline const std::string &getName() const; + inline const std::string& getName() const; /// Returns the namespace of the reflected type. - inline const std::string &getNamespace() const; + inline const std::string& getNamespace() const; /// Returns the qualified name of the reflected type. The qualified /// name is formed by the namespace, if present, plus other modifiers @@ -82,7 +82,7 @@ namespace osgIntrospection /// 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; + 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 @@ -90,13 +90,13 @@ namespace osgIntrospection inline int getNumBaseTypes() const; /// Returns the i-th base type. - inline const Type &getBaseType(int i) const; + 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; + const std::string& getAlias(int i) const; /// Returns whether the reflected type is abstract. inline bool isAbstract() const; @@ -124,154 +124,154 @@ namespace osgIntrospection /// Returns the pointed type. If the reflected type is not a pointer, /// the object returned is typeof(void). - inline const Type &getPointedType() const; + inline const Type& getPointedType() const; /// Returns the list of properties defined for this type. The list /// does not include properties inherited from base types. - inline const PropertyInfoList &getProperties() const; + inline const PropertyInfoList& getProperties() const; /// Fills a list of properties that are either defined in this Type /// or in inherited types. - void getAllProperties(PropertyInfoList &props) const; + void getAllProperties(PropertyInfoList& props) const; /// Returns the list of constructors defined for this type. - inline const ConstructorInfoList &getConstructors() const; + inline const ConstructorInfoList& getConstructors() const; /// Returns the list of methods defined for this type. The list /// does not include methods inherited from base types. - inline const MethodInfoList &getMethods() const; + inline const MethodInfoList& getMethods() const; /// Fills a list of methods that are either defined in this Type /// or in inherited types. - void getAllMethods(MethodInfoList &methods) const; + void getAllMethods(MethodInfoList& methods) const; /// Returns the map of enumeration labels. If the type is not an /// enumeration, an empty map is returned. - inline const EnumLabelMap &getEnumLabels() const; + 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; + 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; + const ConstructorInfo* getConstructor(const ParameterInfoList& params) 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. - const MethodInfo *getCompatibleMethod(const std::string &name, const ValueList &values, bool inherit) const; + const MethodInfo* getCompatibleMethod(const std::string& name, const ValueList& values, bool inherit) const; /// Searches for a method whose parameters match exactly the given /// list of parameter descriptions. - const MethodInfo *getMethod(const std::string &name, const ParameterInfoList ¶ms, bool inherit) const; + const MethodInfo* getMethod(const std::string& name, const ParameterInfoList& params, bool inherit) const; /// Searches for a property given its name, type and list of indices. /// Only exact matches are returned. - const PropertyInfo *getProperty(const std::string &name, const Type &ptype, const ParameterInfoList &indices, bool inherit) const; + const PropertyInfo* getProperty(const std::string& name, const Type& ptype, const ParameterInfoList& indices, bool inherit) const; /// Searches for a suitable method and invokes it with the given list /// of arguments (const instance). - Value invokeMethod(const std::string &name, const Value &instance, ValueList &args, bool inherit) const; + Value invokeMethod(const std::string& name, const Value& instance, ValueList& args, bool inherit) const; /// Searches for a suitable method and invokes it with the given list /// of arguments. - Value invokeMethod(const std::string &name, Value &instance, ValueList &args, bool inherit) const; + Value invokeMethod(const std::string& name, Value& instance, ValueList& args, bool inherit) const; /// Returns whether the reflected type is derived from another type. - bool isSubclassOf(const Type &type) const; + bool isSubclassOf(const Type& type) const; /// 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; + 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; + 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; + 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), - rw_(0), - cmp_(0) + Type(const std::type_info& ti) + : _ti(ti), + _is_const(false), + _is_abstract(false), + _pointed_type(0), + _is_defined(false), + _rw(0), + _cmp(0) { } // throws an exception if the type is not defined. void check_defined() const; - virtual void getInheritedProviders(CustomAttributeProviderList &providers) const; + virtual void getInheritedProviders(CustomAttributeProviderList& providers) const; private: template friend class Reflector; template friend struct TypeNameAliasProxy; friend class Reflection; - Type(const Type ©): CustomAttributeProvider(copy), ti_(copy.ti_) {} + Type(const Type& copy): CustomAttributeProvider(copy), _ti(copy._ti) {} - const std::type_info &ti_; + const std::type_info& _ti; - std::string name_; - std::string namespace_; + std::string _name; + std::string _namespace; - typedef std::vector TypeList; - TypeList base_; + typedef std::vector TypeList; + TypeList _base; - bool is_const_; - bool is_abstract_; - const Type *pointed_type_; + bool _is_const; + bool _is_abstract; + const Type* _pointed_type; - ConstructorInfoList cons_; - PropertyInfoList props_; - MethodInfoList methods_; + ConstructorInfoList _cons; + PropertyInfoList _props; + MethodInfoList _methods; - EnumLabelMap labels_; - bool is_defined_; + EnumLabelMap _labels; + bool _is_defined; - const ReaderWriter *rw_; - const Comparator *cmp_; + const ReaderWriter* _rw; + const Comparator* _cmp; typedef std::vector AliasList; - AliasList aliases_; + AliasList _aliases; }; // OPERATORS /// Equality test operator. Returns true if the two instances of Type /// describe the same type, false otherwise. - inline bool operator==(const Type &t1, const Type &t2) + inline bool operator==(const Type& t1, const Type& t2) { return (t1.getStdTypeInfo() == t2.getStdTypeInfo()) != 0; } /// Inequality test operator. Returns false if the two instances of Type /// describe the same type, true otherwise. - inline bool operator!=(const Type &t1, const Type &t2) + inline bool operator!=(const Type& t1, const Type& t2) { return (t1.getStdTypeInfo() != t2.getStdTypeInfo()) != 0; } /// Less than operator. Returns true if the first type comes before the /// second one. The actual ordering is implementation-dependent. - inline bool operator<(const Type &t1, const Type &t2) + inline bool operator<(const Type& t1, const Type& t2) { return (t1.getStdTypeInfo().before(t2.getStdTypeInfo())) != 0; } /// Greater than or equal to operator. Returns !operator<(). - inline bool operator>=(const Type &t1, const Type &t2) + inline bool operator>=(const Type& t1, const Type& t2) { return !operator<(t1, t2); } @@ -280,39 +280,39 @@ namespace osgIntrospection inline void Type::check_defined() const { - if (!is_defined_) - throw TypeNotDefinedException(ti_); + if (!_is_defined) + throw TypeNotDefinedException(_ti); } - inline const std::type_info &Type::getStdTypeInfo() const + inline const std::type_info& Type::getStdTypeInfo() const { - return ti_; + return _ti; } - inline const std::string &Type::getName() const + inline const std::string& Type::getName() const { check_defined(); - return name_; + return _name; } - inline const std::string &Type::getNamespace() const + inline const std::string& Type::getNamespace() const { check_defined(); - return namespace_; + return _namespace; } inline std::string Type::getQualifiedName() const { check_defined(); std::string qname; - if (is_const_) qname = "const "; - if (!namespace_.empty()) + if (_is_const) qname = "const "; + if (!_namespace.empty()) { - qname.append(namespace_); + qname.append(_namespace); qname.append("::"); } - qname.append(name_); - if (pointed_type_) + qname.append(_name); + if (_pointed_type) qname.append(" *"); return qname; } @@ -320,128 +320,128 @@ namespace osgIntrospection inline int Type::getNumBaseTypes() const { check_defined(); - return static_cast(base_.size()); + return static_cast(_base.size()); } inline bool Type::isConstPointer() const { check_defined(); - return is_const_ && pointed_type_; + return _is_const && _pointed_type; } inline bool Type::isNonConstPointer() const { check_defined(); - return !is_const_ && pointed_type_; + return !_is_const && _pointed_type; } inline bool Type::isAbstract() const { check_defined(); - return is_abstract_; + return _is_abstract; } inline bool Type::isAtomic() const { check_defined(); - return rw_ != 0; + return _rw != 0; } - inline const PropertyInfoList &Type::getProperties() const + inline const PropertyInfoList& Type::getProperties() const { check_defined(); - return props_; + return _props; } - inline const ConstructorInfoList &Type::getConstructors() const - { - check_defined(); - return cons_; - } - - inline const MethodInfoList &Type::getMethods() const + inline const ConstructorInfoList& Type::getConstructors() const { check_defined(); - return methods_; + return _cons; + } + + inline const MethodInfoList& Type::getMethods() const + { + check_defined(); + return _methods; } inline bool Type::isPointer() const { check_defined(); - return pointed_type_ != 0; + return _pointed_type != 0; } inline bool Type::isVoid() const { - return (ti_ == typeid(void)) != 0; + return (_ti == typeid(void)) != 0; } - inline const Type &Type::getPointedType() const + inline const Type& Type::getPointedType() const { check_defined(); - if (pointed_type_) - return *pointed_type_; + if (_pointed_type) + return *_pointed_type; return Reflection::type_void(); } inline bool Type::isEnum() const { check_defined(); - return !labels_.empty(); + return !_labels.empty(); } - inline const EnumLabelMap &Type::getEnumLabels() const + inline const EnumLabelMap& Type::getEnumLabels() const { check_defined(); - return labels_; + return _labels; } inline bool Type::isDefined() const { - return is_defined_; + return _is_defined; } - inline const ReaderWriter *Type::getReaderWriter() const + inline const ReaderWriter* Type::getReaderWriter() const { check_defined(); - return rw_; + return _rw; } - inline const Comparator *Type::getComparator() const + inline const Comparator* Type::getComparator() const { check_defined(); - return cmp_; + return _cmp; } - inline const Type &Type::getBaseType(int i) const + inline const Type& Type::getBaseType(int i) const { check_defined(); - return *base_.at(i); + return *_base.at(i); } inline Value Type::createInstance() const { - ValueList args; + ValueList args; return createInstance(args); } inline int Type::getNumAliases() const { - return static_cast(aliases_.size()); + return static_cast(_aliases.size()); } - inline const std::string &Type::getAlias(int i) const + inline const std::string& Type::getAlias(int i) const { - return aliases_[i]; + return _aliases[i]; } - inline bool Type::matchesName(const std::string &name) const + 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; + 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 index 0a656d948..0b94a56ee 100644 --- a/include/osgIntrospection/TypeNameAliasProxy +++ b/include/osgIntrospection/TypeNameAliasProxy @@ -24,16 +24,16 @@ 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); - } - }; + 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); + } + }; } diff --git a/include/osgIntrospection/TypedConstructorInfo b/include/osgIntrospection/TypedConstructorInfo index 77b3e75e6..3f0098457 100644 --- a/include/osgIntrospection/TypedConstructorInfo +++ b/include/osgIntrospection/TypedConstructorInfo @@ -22,445 +22,445 @@ 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]); - } - - }; + 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]); + } + + }; } diff --git a/include/osgIntrospection/TypedMethodInfo b/include/osgIntrospection/TypedMethodInfo index df68745e7..0d3ec8772 100644 --- a/include/osgIntrospection/TypedMethodInfo +++ b/include/osgIntrospection/TypedMethodInfo @@ -43,2924 +43,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_; } - 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_; - }; + 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 index 51d126252..5de1473f9 100644 --- a/include/osgIntrospection/Utility +++ b/include/osgIntrospection/Utility @@ -26,25 +26,25 @@ 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); - } - } + 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); + } + } } diff --git a/include/osgIntrospection/Value b/include/osgIntrospection/Value index 02257bb0c..99fbf029b 100644 --- a/include/osgIntrospection/Value +++ b/include/osgIntrospection/Value @@ -73,7 +73,7 @@ namespace osgIntrospection /// Copy constructor. The underlying value's type must have /// consistent copy semantics. - inline Value(const Value ©); + inline Value(const Value& copy); /// Destructor. Frees internal resources but it does NOT delete /// the value held. For example, this function will produce a @@ -81,7 +81,7 @@ namespace osgIntrospection inline ~Value(); /// Assignment operator. Behaves like the copy constructor. - inline Value &operator=(const Value ©); + inline Value& operator=(const Value& copy); /// Returns whether the value is a pointer and it points to /// something whose type is different than void. @@ -94,7 +94,7 @@ namespace osgIntrospection inline bool isNullPointer() const; /// Returns the exact type of the value held. - inline const Type &getType() const; + inline const Type& getType() const; /// If the value is a pointer to a non-void type, this method /// returns the actual type of the dereferenced pointer. Please @@ -102,25 +102,25 @@ namespace osgIntrospection /// because the latter would return the non-polymorphic type. /// If the value is not a pointer, this method behaves like /// getType(). - inline const Type &getInstanceType() const; + inline const Type& getInstanceType() const; /// Equal to operator. - bool operator==(const Value &other) const; + bool operator==(const Value& other) const; /// Less than or equal to operator. - bool operator<=(const Value &other) const; + bool operator<=(const Value& other) const; /// Inequality test operator. Returns !operator==(other). - bool operator!=(const Value &other) const; + bool operator!=(const Value& other) const; /// Greater than operator. Returns !operator<=(other). - bool operator>(const Value &other) const; + bool operator>(const Value& other) const; /// Less than operator. Returns !operator==(other) && operator<=(other). - bool operator<(const Value &other) const; + bool operator<(const Value& other) const; /// Greater than or equal to operator. Returns operator==(other) || !operator<=(other) - bool operator>=(const Value &other) const; + 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 @@ -129,7 +129,7 @@ namespace osgIntrospection /// types, or both, don't have a ReaderWriter object, the conversion /// fails and an exception is thrown. If the conversion can't be /// completed for other reasons, other exceptions may be thrown. - Value convertTo(const Type &outtype) const; + Value convertTo(const Type& outtype) const; /// Tries to convert this instance to a Value of the given type. /// The conversion is performed by rendering to a temporary stream @@ -139,7 +139,7 @@ namespace osgIntrospection /// fails and an empty Value is returned. /// Please note that unlike convertTo(), this method does not /// intentionally throw any exceptions. - Value tryConvertTo(const Type &outtype) const; + Value tryConvertTo(const Type& outtype) const; /// Tries to get a string representation of the underlying value. /// This requires the value's type to have a ReaderWriter object @@ -148,15 +148,15 @@ namespace osgIntrospection std::string toString() const; /// Swaps the content of this Value with another Value - void swap(Value &v); + void swap(Value& v); 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); + 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); // throw an exception if the value is empty void check_empty() const; @@ -174,10 +174,10 @@ namespace osgIntrospection template struct Instance: Instance_base { - Instance(T data): data_(data) {} + Instance(T data): _data(data) {} virtual Instance_base *clone() const { return new Instance(*this); } virtual ~Instance() {} - T data_; + T _data; }; // Base class for storage of Instance objects. Actually three @@ -190,30 +190,30 @@ namespace osgIntrospection { Instance_box_base() : inst_(0), - ref_inst_(0), - const_ref_inst_(0) + _ref_inst(0), + _const_ref_inst(0) { } virtual ~Instance_box_base() { delete inst_; - delete ref_inst_; - delete const_ref_inst_; + delete _ref_inst; + delete _const_ref_inst; } // clones the instance box virtual Instance_box_base *clone() const = 0; // returns the type of the value held - virtual const Type *type() const = 0; + virtual const Type* type() const = 0; // returns the actual pointed type if applicable - virtual const Type *ptype() const { return 0; } + virtual const Type* ptype() const { return 0; } // returns whether the data is a null pointer virtual bool nullptr() const = 0; Instance_base *inst_; - Instance_base *ref_inst_; - Instance_base *const_ref_inst_; + Instance_base *_ref_inst; + Instance_base *_const_ref_inst; }; // Generic instance box for non-pointer values. @@ -228,8 +228,8 @@ namespace osgIntrospection { Instance *vl = new Instance(d); inst_ = vl; - ref_inst_ = new Instance(vl->data_); - const_ref_inst_ = new Instance(vl->data_); + _ref_inst = new Instance(vl->_data); + _const_ref_inst = new Instance(vl->_data); } virtual Instance_box_base *clone() const @@ -241,15 +241,15 @@ namespace osgIntrospection Instance *vl = static_cast *>(inst_->clone()); new_inbox->inst_ = vl; - new_inbox->ref_inst_ = new Instance(vl->data_); - new_inbox->const_ref_inst_ = new Instance(vl->data_); + new_inbox->_ref_inst = new Instance(vl->_data); + new_inbox->_const_ref_inst = new Instance(vl->_data); new_inbox->nullptr_ = nullptr_; return new_inbox; } - virtual const Type *type() const + virtual const Type* type() const { - return &typeof(static_cast *>(inst_)->data_); + return &typeof(static_cast *>(inst_)->_data); } virtual bool nullptr() const @@ -275,8 +275,8 @@ namespace osgIntrospection { Instance *vl = new Instance(d); inst_ = vl; - ref_inst_ = new Instance(vl->data_); - const_ref_inst_ = new Instance(vl->data_); + _ref_inst = new Instance(vl->_data); + _const_ref_inst = new Instance(vl->_data); } virtual Instance_box_base *clone() const @@ -288,32 +288,32 @@ namespace osgIntrospection Instance *vl = static_cast *>(inst_->clone()); new_inbox->inst_ = vl; - new_inbox->ref_inst_ = new Instance(vl->data_); - new_inbox->const_ref_inst_ = new Instance(vl->data_); + new_inbox->_ref_inst = new Instance(vl->_data); + new_inbox->_const_ref_inst = new Instance(vl->_data); return new_inbox; } - virtual const Type *type() const + virtual const Type* type() const { - return &typeof(static_cast *>(inst_)->data_); + return &typeof(static_cast *>(inst_)->_data); } - virtual const Type *ptype() const + virtual const Type* ptype() const { - if (!static_cast *>(inst_)->data_) return 0; - return &typeof(*static_cast *>(inst_)->data_); + if (!static_cast *>(inst_)->_data) return 0; + return &typeof(*static_cast *>(inst_)->_data); } virtual bool nullptr() const { - return static_cast *>(inst_)->data_ == 0; + return static_cast *>(inst_)->_data == 0; } }; - Instance_box_base *inbox_; - const Type *type_; - const Type *ptype_; + Instance_box_base *_inbox; + const Type* _type; + const Type* _ptype; }; /// A vector of values. @@ -323,94 +323,94 @@ namespace osgIntrospection // INLINE METHODS inline Value::Value() - : inbox_(0), - type_(&Reflection::type_void()), - ptype_(0) + : _inbox(0), + _type(&Reflection::type_void()), + _ptype(0) { } template Value::Value(const T &v) - : ptype_(0) + : _ptype(0) { - inbox_ = new Instance_box(v); - type_ = inbox_->type(); + _inbox = new Instance_box(v); + _type = _inbox->type(); } inline Value::Value(const void *v) - : ptype_(0) + : _ptype(0) { - inbox_ = new Instance_box(v, v == 0); - type_ = inbox_->type(); + _inbox = new Instance_box(v, v == 0); + _type = _inbox->type(); } inline Value::Value(void *v) - : ptype_(0) + : _ptype(0) { - inbox_ = new Instance_box(v, v == 0); - type_ = inbox_->type(); + _inbox = new Instance_box(v, v == 0); + _type = _inbox->type(); } template Value::Value(const T *v) { - inbox_ = new Ptr_instance_box(v); - type_ = inbox_->type(); - ptype_ = inbox_->ptype(); + _inbox = new Ptr_instance_box(v); + _type = _inbox->type(); + _ptype = _inbox->ptype(); } template Value::Value(T *v) { - inbox_ = new Ptr_instance_box(v); - type_ = inbox_->type(); - ptype_ = inbox_->ptype(); + _inbox = new Ptr_instance_box(v); + _type = _inbox->type(); + _ptype = _inbox->ptype(); } - inline Value::Value(const Value ©) - : inbox_(copy.inbox_? copy.inbox_->clone(): 0), - type_(copy.type_), - ptype_(copy.ptype_) + inline Value::Value(const Value& copy) + : _inbox(copy._inbox? copy._inbox->clone(): 0), + _type(copy._type), + _ptype(copy._ptype) { } - inline Value &Value::operator=(const Value ©) + inline Value& Value::operator=(const Value& copy) { - std::auto_ptr new_inbox(copy.inbox_? copy.inbox_->clone(): 0); - delete inbox_; - inbox_ = new_inbox.release(); - type_ = copy.type_; - ptype_ = copy.ptype_; + std::auto_ptr new_inbox(copy._inbox? copy._inbox->clone(): 0); + delete _inbox; + _inbox = new_inbox.release(); + _type = copy._type; + _ptype = copy._ptype; return *this; } inline Value::~Value() { - delete inbox_; + delete _inbox; } - inline const Type &Value::getType() const + inline const Type& Value::getType() const { - return *type_; + return *_type; } - inline const Type &Value::getInstanceType() const + inline const Type& Value::getInstanceType() const { - if (ptype_) - return *ptype_; - return *type_; + if (_ptype) + return *_ptype; + return *_type; } inline bool Value::isTypedPointer() const { - return ptype_ != 0; + return _ptype != 0; } inline bool Value::isEmpty() const { - return inbox_ == 0; + return _inbox == 0; } inline bool Value::isNullPointer() const { - return inbox_->nullptr(); + return _inbox->nullptr(); } } diff --git a/include/osgIntrospection/variant_cast b/include/osgIntrospection/variant_cast index 97a0fe203..deb70b8ac 100644 --- a/include/osgIntrospection/variant_cast +++ b/include/osgIntrospection/variant_cast @@ -34,19 +34,19 @@ namespace osgIntrospection /// with the converted value as parameter. /// If the conversion can't be completed, an exception is thrown. /// Conversions that attempt to make a const pointer non-const will fail. - template T variant_cast(const Value &v) + template T variant_cast(const Value& v) { // return value - Value::Instance *i = dynamic_cast *>(v.inbox_->inst_); - if (i) return i->data_; + Value::Instance *i = dynamic_cast *>(v._inbox->inst_); + if (i) return i->_data; // return reference to value - i = dynamic_cast *>(v.inbox_->ref_inst_); - if (i) return i->data_; + i = dynamic_cast *>(v._inbox->_ref_inst); + if (i) return i->_data; // return const reference to value - i = dynamic_cast *>(v.inbox_->const_ref_inst_); - if (i) return i->data_; + i = dynamic_cast *>(v._inbox->_const_ref_inst); + if (i) return i->_data; // try to convert v to type T and restart return variant_cast(v.convertTo(typeof(T))); @@ -56,18 +56,18 @@ namespace osgIntrospection /// 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) + template bool requires_conversion(const Value& v) { // direct value - Value::Instance *i = dynamic_cast *>(v.inbox_->inst_); + Value::Instance *i = dynamic_cast *>(v._inbox->inst_); if (i) return false; // reference to value - i = dynamic_cast *>(v.inbox_->ref_inst_); + i = dynamic_cast *>(v._inbox->_ref_inst); if (i) return false; // const reference to value - i = dynamic_cast *>(v.inbox_->const_ref_inst_); + i = dynamic_cast *>(v._inbox->_const_ref_inst); if (i) return false; return true; @@ -76,20 +76,20 @@ namespace osgIntrospection /// Returns a typed pointer to the data contained in a Value /// instance. If the value's type is not identical to type T, /// a null pointer is returned. - template T *extract_raw_data(Value &v) + template T* extract_raw_data(Value& v) { - Value::Instance *i = dynamic_cast *>(v.inbox_->inst_); - if (i) return &i->data_; + Value::Instance* i = dynamic_cast *>(v._inbox->inst_); + if (i) return &i->_data; return 0; } /// Returns a typed pointer to the data contained in a const Value /// instance. If the value's type is not identical to type T, a /// null pointer is returned. - template const T *extract_raw_data(const Value &v) + template const T* extract_raw_data(const Value& v) { - Value::Instance *i = dynamic_cast *>(v.inbox_->inst_); - if (i) return &i->data_; + Value::Instance* i = dynamic_cast *>(v._inbox->inst_); + if (i) return &i->_data; return 0; } diff --git a/src/osgIntrospection/ConstructorInfo.cpp b/src/osgIntrospection/ConstructorInfo.cpp index 72d8ab213..6217a87e0 100644 --- a/src/osgIntrospection/ConstructorInfo.cpp +++ b/src/osgIntrospection/ConstructorInfo.cpp @@ -16,11 +16,11 @@ using namespace osgIntrospection; -void ConstructorInfo::getInheritedProviders(CustomAttributeProviderList &providers) const +void ConstructorInfo::getInheritedProviders(CustomAttributeProviderList& providers) const { - for (int i=0; igetAttribute(type, true); + const CustomAttribute* ca = (*i)->getAttribute(type, true); if (ca) return ca; } } diff --git a/src/osgIntrospection/MethodInfo.cpp b/src/osgIntrospection/MethodInfo.cpp index 611c5dde3..2799b1a4e 100644 --- a/src/osgIntrospection/MethodInfo.cpp +++ b/src/osgIntrospection/MethodInfo.cpp @@ -16,11 +16,11 @@ using namespace osgIntrospection; -void MethodInfo::getInheritedProviders(CustomAttributeProviderList &providers) const +void MethodInfo::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; + if (isConst() != other->isConst()) 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; - } + 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; + 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_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; - } + 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) - { - } + if (num_fixed_1 > num_fixed_2) + { + } */ } diff --git a/src/osgIntrospection/PropertyInfo.cpp b/src/osgIntrospection/PropertyInfo.cpp index 4ab896ff3..f96a8a02a 100644 --- a/src/osgIntrospection/PropertyInfo.cpp +++ b/src/osgIntrospection/PropertyInfo.cpp @@ -18,11 +18,11 @@ using namespace osgIntrospection; -void PropertyInfo::getInheritedProviders(CustomAttributeProviderList &providers) const +void PropertyInfo::getInheritedProviders(CustomAttributeProviderList& providers) const { - for (int i=0; i(false); const CustomPropertyGetAttribute *cget = getAttribute(false); @@ -42,15 +42,15 @@ Value PropertyInfo::getValue(const Value &instance) const return cget->getGetter()->get(instance); } - if (!getm_) - throw PropertyAccessException(decltype_.getQualifiedName() + "::" + name_, PropertyAccessException::GET); + if (!_getm) + throw PropertyAccessException(_decltype.getQualifiedName() + "::" + _name, PropertyAccessException::GET); if (pta) - return getm_->invoke(instance).convertTo(pta->getPropertyType()); - return getm_->invoke(instance); + return _getm->invoke(instance).convertTo(pta->getPropertyType()); + return _getm->invoke(instance); } -Value PropertyInfo::getValue(Value &instance) const +Value PropertyInfo::getValue(Value& instance) const { const PropertyTypeAttribute *pta = getAttribute(false); const CustomPropertyGetAttribute *cget = getAttribute(false); @@ -62,15 +62,15 @@ Value PropertyInfo::getValue(Value &instance) const return cget->getGetter()->get(instance); } - if (!getm_) - throw PropertyAccessException(decltype_.getQualifiedName() + "::" + name_, PropertyAccessException::GET); + if (!_getm) + throw PropertyAccessException(_decltype.getQualifiedName() + "::" + _name, PropertyAccessException::GET); if (pta) - return getm_->invoke(instance).convertTo(pta->getPropertyType()); - return getm_->invoke(instance); + return _getm->invoke(instance).convertTo(pta->getPropertyType()); + return _getm->invoke(instance); } -void PropertyInfo::setValue(Value &instance, const Value &value) const +void PropertyInfo::setValue(Value& instance, const Value& value) const { const CustomPropertySetAttribute *cset = getAttribute(false); @@ -80,15 +80,15 @@ void PropertyInfo::setValue(Value &instance, const Value &value) const return; } - if (!setm_) - throw PropertyAccessException(decltype_.getQualifiedName() + "::" + name_, PropertyAccessException::SET); + if (!_setm) + throw PropertyAccessException(_decltype.getQualifiedName() + "::" + _name, PropertyAccessException::SET); ValueList args; args.push_back(value); - setm_->invoke(instance, args); + _setm->invoke(instance, args); } -Value PropertyInfo::getIndexedValue(const Value &instance, ValueList &args) const +Value PropertyInfo::getIndexedValue(const Value& instance, ValueList& args) const { const PropertyTypeAttribute *pta = getAttribute(false); const CustomPropertyGetAttribute *cget = getAttribute(false); @@ -100,15 +100,15 @@ Value PropertyInfo::getIndexedValue(const Value &instance, ValueList &args) cons return cget->getGetter()->get(instance, args); } - if (!getm_) - throw PropertyAccessException(decltype_.getQualifiedName() + "::" + name_, PropertyAccessException::IGET); + if (!_getm) + throw PropertyAccessException(_decltype.getQualifiedName() + "::" + _name, PropertyAccessException::IGET); if (pta) - return getm_->invoke(instance, args).convertTo(pta->getPropertyType()); - return getm_->invoke(instance, args); + return _getm->invoke(instance, args).convertTo(pta->getPropertyType()); + return _getm->invoke(instance, args); } -Value PropertyInfo::getIndexedValue(Value &instance, ValueList &args) const +Value PropertyInfo::getIndexedValue(Value& instance, ValueList& args) const { const PropertyTypeAttribute *pta = getAttribute(false); const CustomPropertyGetAttribute *cget = getAttribute(false); @@ -120,15 +120,15 @@ Value PropertyInfo::getIndexedValue(Value &instance, ValueList &args) const return cget->getGetter()->get(instance, args); } - if (!getm_) - throw PropertyAccessException(decltype_.getQualifiedName() + "::" + name_, PropertyAccessException::IGET); + if (!_getm) + throw PropertyAccessException(_decltype.getQualifiedName() + "::" + _name, PropertyAccessException::IGET); if (pta) - return getm_->invoke(instance, args).convertTo(pta->getPropertyType()); - return getm_->invoke(instance, args); + return _getm->invoke(instance, args).convertTo(pta->getPropertyType()); + return _getm->invoke(instance, args); } -void PropertyInfo::setIndexedValue(Value &instance, ValueList &args, const Value &value) const +void PropertyInfo::setIndexedValue(Value& instance, ValueList& args, const Value& value) const { const CustomPropertySetAttribute *cset = getAttribute(false); if (cset) @@ -137,26 +137,26 @@ void PropertyInfo::setIndexedValue(Value &instance, ValueList &args, const Value return; } - if (!setm_) - throw PropertyAccessException(decltype_.getQualifiedName() + "::" + name_, PropertyAccessException::ISET); + if (!_setm) + throw PropertyAccessException(_decltype.getQualifiedName() + "::" + _name, PropertyAccessException::ISET); args.push_back(value); - setm_->invoke(instance, args); + _setm->invoke(instance, args); args.pop_back(); } -int PropertyInfo::getNumArrayItems(const Value &instance) const +int PropertyInfo::getNumArrayItems(const Value& instance) const { const CustomPropertyCountAttribute *ccount = getAttribute(false); if (ccount) return ccount->getCounter()->count(instance); - if (!numm_) - throw PropertyAccessException(decltype_.getQualifiedName() + "::" + name_, PropertyAccessException::COUNT); + if (!_numm) + throw PropertyAccessException(_decltype.getQualifiedName() + "::" + _name, PropertyAccessException::COUNT); - return variant_cast(numm_->invoke(instance)); + return variant_cast(_numm->invoke(instance)); } -Value PropertyInfo::getArrayItem(const Value &instance, int i) const +Value PropertyInfo::getArrayItem(const Value& instance, int i) const { const PropertyTypeAttribute *pta = getAttribute(false); const CustomPropertyGetAttribute *cget = getAttribute(false); @@ -168,18 +168,18 @@ Value PropertyInfo::getArrayItem(const Value &instance, int i) const return cget->getGetter()->get(instance, i); } - if (!getm_) - throw PropertyAccessException(decltype_.getQualifiedName() + "::" + name_, PropertyAccessException::AGET); + 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); + return _getm->invoke(instance, args).convertTo(pta->getPropertyType()); + return _getm->invoke(instance, args); } -Value PropertyInfo::getArrayItem(Value &instance, int i) const +Value PropertyInfo::getArrayItem(Value& instance, int i) const { const PropertyTypeAttribute *pta = getAttribute(false); const CustomPropertyGetAttribute *cget = getAttribute(false); @@ -191,18 +191,18 @@ Value PropertyInfo::getArrayItem(Value &instance, int i) const return cget->getGetter()->get(instance, i); } - if (!getm_) - throw PropertyAccessException(decltype_.getQualifiedName() + "::" + name_, PropertyAccessException::AGET); + 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); + return _getm->invoke(instance, args).convertTo(pta->getPropertyType()); + return _getm->invoke(instance, args); } -void PropertyInfo::setArrayItem(Value &instance, int i, const Value &value) const +void PropertyInfo::setArrayItem(Value& instance, int i, const Value& value) const { const CustomPropertySetAttribute *cset = getAttribute(false); if (cset) @@ -211,16 +211,16 @@ void PropertyInfo::setArrayItem(Value &instance, int i, const Value &value) cons return; } - if (!setm_) - throw PropertyAccessException(decltype_.getQualifiedName() + "::" + name_, PropertyAccessException::ASET); + if (!_setm) + throw PropertyAccessException(_decltype.getQualifiedName() + "::" + _name, PropertyAccessException::ASET); ValueList args; args.push_back(i); args.push_back(value); - setm_->invoke(instance, args); + _setm->invoke(instance, args); } -void PropertyInfo::addArrayItem(Value &instance, const Value &value) const +void PropertyInfo::addArrayItem(Value& instance, const Value& value) const { const CustomPropertyAddAttribute *cadd = getAttribute(false); if (cadd) @@ -229,15 +229,15 @@ void PropertyInfo::addArrayItem(Value &instance, const Value &value) const return; } - if (!addm_) - throw PropertyAccessException(decltype_.getQualifiedName() + "::" + name_, PropertyAccessException::ADD); + if (!_addm) + throw PropertyAccessException(_decltype.getQualifiedName() + "::" + _name, PropertyAccessException::ADD); ValueList args; args.push_back(value); - addm_->invoke(instance, args); + _addm->invoke(instance, args); } -void PropertyInfo::removeArrayItem(Value &instance, int i) const +void PropertyInfo::removeArrayItem(Value& instance, int i) const { const CustomPropertyRemoveAttribute *crem = getAttribute(false); if (crem) @@ -246,19 +246,19 @@ void PropertyInfo::removeArrayItem(Value &instance, int i) const return; } - if (!remm_) - throw PropertyAccessException(decltype_.getQualifiedName() + "::" + name_, PropertyAccessException::REMOVE); + if (!_remm) + throw PropertyAccessException(_decltype.getQualifiedName() + "::" + _name, PropertyAccessException::REMOVE); ValueList args; args.push_back(i); - remm_->invoke(instance, args); + _remm->invoke(instance, args); } Value PropertyInfo::getDefaultValue() const { if (isArray() || isIndexed()) return Value(); - const CustomAttributeList &cal = getCustomAttributes(); + const CustomAttributeList& cal = getCustomAttributes(); for (CustomAttributeList::const_iterator i=cal.begin(); i!=cal.end(); ++i) { if (dynamic_cast(*i) != 0) @@ -271,19 +271,19 @@ Value PropertyInfo::getDefaultValue() const } } - if (decltype_.isAbstract()) + if (_decltype.isAbstract()) { - if (ptype_.isAbstract() || !ptype_.isDefined()) + if (_ptype.isAbstract() || !_ptype.isDefined()) return Value(); - return ptype_.createInstance(); + return _ptype.createInstance(); } // auto default value - Value instance = decltype_.createInstance(); + Value instance = _decltype.createInstance(); return getValue(instance); } -void PropertyInfo::getIndexValueSet(int whichindex, const Value &instance, ValueList &values) const +void PropertyInfo::getIndexValueSet(int whichindex, const Value& instance, ValueList& values) const { const CustomIndexAttribute *cia = getAttribute(false); if (cia) @@ -293,7 +293,7 @@ void PropertyInfo::getIndexValueSet(int whichindex, const Value &instance, Value else { std::map ita_map; - const CustomAttributeList &cal = getCustomAttributes(); + const CustomAttributeList& cal = getCustomAttributes(); for (CustomAttributeList::const_iterator i=cal.begin(); i!=cal.end(); ++i) { const IndexTypeAttribute *ita = dynamic_cast(*i); @@ -301,21 +301,21 @@ void PropertyInfo::getIndexValueSet(int whichindex, const Value &instance, Value ita_map[ita->getWhichIndex()] = ita; } - const EnumLabelMap &elm = getIndexParameters().at(whichindex)->getParameterType().getEnumLabels(); + const EnumLabelMap& elm = getIndexParameters().at(whichindex)->getParameterType().getEnumLabels(); if (elm.empty()) - throw IndexValuesNotDefinedException(name_, getIndexParameters().at(whichindex)->getName()); + throw IndexValuesNotDefinedException(_name, getIndexParameters().at(whichindex)->getName()); for (EnumLabelMap::const_iterator i=elm.begin(); i!=elm.end(); ++i) { if (ita_map[whichindex]) values.push_back(Value(i->first).convertTo(ita_map[whichindex]->getIndexType())); else - values.push_back(Value(i->first).convertTo(indices_[whichindex]->getParameterType())); + values.push_back(Value(i->first).convertTo(_indices[whichindex]->getParameterType())); } } } -const ParameterInfoList &PropertyInfo::getIndexParameters() const +const ParameterInfoList& PropertyInfo::getIndexParameters() const { const CustomIndexAttribute *cia = getAttribute(false); if (cia) @@ -323,5 +323,5 @@ const ParameterInfoList &PropertyInfo::getIndexParameters() const return cia->getIndexInfo()->getIndexParameters(); } - return indices_; + return _indices; } diff --git a/src/osgIntrospection/Reflection.cpp b/src/osgIntrospection/Reflection.cpp index 7ad428339..eec5e0e7b 100644 --- a/src/osgIntrospection/Reflection.cpp +++ b/src/osgIntrospection/Reflection.cpp @@ -10,7 +10,7 @@ using namespace osgIntrospection; -Reflection::StaticData *Reflection::staticdata__ = 0; +Reflection::StaticData* Reflection::_static_data = 0; Reflection::StaticData::~StaticData() { @@ -26,29 +26,29 @@ Reflection::StaticData::~StaticData() } } -const TypeMap &Reflection::getTypes() +const TypeMap& Reflection::getTypes() { return getOrCreateStaticData().typemap; } -Reflection::StaticData &Reflection::getOrCreateStaticData() +Reflection::StaticData& Reflection::getOrCreateStaticData() { static OpenThreads::Mutex access_mtx; OpenThreads::ScopedLock lock(access_mtx); - if (!staticdata__) + if (!_static_data) { - staticdata__ = new StaticData; + _static_data = new StaticData; std::auto_ptr tvoid(new Type(typeid(void))); - staticdata__->typemap.insert(std::make_pair(&typeid(void), tvoid.get())); - staticdata__->type_void = tvoid.release(); + _static_data->typemap.insert(std::make_pair(&typeid(void), tvoid.get())); + _static_data->type_void = tvoid.release(); } - return *staticdata__; + return *_static_data; } -const Type &Reflection::getType(const std::type_info &ti) +const Type& Reflection::getType(const std::type_info& ti) { - const TypeMap &types = getTypes(); + const TypeMap& types = getTypes(); TypeMap::const_iterator i = types.find(&ti); if (i == types.end()) @@ -58,9 +58,9 @@ const Type &Reflection::getType(const std::type_info &ti) return *i->second; } -const Type &Reflection::getType(const std::string &qname) +const Type& Reflection::getType(const std::string& qname) { - const TypeMap &types = getTypes(); + const TypeMap& types = getTypes(); for (TypeMap::const_iterator i=types.begin(); i!=types.end(); ++i) { @@ -74,21 +74,21 @@ const Type &Reflection::getType(const std::string &qname) throw TypeNotFoundException(qname); } -const Type &Reflection::type_void() +const Type& Reflection::type_void() { return *getOrCreateStaticData().type_void; } -Type *Reflection::registerType(const std::type_info &ti) +Type* Reflection::registerType(const std::type_info& ti) { std::auto_ptr type(new Type(ti)); getOrCreateStaticData().typemap.insert(std::make_pair(&ti, type.get())); return type.release(); } -Type *Reflection::getOrRegisterType(const std::type_info &ti, bool replace_if_defined) +Type* Reflection::getOrRegisterType(const std::type_info& ti, bool replace_if_defined) { - TypeMap &tm = getOrCreateStaticData().typemap; + TypeMap& tm = getOrCreateStaticData().typemap; TypeMap::iterator i = tm.find(&ti); if (i != tm.end()) @@ -97,12 +97,12 @@ Type *Reflection::getOrRegisterType(const std::type_info &ti, bool replace_if_de { std::string old_name = i->second->getName(); std::string old_namespace = i->second->getNamespace(); - std::vector old_aliases = i->second->aliases_; + 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); + Type* newtype = new (i->second) Type(ti); + newtype->_name = old_name; + newtype->_namespace = old_namespace; + newtype->_aliases.swap(old_aliases); return newtype; } @@ -112,20 +112,20 @@ Type *Reflection::getOrRegisterType(const std::type_info &ti, bool replace_if_de return registerType(ti); } -void Reflection::registerConverter(const Type &source, const Type &dest, const Converter *cvt) +void Reflection::registerConverter(const Type& source, const Type& dest, const Converter* cvt) { getOrCreateStaticData().convmap[&source][&dest] = cvt; } -const Converter *Reflection::getConverter(const Type &source, const Type &dest) +const Converter* Reflection::getConverter(const Type& source, const Type& dest) { return getOrCreateStaticData().convmap[&source][&dest]; } -bool Reflection::getConversionPath(const Type &source, const Type &dest, ConverterList &conv) +bool Reflection::getConversionPath(const Type& source, const Type& dest, ConverterList& conv) { ConverterList temp; - std::vector chain; + std::vector chain; if (accum_conv_path(source, dest, temp, chain)) { conv.swap(temp); @@ -134,7 +134,7 @@ bool Reflection::getConversionPath(const Type &source, const Type &dest, Convert return false; } -bool Reflection::accum_conv_path(const Type &source, const Type &dest, ConverterList &conv, std::vector &chain) +bool Reflection::accum_conv_path(const Type& source, const Type& dest, ConverterList& conv, std::vector &chain) { // break unwanted loops if (std::find(chain.begin(), chain.end(), &source) != chain.end()) @@ -147,7 +147,7 @@ bool Reflection::accum_conv_path(const Type &source, const Type &dest, Converter if (i == getOrCreateStaticData().convmap.end()) return false; - const StaticData::ConverterMap &cmap = i->second; + const StaticData::ConverterMap& cmap = i->second; StaticData::ConverterMap::const_iterator j = cmap.find(&dest); if (j != cmap.end()) { diff --git a/src/osgIntrospection/Type.cpp b/src/osgIntrospection/Type.cpp index c8351344b..23dc71bf3 100644 --- a/src/osgIntrospection/Type.cpp +++ b/src/osgIntrospection/Type.cpp @@ -30,7 +30,7 @@ using namespace osgIntrospection; namespace { - template + template struct ObjectMatch { int list_pos; @@ -46,28 +46,28 @@ namespace } }; - typedef ObjectMatch MethodMatch; - typedef ObjectMatch ConstructorMatch; + typedef ObjectMatch MethodMatch; + typedef ObjectMatch ConstructorMatch; } Type::~Type() { - for (PropertyInfoList::const_iterator i=props_.begin(); i!=props_.end(); ++i) + for (PropertyInfoList::const_iterator i=_props.begin(); i!=_props.end(); ++i) delete *i; - for (MethodInfoList::const_iterator i=methods_.begin(); i!=methods_.end(); ++i) + for (MethodInfoList::const_iterator i=_methods.begin(); i!=_methods.end(); ++i) + delete *i; + for (ConstructorInfoList::const_iterator i=_cons.begin(); i!=_cons.end(); ++i) delete *i; - for (ConstructorInfoList::const_iterator i=cons_.begin(); i!=cons_.end(); ++i) - delete *i; - delete rw_; - delete cmp_; + delete _rw; + delete _cmp; } -bool Type::isSubclassOf(const Type &type) const +bool Type::isSubclassOf(const Type& type) const { check_defined(); - for (TypeList::const_iterator i=base_.begin(); i!=base_.end(); ++i) + for (TypeList::const_iterator i=_base.begin(); i!=_base.end(); ++i) { if (**i == type.getStdTypeInfo()) return true; @@ -77,7 +77,7 @@ bool Type::isSubclassOf(const Type &type) const return false; } -const MethodInfo *Type::getCompatibleMethod(const std::string &name, const ValueList &values, bool inherit) const +const MethodInfo *Type::getCompatibleMethod(const std::string& name, const ValueList& values, bool inherit) const { check_defined(); @@ -89,7 +89,7 @@ const MethodInfo *Type::getCompatibleMethod(const std::string &name, const Value methods = &allmethods; } else - methods = &methods_; + methods = &_methods; typedef std::vector MatchList; MatchList matches; @@ -100,15 +100,15 @@ const MethodInfo *Type::getCompatibleMethod(const std::string &name, const Value const MethodInfo *mi = *j; if (mi->getName().compare(name) == 0) { - float match; - if (areArgumentsCompatible(values, mi->getParameters(), match)) - { - MethodMatch 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); - } + } } } @@ -121,24 +121,24 @@ const MethodInfo *Type::getCompatibleMethod(const std::string &name, const Value return 0; } -const MethodInfo *Type::getMethod(const std::string &name, const ParameterInfoList ¶ms, bool inherit) const +const MethodInfo *Type::getMethod(const std::string& name, const ParameterInfoList& params, bool inherit) const { check_defined(); - for (MethodInfoList::const_iterator j=methods_.begin(); j!=methods_.end(); ++j) + for (MethodInfoList::const_iterator j=_methods.begin(); j!=_methods.end(); ++j) { const MethodInfo *mi = *j; if (mi->getName().compare(name) == 0) { - if (areParametersCompatible(params, mi->getParameters())) - { - return mi; - } + if (areParametersCompatible(params, mi->getParameters())) + { + return mi; + } } } if (inherit) { - for (TypeList::const_iterator i=base_.begin(); i!=base_.end(); ++i) + for (TypeList::const_iterator i=_base.begin(); i!=_base.end(); ++i) { const MethodInfo *mi = (*i)->getMethod(name, params, true); if (mi) return mi; @@ -148,30 +148,30 @@ const MethodInfo *Type::getMethod(const std::string &name, const ParameterInfoLi return 0; } -void Type::getInheritedProviders(CustomAttributeProviderList &providers) const +void Type::getInheritedProviders(CustomAttributeProviderList& providers) const { check_defined(); - providers.assign(base_.begin(), base_.end()); + providers.assign(_base.begin(), _base.end()); } -const PropertyInfo *Type::getProperty(const std::string &name, const Type &ptype, const ParameterInfoList &indices, bool inherit) const +const PropertyInfo *Type::getProperty(const std::string& name, const Type& ptype, const ParameterInfoList& indices, bool inherit) const { check_defined(); - for (PropertyInfoList::const_iterator i=props_.begin(); i!=props_.end(); ++i) + for (PropertyInfoList::const_iterator i=_props.begin(); i!=_props.end(); ++i) { const PropertyInfo *pi = *i; if (pi->getName() == name && pi->getPropertyType() == ptype) { - if (areParametersCompatible(indices, pi->getIndexParameters())) - { - return pi; - } + if (areParametersCompatible(indices, pi->getIndexParameters())) + { + return pi; + } } } if (inherit) { - for (TypeList::const_iterator i=base_.begin(); i!=base_.end(); ++i) + for (TypeList::const_iterator i=_base.begin(); i!=_base.end(); ++i) { const PropertyInfo *pi = (*i)->getProperty(name, ptype, indices, true); if (pi) return pi; @@ -181,55 +181,55 @@ const PropertyInfo *Type::getProperty(const std::string &name, const Type &ptype return 0; } -Value Type::invokeMethod(const std::string &name, const Value &instance, ValueList &args, bool inherit) const +Value Type::invokeMethod(const std::string& name, const Value& instance, ValueList& args, bool inherit) const { check_defined(); const MethodInfo *mi = getCompatibleMethod(name, args, inherit); - if (!mi) throw MethodNotFoundException(name, name_); + if (!mi) throw MethodNotFoundException(name, _name); return mi->invoke(instance, args); } -Value Type::invokeMethod(const std::string &name, Value &instance, ValueList &args, bool inherit) const +Value Type::invokeMethod(const std::string& name, Value& instance, ValueList& args, bool inherit) const { check_defined(); const MethodInfo *mi = getCompatibleMethod(name, args, inherit); - if (!mi) throw MethodNotFoundException(name, name_); + if (!mi) throw MethodNotFoundException(name, _name); return mi->invoke(instance, args); } -void Type::getAllProperties(PropertyInfoList &props) const +void Type::getAllProperties(PropertyInfoList& props) const { check_defined(); - std::copy(props_.begin(), props_.end(), std::back_inserter(props)); - for (TypeList::const_iterator i=base_.begin(); i!=base_.end(); ++i) + std::copy(_props.begin(), _props.end(), std::back_inserter(props)); + for (TypeList::const_iterator i=_base.begin(); i!=_base.end(); ++i) { (*i)->getAllProperties(props); } } -void Type::getAllMethods(MethodInfoList &methods) const +void Type::getAllMethods(MethodInfoList& methods) const { check_defined(); - std::copy(methods_.begin(), methods_.end(), std::back_inserter(methods)); - for (TypeList::const_iterator i=base_.begin(); i!=base_.end(); ++i) + std::copy(_methods.begin(), _methods.end(), std::back_inserter(methods)); + for (TypeList::const_iterator i=_base.begin(); i!=_base.end(); ++i) { (*i)->getAllMethods(methods); } } -Value Type::createInstance(ValueList &args) const +Value Type::createInstance(ValueList& args) const { - if (isAbstract()) - throw TypeIsAbstractException(ti_); + if (isAbstract()) + throw TypeIsAbstractException(_ti); - const ConstructorInfo *ci = getCompatibleConstructor(args); - if (!ci) - throw ConstructorNotFoundException(ti_); + const ConstructorInfo *ci = getCompatibleConstructor(args); + if (!ci) + throw ConstructorNotFoundException(_ti); - return ci->createInstance(args); + return ci->createInstance(args); } -const ConstructorInfo *Type::getCompatibleConstructor(const ValueList &values) const +const ConstructorInfo *Type::getCompatibleConstructor(const ValueList& values) const { check_defined(); @@ -237,17 +237,17 @@ const ConstructorInfo *Type::getCompatibleConstructor(const ValueList &values) c MatchList matches; int pos = 0; - for (ConstructorInfoList::const_iterator j=cons_.begin(); j!=cons_.end(); ++j, ++pos) + for (ConstructorInfoList::const_iterator j=_cons.begin(); j!=_cons.end(); ++j, ++pos) { - float match; - if (areArgumentsCompatible(values, (*j)->getParameters(), match)) - { - ConstructorMatch mm; + 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()) @@ -259,14 +259,14 @@ const ConstructorInfo *Type::getCompatibleConstructor(const ValueList &values) c return 0; } -const ConstructorInfo *Type::getConstructor(const ParameterInfoList ¶ms) const +const ConstructorInfo *Type::getConstructor(const ParameterInfoList& params) const { check_defined(); - for (ConstructorInfoList::const_iterator j=cons_.begin(); j!=cons_.end(); ++j) + for (ConstructorInfoList::const_iterator j=_cons.begin(); j!=_cons.end(); ++j) { - if (areParametersCompatible(params, (*j)->getParameters())) - return *j; + if (areParametersCompatible(params, (*j)->getParameters())) + return *j; } return 0; diff --git a/src/osgIntrospection/Utility.cpp b/src/osgIntrospection/Utility.cpp index fa3be8788..627e0d688 100644 --- a/src/osgIntrospection/Utility.cpp +++ b/src/osgIntrospection/Utility.cpp @@ -16,7 +16,7 @@ using namespace osgIntrospection; -bool osgIntrospection::areParametersCompatible(const ParameterInfoList &pl1, const ParameterInfoList &pl2) +bool osgIntrospection::areParametersCompatible(const ParameterInfoList& pl1, const ParameterInfoList& pl2) { if (pl1.size() == pl2.size()) { @@ -37,20 +37,20 @@ bool osgIntrospection::areParametersCompatible(const ParameterInfoList &pl1, con } } - return false; + return false; } -bool osgIntrospection::areArgumentsCompatible(const ValueList &vl, const ParameterInfoList &pl, float &match) +bool osgIntrospection::areArgumentsCompatible(const ValueList& vl, const ParameterInfoList& pl, float &match) { - if (pl.empty()) - { - if (vl.empty()) - { - match = 1.0f; - return true; - } - return false; - } + if (pl.empty()) + { + if (vl.empty()) + { + match = 1.0f; + return true; + } + return false; + } ParameterInfoList::const_iterator i1 = pl.begin(); ValueList::const_iterator i2 = vl.begin(); @@ -59,27 +59,27 @@ bool osgIntrospection::areArgumentsCompatible(const ValueList &vl, const Paramet for (; i1getDefaultValue().isEmpty()) - return false; - continue; - } + if (i2 == vl.end()) + { + if ((*i1)->getDefaultValue().isEmpty()) + return false; + continue; + } if ((*i1)->getParameterType() != i2->getType()) { if (i2->tryConvertTo((*i1)->getParameterType()).isEmpty()) { - return false; + return false; } } else ++exact_args; - ++i2; + ++i2; } - match = static_cast(exact_args) / pl.size(); - return true; + match = static_cast(exact_args) / pl.size(); + return true; } diff --git a/src/osgIntrospection/Value.cpp b/src/osgIntrospection/Value.cpp index cf55a35d0..3de85a978 100644 --- a/src/osgIntrospection/Value.cpp +++ b/src/osgIntrospection/Value.cpp @@ -25,27 +25,27 @@ using namespace osgIntrospection; -Value Value::convertTo(const Type &outtype) const +Value Value::convertTo(const Type& outtype) const { Value v = tryConvertTo(outtype); if (v.isEmpty()) - throw TypeConversionException(type_->getStdTypeInfo(), outtype.getStdTypeInfo()); + throw TypeConversionException(_type->getStdTypeInfo(), outtype.getStdTypeInfo()); return v; } -Value Value::tryConvertTo(const Type &outtype) const +Value Value::tryConvertTo(const Type& outtype) const { check_empty(); - if (type_ == &outtype) + if (_type == &outtype) return *this; - if (type_->isConstPointer() && outtype.isNonConstPointer()) + if (_type->isConstPointer() && outtype.isNonConstPointer()) return Value(); // search custom converters ConverterList conv; - if (Reflection::getConversionPath(*type_, outtype, conv)) + if (Reflection::getConversionPath(*_type, outtype, conv)) { std::auto_ptr cvt(new CompositeConverter(conv)); return cvt->convert(*this); @@ -53,16 +53,16 @@ Value Value::tryConvertTo(const Type &outtype) const std::auto_ptr wopt; - if (type_->isEnum() && (outtype.getQualifiedName() == "int" || outtype.getQualifiedName() == "unsigned int")) + if (_type->isEnum() && (outtype.getQualifiedName() == "int" || outtype.getQualifiedName() == "unsigned int")) { wopt.reset(new ReaderWriter::Options); wopt->setForceNumericOutput(true); } - const ReaderWriter *src_rw = type_->getReaderWriter(); + const ReaderWriter* src_rw = _type->getReaderWriter(); if (src_rw) { - const ReaderWriter *dst_rw = outtype.getReaderWriter(); + const ReaderWriter* dst_rw = outtype.getReaderWriter(); if (dst_rw) { std::stringstream ss; @@ -84,7 +84,7 @@ std::string Value::toString() const { check_empty(); - const ReaderWriter *rw = type_->getReaderWriter(); + const ReaderWriter* rw = _type->getReaderWriter(); if (rw) { std::ostringstream oss; @@ -92,23 +92,23 @@ std::string Value::toString() const throw StreamWriteErrorException(); return oss.str(); } - throw StreamingNotSupportedException(StreamingNotSupportedException::ANY, type_->getStdTypeInfo()); + throw StreamingNotSupportedException(StreamingNotSupportedException::ANY, _type->getStdTypeInfo()); } void Value::check_empty() const { - if (!type_ || !inbox_) + if (!_type || !_inbox) throw EmptyValueException(); } -void Value::swap(Value &v) +void Value::swap(Value& v) { - std::swap(inbox_, v.inbox_); - std::swap(type_, v.type_); - std::swap(ptype_, v.ptype_); + std::swap(_inbox, v._inbox); + std::swap(_type, v._type); + std::swap(_ptype, v._ptype); } -bool Value::operator ==(const Value &other) const +bool Value::operator ==(const Value& other) const { if (isEmpty() && other.isEmpty()) return true; @@ -116,94 +116,94 @@ bool Value::operator ==(const Value &other) const if (isEmpty() ^ other.isEmpty()) return false; - const Comparator *cmp1 = type_->getComparator(); - const Comparator *cmp2 = other.type_->getComparator(); + const Comparator* cmp1 = _type->getComparator(); + const Comparator* cmp2 = other._type->getComparator(); - const Comparator *cmp = cmp1? cmp1: cmp2; + const Comparator* cmp = cmp1? cmp1: cmp2; if (!cmp) - throw ComparisonNotPermittedException(type_->getStdTypeInfo()); + throw ComparisonNotPermittedException(_type->getStdTypeInfo()); if (cmp1 == cmp2) return cmp->isEqualTo(*this, other); if (cmp1) - return cmp1->isEqualTo(*this, other.convertTo(*type_)); + return cmp1->isEqualTo(*this, other.convertTo(*_type)); - return cmp2->isEqualTo(convertTo(*other.type_), other); + return cmp2->isEqualTo(convertTo(*other._type), other); } -bool Value::operator <=(const Value &other) const +bool Value::operator <=(const Value& other) const { - const Comparator *cmp1 = type_->getComparator(); - const Comparator *cmp2 = other.type_->getComparator(); + const Comparator* cmp1 = _type->getComparator(); + const Comparator* cmp2 = other._type->getComparator(); - const Comparator *cmp = cmp1? cmp1: cmp2; + const Comparator* cmp = cmp1? cmp1: cmp2; if (!cmp) - throw ComparisonNotPermittedException(type_->getStdTypeInfo()); + throw ComparisonNotPermittedException(_type->getStdTypeInfo()); if (cmp1 == cmp2) return cmp->isLessThanOrEqualTo(*this, other); if (cmp1) - return cmp1->isLessThanOrEqualTo(*this, other.convertTo(*type_)); + return cmp1->isLessThanOrEqualTo(*this, other.convertTo(*_type)); - return cmp2->isLessThanOrEqualTo(convertTo(*other.type_), other); + return cmp2->isLessThanOrEqualTo(convertTo(*other._type), other); } -bool Value::operator !=(const Value &other) const +bool Value::operator !=(const Value& other) const { return !operator==(other); } -bool Value::operator >(const Value &other) const +bool Value::operator >(const Value& other) const { return !operator<=(other); } -bool Value::operator <(const Value &other) const +bool Value::operator <(const Value& other) const { - const Comparator *cmp1 = type_->getComparator(); - const Comparator *cmp2 = other.type_->getComparator(); + const Comparator* cmp1 = _type->getComparator(); + const Comparator* cmp2 = other._type->getComparator(); - const Comparator *cmp = cmp1? cmp1: cmp2; + const Comparator* cmp = cmp1? cmp1: cmp2; if (!cmp) - throw ComparisonNotPermittedException(type_->getStdTypeInfo()); + throw ComparisonNotPermittedException(_type->getStdTypeInfo()); if (cmp1 == cmp2) return cmp->isLessThanOrEqualTo(*this, other) && !cmp->isEqualTo(*this, other); if (cmp1) { - Value temp(other.convertTo(*type_)); + Value temp(other.convertTo(*_type)); return cmp1->isLessThanOrEqualTo(*this, temp) && !cmp1->isEqualTo(*this, temp); } - Value temp(convertTo(*other.type_)); + Value temp(convertTo(*other._type)); return cmp2->isLessThanOrEqualTo(temp, other) && !cmp2->isEqualTo(temp, other); } -bool Value::operator >=(const Value &other) const +bool Value::operator >=(const Value& other) const { - const Comparator *cmp1 = type_->getComparator(); - const Comparator *cmp2 = other.type_->getComparator(); + const Comparator* cmp1 = _type->getComparator(); + const Comparator* cmp2 = other._type->getComparator(); - const Comparator *cmp = cmp1? cmp1: cmp2; + const Comparator* cmp = cmp1? cmp1: cmp2; if (!cmp) - throw ComparisonNotPermittedException(type_->getStdTypeInfo()); + throw ComparisonNotPermittedException(_type->getStdTypeInfo()); if (cmp1 == cmp2) return !cmp->isLessThanOrEqualTo(*this, other) || cmp->isEqualTo(*this, other); if (cmp1) { - Value temp(other.convertTo(*type_)); + Value temp(other.convertTo(*_type)); return !cmp1->isLessThanOrEqualTo(*this, temp) || cmp1->isEqualTo(*this, temp); } - Value temp(convertTo(*other.type_)); + Value temp(convertTo(*other._type)); return !cmp2->isLessThanOrEqualTo(temp, other) || cmp2->isEqualTo(temp, other); }