#ifndef OSGINTROSPECTION_TYPEDMETHODINFO_
#define OSGINTROSPECTION_TYPEDMETHODINFO_

#include <osgIntrospection/MethodInfo>
#include <osgIntrospection/Reflection>

namespace osgIntrospection
{

	/// Class templates TypedMethodInfoN (where 0 <= N <= 16) are concrete 
	/// implementations of MethodInfo. They are used to keep information
	/// about class methods and to provide the means for calling them
	/// dynamically. Each class template can handle methods with N arguments 
	/// and is parametrized by the class that declares the method and by the 
	/// return type. Both const and non-const methods are supported.
	/// The invoke() methods allow to call the reflected method dynamically,
	/// passing it the arguments as a list of Value objects. The instance
	/// on which the reflected method will be called is passed to invoke()
	/// as a Value object, which can contain either a value of type C or a
	/// pointer to C. If the constness doesn't match (i.e., you try to call
	/// a non-const reflected method on a const instance) an exception is
	/// thrown.
	///
	/// NOTE: currently, variant_cast<> does not check pointer conversions,
	/// it simply converts one pointer into another even if they point to
	/// types that are completely unrelated.
	/// This means you won't probably get any exceptions if you try to call
	/// a class' method on another class' instance, but of course that's a
	/// bad, bad idea...
	///
	template<typename C, typename R> 
	class TypedMethodInfo0: public MethodInfo
	{
	public:
		typedef R (C::*ConstFunctionType)() const;
		typedef R (C::*FunctionType)();

		TypedMethodInfo0(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo0(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)();
			if (f_) return (variant_cast<C *>(instance)->*f_)();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(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<const C *>(instance)->*cf_)();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)();
			if (f_) return (variant_cast<C *>(instance)->*f_)();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)();
		if (f_) return (variant_cast<C &>(instance).*f_)();
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename R, typename P0> 
	class TypedMethodInfo1: public MethodInfo
	{
	public:
		typedef R (C::*ConstFunctionType)(P0) const;
		typedef R (C::*FunctionType)(P0);

		TypedMethodInfo1(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo1(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]));
		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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]));
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]));
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename R, typename P0, typename P1> 
	class TypedMethodInfo2: public MethodInfo
	{
	public:
		typedef R (C::*ConstFunctionType)(P0, P1) const;
		typedef R (C::*FunctionType)(P0, P1);

		TypedMethodInfo2(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo2(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]));
		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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]));
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]));
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename R, typename P0, typename P1, typename P2> 
	class TypedMethodInfo3: public MethodInfo
	{
	public:
		typedef R (C::*ConstFunctionType)(P0, P1, P2) const;
		typedef R (C::*FunctionType)(P0, P1, P2);

		TypedMethodInfo3(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo3(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]));
		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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]));
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]));
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename R, typename P0, typename P1, typename P2, typename P3> 
	class TypedMethodInfo4: public MethodInfo
	{
	public:
		typedef R (C::*ConstFunctionType)(P0, P1, P2, P3) const;
		typedef R (C::*FunctionType)(P0, P1, P2, P3);

		TypedMethodInfo4(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo4(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]));
		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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]));
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]));
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4> 
	class TypedMethodInfo5: public MethodInfo
	{
	public:
		typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4) const;
		typedef R (C::*FunctionType)(P0, P1, P2, P3, P4);

		TypedMethodInfo5(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo5(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]));
		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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]));
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]));
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5> 
	class TypedMethodInfo6: public MethodInfo
	{
	public:
		typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5) const;
		typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5);

		TypedMethodInfo6(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo6(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]));
		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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]));
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]));
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6> 
	class TypedMethodInfo7: public MethodInfo
	{
	public:
		typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6) const;
		typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6);

		TypedMethodInfo7(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo7(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]));
		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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]));
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]));
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7> 
	class TypedMethodInfo8: public MethodInfo
	{
	public:
		typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7) const;
		typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7);

		TypedMethodInfo8(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo8(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]));
		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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]));
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]));
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8> 
	class TypedMethodInfo9: public MethodInfo
	{
	public:
		typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8) const;
		typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8);

		TypedMethodInfo9(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo9(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]));
		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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]));
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]));
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9> 
	class TypedMethodInfo10: public MethodInfo
	{
	public:
		typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) const;
		typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9);

		TypedMethodInfo10(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo10(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]));
		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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]));
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]));
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10> 
	class TypedMethodInfo11: public MethodInfo
	{
	public:
		typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) const;
		typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10);

		TypedMethodInfo11(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo11(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]));
		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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]));
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]));
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11> 
	class TypedMethodInfo12: public MethodInfo
	{
	public:
		typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) const;
		typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11);

		TypedMethodInfo12(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo12(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]));
		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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]));
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]));
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12> 
	class TypedMethodInfo13: public MethodInfo
	{
	public:
		typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) const;
		typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12);

		TypedMethodInfo13(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo13(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]));
		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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]));
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]));
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13> 
	class TypedMethodInfo14: public MethodInfo
	{
	public:
		typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) const;
		typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13);

		TypedMethodInfo14(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo14(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]));
		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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]));
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]));
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14> 
	class TypedMethodInfo15: public MethodInfo
	{
	public:
		typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) const;
		typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14);

		TypedMethodInfo15(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo15(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]));
		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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]));
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]));
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15> 
	class TypedMethodInfo16: public MethodInfo
	{
	public:
		typedef R (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) const;
		typedef R (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15);

		TypedMethodInfo16(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo16(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(R), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]), variant_cast<P15>(args[15]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]), variant_cast<P15>(args[15]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]), variant_cast<P15>(args[15]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]), variant_cast<P15>(args[15]));
		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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]), variant_cast<P15>(args[15]));
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]), variant_cast<P15>(args[15]));
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]), variant_cast<P15>(args[15]));
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]), variant_cast<P15>(args[15]));
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]), variant_cast<P15>(args[15]));
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C> 
	class TypedMethodInfo0<C, void>: public MethodInfo
	{
	public:
		typedef void (C::*ConstFunctionType)() const;
		typedef void (C::*FunctionType)();

		TypedMethodInfo0(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo0(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(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<const C *>(instance)->*cf_)(), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(), Value();
		if (f_) return (variant_cast<C &>(instance).*f_)(), Value();
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename P0> 
	class TypedMethodInfo1<C, void, P0>: public MethodInfo
	{
	public:
		typedef void (C::*ConstFunctionType)(P0) const;
		typedef void (C::*FunctionType)(P0);

		TypedMethodInfo1(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo1(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0])), 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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0])), Value();
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0])), Value();
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename P0, typename P1> 
	class TypedMethodInfo2<C, void, P0, P1>: public MethodInfo
	{
	public:
		typedef void (C::*ConstFunctionType)(P0, P1) const;
		typedef void (C::*FunctionType)(P0, P1);

		TypedMethodInfo2(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo2(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1])), 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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1])), Value();
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1])), Value();
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename P0, typename P1, typename P2> 
	class TypedMethodInfo3<C, void, P0, P1, P2>: public MethodInfo
	{
	public:
		typedef void (C::*ConstFunctionType)(P0, P1, P2) const;
		typedef void (C::*FunctionType)(P0, P1, P2);

		TypedMethodInfo3(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo3(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2])), 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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2])), Value();
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2])), Value();
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename P0, typename P1, typename P2, typename P3> 
	class TypedMethodInfo4<C, void, P0, P1, P2, P3>: public MethodInfo
	{
	public:
		typedef void (C::*ConstFunctionType)(P0, P1, P2, P3) const;
		typedef void (C::*FunctionType)(P0, P1, P2, P3);

		TypedMethodInfo4(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo4(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3])), 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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3])), Value();
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3])), Value();
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4> 
	class TypedMethodInfo5<C, void, P0, P1, P2, P3, P4>: public MethodInfo
	{
	public:
		typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4) const;
		typedef void (C::*FunctionType)(P0, P1, P2, P3, P4);

		TypedMethodInfo5(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo5(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4])), 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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4])), Value();
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4])), Value();
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5> 
	class TypedMethodInfo6<C, void, P0, P1, P2, P3, P4, P5>: public MethodInfo
	{
	public:
		typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5) const;
		typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5);

		TypedMethodInfo6(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo6(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5])), 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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5])), Value();
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5])), Value();
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6> 
	class TypedMethodInfo7<C, void, P0, P1, P2, P3, P4, P5, P6>: public MethodInfo
	{
	public:
		typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6) const;
		typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6);

		TypedMethodInfo7(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo7(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6])), 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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6])), Value();
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6])), Value();
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7> 
	class TypedMethodInfo8<C, void, P0, P1, P2, P3, P4, P5, P6, P7>: public MethodInfo
	{
	public:
		typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7) const;
		typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7);

		TypedMethodInfo8(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo8(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7])), 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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7])), Value();
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7])), Value();
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8> 
	class TypedMethodInfo9<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8>: public MethodInfo
	{
	public:
		typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8) const;
		typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8);

		TypedMethodInfo9(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo9(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8])), 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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8])), Value();
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8])), Value();
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9> 
	class TypedMethodInfo10<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>: public MethodInfo
	{
	public:
		typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) const;
		typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9);

		TypedMethodInfo10(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo10(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9])), 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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9])), Value();
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9])), Value();
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10> 
	class TypedMethodInfo11<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>: public MethodInfo
	{
	public:
		typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) const;
		typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10);

		TypedMethodInfo11(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo11(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10])), 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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10])), Value();
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10])), Value();
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11> 
	class TypedMethodInfo12<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>: public MethodInfo
	{
	public:
		typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) const;
		typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11);

		TypedMethodInfo12(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo12(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11])), 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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11])), Value();
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11])), Value();
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12> 
	class TypedMethodInfo13<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>: public MethodInfo
	{
	public:
		typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) const;
		typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12);

		TypedMethodInfo13(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo13(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12])), 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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12])), Value();
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12])), Value();
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13> 
	class TypedMethodInfo14<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>: public MethodInfo
	{
	public:
		typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) const;
		typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13);

		TypedMethodInfo14(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo14(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13])), 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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13])), Value();
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13])), Value();
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14> 
	class TypedMethodInfo15<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>: public MethodInfo
	{
	public:
		typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) const;
		typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14);

		TypedMethodInfo15(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo15(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14])), 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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14])), Value();
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14])), Value();
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


	template<typename C, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15> 
	class TypedMethodInfo16<C, void, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>: public MethodInfo
	{
	public:
		typedef void (C::*ConstFunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) const;
		typedef void (C::*FunctionType)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15);

		TypedMethodInfo16(const std::string &qname, ConstFunctionType cf, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(cf), f_(0)
		{
		}

		TypedMethodInfo16(const std::string &qname, FunctionType f, const ParameterInfoList &plist)
		:	MethodInfo(qname, typeof(C), typeof(void), plist), cf_(0), f_(f)
		{
		}

		bool isConst() const { return cf_; }

	Value invoke(const Value &instance, ValueList &args) const
	{
		const Type &type = instance.getType();
		if (type.isPointer())
		{
			if (type.isConstPointer())
			{
				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]), variant_cast<P15>(args[15])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]), variant_cast<P15>(args[15])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]), variant_cast<P15>(args[15])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]), variant_cast<P15>(args[15])), 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<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]), variant_cast<P15>(args[15])), Value();
				if (f_) throw ConstIsConstException();
				throw InvalidFunctionPointerException();
			}
			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]), variant_cast<P15>(args[15])), Value();
			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]), variant_cast<P15>(args[15])), Value();
			throw InvalidFunctionPointerException();
		}
		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]), variant_cast<P15>(args[15])), Value();
		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]), variant_cast<P3>(args[3]), variant_cast<P4>(args[4]), variant_cast<P5>(args[5]), variant_cast<P6>(args[6]), variant_cast<P7>(args[7]), variant_cast<P8>(args[8]), variant_cast<P9>(args[9]), variant_cast<P10>(args[10]), variant_cast<P11>(args[11]), variant_cast<P12>(args[12]), variant_cast<P13>(args[13]), variant_cast<P14>(args[14]), variant_cast<P15>(args[15])), Value();
		throw InvalidFunctionPointerException();
	}

	private:
		ConstFunctionType cf_;
		FunctionType f_;
	};


}

#endif