From 21ae4c6c65d6219725992262a0b3861d7b791ebb Mon Sep 17 00:00:00 2001
From: Robert Osfield <robert@openscenegraph.com>
Date: Mon, 14 Mar 2005 09:13:38 +0000
Subject: [PATCH] From Marco Jez, fix for data corruption bug in
 TypedMethodInfo*::invoke()

---
 include/osgIntrospection/TypedMethodInfo | 1121 ++++++++++++++++------
 1 file changed, 833 insertions(+), 288 deletions(-)

diff --git a/include/osgIntrospection/TypedMethodInfo b/include/osgIntrospection/TypedMethodInfo
index 8df0d14fb..df6fbd19a 100644
--- a/include/osgIntrospection/TypedMethodInfo
+++ b/include/osgIntrospection/TypedMethodInfo
@@ -114,41 +114,43 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]));
+				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0));
 			throw InvalidFunctionPointerException();
 		}
-		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]));
+		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0));
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]));
+				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0));
 			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]));
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0));
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0));
 		throw InvalidFunctionPointerException();
 	}
 
@@ -179,41 +181,45 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]));
+				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1));
 			throw InvalidFunctionPointerException();
 		}
-		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]));
+		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1));
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]));
+				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1));
 			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]));
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1));
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1));
 		throw InvalidFunctionPointerException();
 	}
 
@@ -244,41 +250,47 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]));
+				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2));
 			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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2));
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2]));
+				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2));
 			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]));
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2));
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2));
 		throw InvalidFunctionPointerException();
 	}
 
@@ -309,41 +321,49 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3));
 			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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3));
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3));
 			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]));
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3));
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3));
 		throw InvalidFunctionPointerException();
 	}
 
@@ -374,41 +394,51 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4));
 			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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4));
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4));
 			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]));
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4));
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4));
 		throw InvalidFunctionPointerException();
 	}
 
@@ -439,41 +469,53 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5));
 			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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5));
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5));
 			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]));
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5));
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5));
 		throw InvalidFunctionPointerException();
 	}
 
@@ -504,41 +546,55 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6));
 			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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6));
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6));
 			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]));
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6));
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6));
 		throw InvalidFunctionPointerException();
 	}
 
@@ -569,41 +625,57 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7));
 			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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7));
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7));
 			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]));
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7));
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7));
 		throw InvalidFunctionPointerException();
 	}
 
@@ -634,41 +706,59 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8));
 			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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8));
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8));
 			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]));
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8));
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8));
 		throw InvalidFunctionPointerException();
 	}
 
@@ -699,41 +789,61 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9));
 			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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9));
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9));
 			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]));
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9));
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9));
 		throw InvalidFunctionPointerException();
 	}
 
@@ -764,41 +874,63 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10));
 			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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10));
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10));
 			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]));
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10));
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10));
 		throw InvalidFunctionPointerException();
 	}
 
@@ -829,41 +961,65 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11));
 			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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11));
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11));
 			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]));
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11));
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11));
 		throw InvalidFunctionPointerException();
 	}
 
@@ -894,41 +1050,67 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
+		Value a12(args[12].convertTo(typeof(P12)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12));
 			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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12));
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
+		Value a12(args[12].convertTo(typeof(P12)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12));
 			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]));
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12));
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12));
 		throw InvalidFunctionPointerException();
 	}
 
@@ -959,41 +1141,69 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
+		Value a12(args[12].convertTo(typeof(P12)));
+		Value a13(args[13].convertTo(typeof(P13)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13));
 			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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13));
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
+		Value a12(args[12].convertTo(typeof(P12)));
+		Value a13(args[13].convertTo(typeof(P13)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13));
 			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]));
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13));
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13));
 		throw InvalidFunctionPointerException();
 	}
 
@@ -1024,41 +1234,71 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
+		Value a12(args[12].convertTo(typeof(P12)));
+		Value a13(args[13].convertTo(typeof(P13)));
+		Value a14(args[14].convertTo(typeof(P14)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14));
 			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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14));
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
+		Value a12(args[12].convertTo(typeof(P12)));
+		Value a13(args[13].convertTo(typeof(P13)));
+		Value a14(args[14].convertTo(typeof(P14)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14));
 			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]));
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14));
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14));
 		throw InvalidFunctionPointerException();
 	}
 
@@ -1089,41 +1329,73 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
+		Value a12(args[12].convertTo(typeof(P12)));
+		Value a13(args[13].convertTo(typeof(P13)));
+		Value a14(args[14].convertTo(typeof(P14)));
+		Value a15(args[15].convertTo(typeof(P15)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14), variant_cast<P15>(a15));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14), variant_cast<P15>(a15));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14), variant_cast<P15>(a15));
 			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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14), variant_cast<P15>(a15));
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
+		Value a12(args[12].convertTo(typeof(P12)));
+		Value a13(args[13].convertTo(typeof(P13)));
+		Value a14(args[14].convertTo(typeof(P14)));
+		Value a15(args[15].convertTo(typeof(P15)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14), variant_cast<P15>(a15));
 				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]));
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14), variant_cast<P15>(a15));
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14), variant_cast<P15>(a15));
 			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]));
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14), variant_cast<P15>(a15));
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14), variant_cast<P15>(a15));
 		throw InvalidFunctionPointerException();
 	}
 
@@ -1219,41 +1491,43 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0])), Value();
+				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0)), Value();
 			throw InvalidFunctionPointerException();
 		}
-		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0])), Value();
+		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0)), Value();
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0])), Value();
+				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0)), 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();
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0)), Value();
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0)), Value();
 		throw InvalidFunctionPointerException();
 	}
 
@@ -1284,41 +1558,45 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1])), Value();
+				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1)), Value();
 			throw InvalidFunctionPointerException();
 		}
-		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1])), Value();
+		if (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1)), Value();
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1])), Value();
+				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1)), 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();
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1)), Value();
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1)), Value();
 		throw InvalidFunctionPointerException();
 	}
 
@@ -1349,41 +1627,47 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2])), Value();
+				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2)), 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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2)), Value();
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(args[0]), variant_cast<P1>(args[1]), variant_cast<P2>(args[2])), Value();
+				if (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2)), 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();
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2)), Value();
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2)), Value();
 		throw InvalidFunctionPointerException();
 	}
 
@@ -1414,41 +1698,49 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3)), 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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3)), Value();
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3)), 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();
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3)), Value();
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3)), Value();
 		throw InvalidFunctionPointerException();
 	}
 
@@ -1479,41 +1771,51 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4)), 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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4)), Value();
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4)), 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();
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4)), Value();
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4)), Value();
 		throw InvalidFunctionPointerException();
 	}
 
@@ -1544,41 +1846,53 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5)), 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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5)), Value();
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5)), 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();
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5)), Value();
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5)), Value();
 		throw InvalidFunctionPointerException();
 	}
 
@@ -1609,41 +1923,55 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6)), 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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6)), Value();
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6)), 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();
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6)), Value();
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6)), Value();
 		throw InvalidFunctionPointerException();
 	}
 
@@ -1674,41 +2002,57 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7)), 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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7)), Value();
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7)), 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();
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7)), Value();
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7)), Value();
 		throw InvalidFunctionPointerException();
 	}
 
@@ -1739,41 +2083,59 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8)), 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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8)), Value();
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8)), 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();
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8)), Value();
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8)), Value();
 		throw InvalidFunctionPointerException();
 	}
 
@@ -1804,41 +2166,61 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9)), 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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9)), Value();
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9)), 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();
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9)), Value();
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9)), Value();
 		throw InvalidFunctionPointerException();
 	}
 
@@ -1869,41 +2251,63 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10)), 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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10)), Value();
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10)), 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();
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10)), Value();
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10)), Value();
 		throw InvalidFunctionPointerException();
 	}
 
@@ -1934,41 +2338,65 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11)), 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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11)), Value();
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11)), 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();
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11)), Value();
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11)), Value();
 		throw InvalidFunctionPointerException();
 	}
 
@@ -1999,41 +2427,67 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
+		Value a12(args[12].convertTo(typeof(P12)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12)), 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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12)), Value();
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
+		Value a12(args[12].convertTo(typeof(P12)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12)), 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();
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12)), Value();
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12)), Value();
 		throw InvalidFunctionPointerException();
 	}
 
@@ -2064,41 +2518,69 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
+		Value a12(args[12].convertTo(typeof(P12)));
+		Value a13(args[13].convertTo(typeof(P13)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13)), 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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13)), Value();
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
+		Value a12(args[12].convertTo(typeof(P12)));
+		Value a13(args[13].convertTo(typeof(P13)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13)), 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();
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13)), Value();
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13)), Value();
 		throw InvalidFunctionPointerException();
 	}
 
@@ -2129,41 +2611,71 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
+		Value a12(args[12].convertTo(typeof(P12)));
+		Value a13(args[13].convertTo(typeof(P13)));
+		Value a14(args[14].convertTo(typeof(P14)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14)), 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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14)), Value();
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
+		Value a12(args[12].convertTo(typeof(P12)));
+		Value a13(args[13].convertTo(typeof(P13)));
+		Value a14(args[14].convertTo(typeof(P14)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14)), 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();
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14)), Value();
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14)), Value();
 		throw InvalidFunctionPointerException();
 	}
 
@@ -2194,41 +2706,73 @@ namespace osgIntrospection
 
 	Value invoke(const Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
+		Value a12(args[12].convertTo(typeof(P12)));
+		Value a13(args[13].convertTo(typeof(P13)));
+		Value a14(args[14].convertTo(typeof(P14)));
+		Value a15(args[15].convertTo(typeof(P15)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14), variant_cast<P15>(a15)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14), variant_cast<P15>(a15)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14), variant_cast<P15>(a15)), 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 (cf_) return (variant_cast<const C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14), variant_cast<P15>(a15)), Value();
 		if (f_) throw ConstIsConstException();
 		throw InvalidFunctionPointerException();
 	}
 
 	Value invoke(Value &instance, ValueList &args) const
 	{
+		Value a0(args[0].convertTo(typeof(P0)));
+		Value a1(args[1].convertTo(typeof(P1)));
+		Value a2(args[2].convertTo(typeof(P2)));
+		Value a3(args[3].convertTo(typeof(P3)));
+		Value a4(args[4].convertTo(typeof(P4)));
+		Value a5(args[5].convertTo(typeof(P5)));
+		Value a6(args[6].convertTo(typeof(P6)));
+		Value a7(args[7].convertTo(typeof(P7)));
+		Value a8(args[8].convertTo(typeof(P8)));
+		Value a9(args[9].convertTo(typeof(P9)));
+		Value a10(args[10].convertTo(typeof(P10)));
+		Value a11(args[11].convertTo(typeof(P11)));
+		Value a12(args[12].convertTo(typeof(P12)));
+		Value a13(args[13].convertTo(typeof(P13)));
+		Value a14(args[14].convertTo(typeof(P14)));
+		Value a15(args[15].convertTo(typeof(P15)));
 		const Type &type = instance.getType();
 		if (type.isPointer())
 		{
 			if (type.isConstPointer())
 			{
-				if (cf_) return (variant_cast<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 (cf_) return (variant_cast<const C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14), variant_cast<P15>(a15)), 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();
+			if (cf_) return (variant_cast<C *>(instance)->*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14), variant_cast<P15>(a15)), Value();
+			if (f_) return (variant_cast<C *>(instance)->*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14), variant_cast<P15>(a15)), 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();
+		if (cf_) return (variant_cast<C &>(instance).*cf_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14), variant_cast<P15>(a15)), Value();
+		if (f_) return (variant_cast<C &>(instance).*f_)(variant_cast<P0>(a0), variant_cast<P1>(a1), variant_cast<P2>(a2), variant_cast<P3>(a3), variant_cast<P4>(a4), variant_cast<P5>(a5), variant_cast<P6>(a6), variant_cast<P7>(a7), variant_cast<P8>(a8), variant_cast<P9>(a9), variant_cast<P10>(a10), variant_cast<P11>(a11), variant_cast<P12>(a12), variant_cast<P13>(a13), variant_cast<P14>(a14), variant_cast<P15>(a15)), Value();
 		throw InvalidFunctionPointerException();
 	}
 
@@ -2241,3 +2785,4 @@ namespace osgIntrospection
 }
 
 #endif
+