From d48e9ffd019ae1827fda4bc74228253fa34e56a0 Mon Sep 17 00:00:00 2001
From: hammonda <david.hammond@sannopoint.com>
Date: Tue, 16 Oct 2012 10:44:22 +0100
Subject: [PATCH 1/6] Added type trait to determine if a type is convertible to
 a V8 JS type.

---
 src/vu8/detail/TypeTraits.hpp | 43 +++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 src/vu8/detail/TypeTraits.hpp

diff --git a/src/vu8/detail/TypeTraits.hpp b/src/vu8/detail/TypeTraits.hpp
new file mode 100644
index 0000000..6fb568b
--- /dev/null
+++ b/src/vu8/detail/TypeTraits.hpp
@@ -0,0 +1,43 @@
+#ifndef TYPETRAITS_HPP_
+#define TYPETRAITS_HPP_
+
+#include <string>
+
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/utility/enable_if.hpp>
+
+#include <v8.h>
+
+namespace vu8 {
+
+template <typename T> struct remove_reference_and_const {
+  typedef typename boost::remove_const<
+    typename boost::remove_reference<T>::type
+  >::type type;
+};
+
+template <typename T, typename Enable = void>
+struct is_to_v8_convertible : public boost::false_type { };
+
+template <typename T>
+struct is_to_v8_convertible<T, typename boost::enable_if<
+  boost::is_arithmetic<T>
+>::type> : public boost::true_type { };
+
+#define VU8_TO_V8_CONV_TYPE_TRAIT_SPEC(T,M,spec) \
+template <typename T > \
+struct is_to_v8_convertible<T, typename boost::enable_if< \
+  boost::is_same<M, spec > \
+>::type> : public boost::true_type { }; \
+/**/
+
+VU8_TO_V8_CONV_TYPE_TRAIT_SPEC(T,T,v8::Handle<v8::Value>);
+VU8_TO_V8_CONV_TYPE_TRAIT_SPEC(T,typename remove_reference_and_const<T>::type, std::string);
+}
+
+#endif /* TYPETRAITS_HPP_ */

From 950da8da1a93305eb1b38a16fd98c4e619218645 Mon Sep 17 00:00:00 2001
From: hammonda <david.hammond@sannopoint.com>
Date: Tue, 16 Oct 2012 10:45:42 +0100
Subject: [PATCH 2/6] Added specialization to MemFunProto to allow return types
 which are wrapped c++ classes.

---
 src/vu8/detail/ProtoHelper.hpp | 78 ++++++++++++++++++++++------------
 1 file changed, 51 insertions(+), 27 deletions(-)

diff --git a/src/vu8/detail/ProtoHelper.hpp b/src/vu8/detail/ProtoHelper.hpp
index 1aa3b89..30c1fa7 100644
--- a/src/vu8/detail/ProtoHelper.hpp
+++ b/src/vu8/detail/ProtoHelper.hpp
@@ -1,23 +1,29 @@
 #ifndef BOOST_PP_IS_ITERATING
-#   ifndef TSA_VU8_DETAIL_PROTO_HELPER_HPP
-#   define TSA_VU8_DETAIL_PROTO_HELPER_HPP
-#       include <vu8/config.hpp>
-
-#       include <boost/preprocessor/repetition.hpp>
-#       include <boost/preprocessor/punctuation/comma_if.hpp>
-#       include <boost/preprocessor/iteration/iterate.hpp>
-#       include <boost/mpl/vector.hpp>
-
-#       ifndef VU8_PROTO_MAX_SIZE
-#         define VU8_PROTO_MAX_SIZE VU8_PP_ITERATION_LIMIT
-#       endif
-namespace vu8 { namespace detail {
+#  ifndef TSA_VU8_DETAIL_PROTO_HELPER_HPP
+#  define TSA_VU8_DETAIL_PROTO_HELPER_HPP
+#    include <vu8/config.hpp>
+
+#    include <boost/preprocessor/repetition.hpp>
+#    include <boost/preprocessor/punctuation/comma_if.hpp>
+#    include <boost/preprocessor/iteration/iterate.hpp>
+#    include <boost/mpl/vector.hpp>
+#    include <boost/type_traits/integral_constant.hpp>
+
+#    ifndef VU8_PROTO_MAX_SIZE
+#      define VU8_PROTO_MAX_SIZE VU8_PP_ITERATION_LIMIT
+#    endif
+namespace vu8 {
+
+template <class T, class F> struct Class;
+template <class T, class F> struct ClassSingleton;
+
+namespace detail {
 
 namespace mpl = boost::mpl;
 
 template <class R>
 struct FunProtoBase {
-    typedef R return_type;
+  typedef R return_type;
 };
 
 template <class T>
@@ -27,37 +33,55 @@ template <class C, class T>
 struct MemFunProto;
 
 } }
-#       define BOOST_PP_ITERATION_LIMITS (0, VU8_PROTO_MAX_SIZE - 1)
-#       define BOOST_PP_FILENAME_1       "vu8/detail/ProtoHelper.hpp"
-#       include BOOST_PP_ITERATE()
-#    endif // include guard
+#    define BOOST_PP_ITERATION_LIMITS (0, VU8_PROTO_MAX_SIZE - 1)
+#    define BOOST_PP_FILENAME_1       "vu8/detail/ProtoHelper.hpp"
+#    include BOOST_PP_ITERATE()
+#  endif // include guard
 #else // BOOST_PP_IS_ITERATING
 
-#   define n BOOST_PP_ITERATION()
-#   define VU8_PROTO_print(z, n, data) data
+#  define n BOOST_PP_ITERATION()
+#  define VU8_PROTO_print(z, n, data) data
 
 namespace vu8 { namespace detail {
 
 template <class R BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A)>
 struct FunProto<R ( BOOST_PP_ENUM_PARAMS(n, A) )> : FunProtoBase<R> {
-    typedef mpl::vector<BOOST_PP_ENUM_PARAMS(n, A)>   arguments;
-    typedef R(*function_type)(BOOST_PP_ENUM_PARAMS(n, A));
+  typedef mpl::vector<BOOST_PP_ENUM_PARAMS(n, A)>   arguments;
+  typedef R(*function_type)(BOOST_PP_ENUM_PARAMS(n, A));
 };
 
 template <class C, class R BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A)>
 struct MemFunProto<C, R ( BOOST_PP_ENUM_PARAMS(n, A) )> : FunProtoBase<R> {
-    typedef mpl::vector<BOOST_PP_ENUM_PARAMS(n, A)>   arguments;
-    typedef R(C::*method_type)(BOOST_PP_ENUM_PARAMS(n, A));
+  typedef mpl::vector<BOOST_PP_ENUM_PARAMS(n, A)>   arguments;
+  typedef R(C::*method_type)(BOOST_PP_ENUM_PARAMS(n, A));
+  typedef boost::false_type IS_RETURN_WRAPPED_CLASS;
+};
+
+template <class C, class R, class Factory BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A)>
+struct MemFunProto<C, vu8::Class<R, Factory> ( BOOST_PP_ENUM_PARAMS(n, A) )> : FunProtoBase<R> {
+  typedef mpl::vector<BOOST_PP_ENUM_PARAMS(n, A)>   arguments;
+  typedef R(C::*method_type)(BOOST_PP_ENUM_PARAMS(n, A));
+  typedef boost::true_type IS_RETURN_WRAPPED_CLASS;
+  typedef vu8::ClassSingleton<R, Factory> ClassSingleton;
 };
 
 template <class C, class R BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A)>
 struct MemFunProto<C const, R ( BOOST_PP_ENUM_PARAMS(n, A) )> : FunProtoBase<R> {
-    typedef mpl::vector<BOOST_PP_ENUM_PARAMS(n, A)>   arguments;
-    typedef R(C::*method_type)(BOOST_PP_ENUM_PARAMS(n, A)) const;
+  typedef mpl::vector<BOOST_PP_ENUM_PARAMS(n, A)>   arguments;
+  typedef R(C::*method_type)(BOOST_PP_ENUM_PARAMS(n, A)) const;
+  typedef boost::false_type IS_RETURN_WRAPPED_CLASS;
+};
+
+template <class C, class R, class Factory BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A)>
+struct MemFunProto<C const, vu8::Class<R, Factory> ( BOOST_PP_ENUM_PARAMS(n, A) )> : FunProtoBase<R> {
+  typedef mpl::vector<BOOST_PP_ENUM_PARAMS(n, A)>   arguments;
+  typedef R(C::*method_type)(BOOST_PP_ENUM_PARAMS(n, A)) const;
+  typedef boost::true_type IS_RETURN_WRAPPED_CLASS;
+  typedef vu8::ClassSingleton<R, Factory> ClassSingleton;
 };
 
 } }
 
-#   undef n
+#  undef n
 
 #endif

From f907da78f40ce0dd33f0f937080432f73feaba52 Mon Sep 17 00:00:00 2001
From: hammonda <david.hammond@sannopoint.com>
Date: Tue, 16 Oct 2012 10:48:12 +0100
Subject: [PATCH 3/6] Added ForwardReturn method overload to handle returning
 wrapped classes.

---
 src/vu8/Class.hpp | 41 ++++++++++++++++++++++++++++++-----------
 1 file changed, 30 insertions(+), 11 deletions(-)

diff --git a/src/vu8/Class.hpp b/src/vu8/Class.hpp
index 65bae3a..e970061 100644
--- a/src/vu8/Class.hpp
+++ b/src/vu8/Class.hpp
@@ -9,6 +9,7 @@
 #include <vu8/detail/Proto.hpp>
 #include <vu8/detail/Singleton.hpp>
 #include <vu8/detail/Class.hpp>
+#include <vu8/detail/TypeTraits.hpp>
 
 #include <boost/fusion/container/vector.hpp>
 #include <boost/fusion/adapted/mpl.hpp>
@@ -64,7 +65,7 @@ struct ClassSingletonFactory<M, NoFactory> {
 
 template <class T, class Factory>
 class ClassSingleton
-  : detail::LazySingleton< ClassSingleton<T, Factory> >,
+  : private detail::LazySingleton< ClassSingleton<T, Factory> >,
     public ClassSingletonFactory<ClassSingleton<T, Factory>, Factory>
 {
     friend class ClassSingletonFactory<ClassSingleton<T, Factory>, Factory>;
@@ -92,22 +93,40 @@ class ClassSingleton
     static inline typename boost::disable_if<
         detail::PassDirectIf<P>, typename P::return_type >::type
     Invoke(T *obj, const v8::Arguments& args) {
-        return CallFromV8<P>(*obj, args);
+      return CallFromV8<P>(*obj, args);
     }
 
     template <class P>
-    static inline typename boost::disable_if<
-        boost::is_same<void, typename P::return_type>, ValueHandle >::type
-    ForwardReturn(T *obj, const v8::Arguments& args) {
-        return ToV8(Invoke<P>(obj, args));
+    static inline typename
+    boost::enable_if<vu8::is_to_v8_convertible<typename P::return_type>,
+    ValueHandle >::type ForwardReturn (T *obj, const v8::Arguments& args) {
+      return ToV8(Invoke<P>(obj, args));
     }
 
     template <class P>
-    static inline typename boost::enable_if<
-        boost::is_same<void, typename P::return_type>, ValueHandle >::type
-    ForwardReturn(T *obj, const v8::Arguments& args) {
-        Invoke<P>(obj, args);
-        return v8::Undefined();
+    static inline typename
+    boost::enable_if<boost::is_void<typename P::return_type>,
+    ValueHandle >::type ForwardReturn (T *obj, const v8::Arguments& args) {
+      Invoke<P>(obj, args);
+      return v8::Undefined();
+    }
+
+    template <class P>
+    static inline typename
+    boost::enable_if<typename P::IS_RETURN_WRAPPED_CLASS,
+    ValueHandle >::type ForwardReturn (T *obj, const v8::Arguments& args) {
+      typedef typename P::ClassSingleton LocalSelf;
+      typedef typename P::return_type ReturnType;
+
+      v8::HandleScope scope;
+      ReturnType* return_value = new ReturnType(Invoke<P>(obj, args));
+      v8::Local<v8::Object> localObj =
+          LocalSelf::Instance().func_->GetFunction()->NewInstance();
+      v8::Persistent<v8::Object> persistentObj =
+          v8::Persistent<v8::Object>::New(localObj);
+      persistentObj->SetInternalField(0, v8::External::New(return_value));
+      persistentObj.MakeWeak(return_value, &LocalSelf::MadeWeak);
+      return scope.Close(localObj);
     }
 
     // every method is run inside a handle scope

From 75eddebce4d0b7924b8851f39fd33c3383a4f967 Mon Sep 17 00:00:00 2001
From: hammonda <david.hammond@sannopoint.com>
Date: Tue, 16 Oct 2012 11:04:15 +0100
Subject: [PATCH 4/6] Added missing include for boost::is_void.

---
 src/vu8/Class.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/vu8/Class.hpp b/src/vu8/Class.hpp
index e970061..dee3e39 100644
--- a/src/vu8/Class.hpp
+++ b/src/vu8/Class.hpp
@@ -16,6 +16,8 @@
 #include <boost/fusion/include/push_front.hpp>
 #include <boost/fusion/include/join.hpp>
 
+#include <boost/type_traits/is_void.hpp>
+
 #include <iostream>
 #include <stdexcept>
 

From 6894587a8cbf4945d7425b9944940b03fa8d7c9d Mon Sep 17 00:00:00 2001
From: hammonda <david.hammond@sannopoint.com>
Date: Sat, 3 Nov 2012 09:50:12 +0000
Subject: [PATCH 5/6] Changed typename to class to be consistent with parent
 vu8 project.

---
 src/vu8/detail/TypeTraits.hpp | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/vu8/detail/TypeTraits.hpp b/src/vu8/detail/TypeTraits.hpp
index 6fb568b..368cb56 100644
--- a/src/vu8/detail/TypeTraits.hpp
+++ b/src/vu8/detail/TypeTraits.hpp
@@ -15,24 +15,24 @@
 
 namespace vu8 {
 
-template <typename T> struct remove_reference_and_const {
-  typedef typename boost::remove_const<
-    typename boost::remove_reference<T>::type
-  >::type type;
+template <class T> struct remove_reference_and_const {
+    typedef typename boost::remove_const<
+        typename boost::remove_reference<T>::type
+    >::type type;
 };
 
-template <typename T, typename Enable = void>
+template <class T, class Enable = void>
 struct is_to_v8_convertible : public boost::false_type { };
 
-template <typename T>
+template <class T>
 struct is_to_v8_convertible<T, typename boost::enable_if<
-  boost::is_arithmetic<T>
+    boost::is_arithmetic<T>
 >::type> : public boost::true_type { };
 
 #define VU8_TO_V8_CONV_TYPE_TRAIT_SPEC(T,M,spec) \
-template <typename T > \
+template <class T > \
 struct is_to_v8_convertible<T, typename boost::enable_if< \
-  boost::is_same<M, spec > \
+    boost::is_same<M, spec > \
 >::type> : public boost::true_type { }; \
 /**/
 

From 678664ea8b9de4ec3c3880cfb5962253b3eb02a4 Mon Sep 17 00:00:00 2001
From: hammonda <david.hammond@sannopoint.com>
Date: Sat, 3 Nov 2012 09:52:43 +0000
Subject: [PATCH 6/6] Reformatted to be consistent with parent vu8 project.

---
 src/vu8/Class.hpp              | 32 +++++++--------
 src/vu8/detail/ProtoHelper.hpp | 74 +++++++++++++++++-----------------
 2 files changed, 53 insertions(+), 53 deletions(-)

diff --git a/src/vu8/Class.hpp b/src/vu8/Class.hpp
index dee3e39..6042e95 100644
--- a/src/vu8/Class.hpp
+++ b/src/vu8/Class.hpp
@@ -95,40 +95,40 @@ class ClassSingleton
     static inline typename boost::disable_if<
         detail::PassDirectIf<P>, typename P::return_type >::type
     Invoke(T *obj, const v8::Arguments& args) {
-      return CallFromV8<P>(*obj, args);
+        return CallFromV8<P>(*obj, args);
     }
 
     template <class P>
     static inline typename
     boost::enable_if<vu8::is_to_v8_convertible<typename P::return_type>,
     ValueHandle >::type ForwardReturn (T *obj, const v8::Arguments& args) {
-      return ToV8(Invoke<P>(obj, args));
+        return ToV8(Invoke<P>(obj, args));
     }
 
     template <class P>
     static inline typename
     boost::enable_if<boost::is_void<typename P::return_type>,
     ValueHandle >::type ForwardReturn (T *obj, const v8::Arguments& args) {
-      Invoke<P>(obj, args);
-      return v8::Undefined();
+        Invoke<P>(obj, args);
+        return v8::Undefined();
     }
 
     template <class P>
     static inline typename
     boost::enable_if<typename P::IS_RETURN_WRAPPED_CLASS,
     ValueHandle >::type ForwardReturn (T *obj, const v8::Arguments& args) {
-      typedef typename P::ClassSingleton LocalSelf;
-      typedef typename P::return_type ReturnType;
-
-      v8::HandleScope scope;
-      ReturnType* return_value = new ReturnType(Invoke<P>(obj, args));
-      v8::Local<v8::Object> localObj =
-          LocalSelf::Instance().func_->GetFunction()->NewInstance();
-      v8::Persistent<v8::Object> persistentObj =
-          v8::Persistent<v8::Object>::New(localObj);
-      persistentObj->SetInternalField(0, v8::External::New(return_value));
-      persistentObj.MakeWeak(return_value, &LocalSelf::MadeWeak);
-      return scope.Close(localObj);
+        typedef typename P::ClassSingleton LocalSelf;
+        typedef typename P::return_type ReturnType;
+
+        v8::HandleScope scope;
+        ReturnType* return_value = new ReturnType(Invoke<P>(obj, args));
+        v8::Local<v8::Object> localObj =
+            LocalSelf::Instance().func_->GetFunction()->NewInstance();
+        v8::Persistent<v8::Object> persistentObj =
+            v8::Persistent<v8::Object>::New(localObj);
+        persistentObj->SetInternalField(0, v8::External::New(return_value));
+        persistentObj.MakeWeak(return_value, &LocalSelf::MadeWeak);
+        return scope.Close(localObj);
     }
 
     // every method is run inside a handle scope
diff --git a/src/vu8/detail/ProtoHelper.hpp b/src/vu8/detail/ProtoHelper.hpp
index 30c1fa7..89f1590 100644
--- a/src/vu8/detail/ProtoHelper.hpp
+++ b/src/vu8/detail/ProtoHelper.hpp
@@ -1,17 +1,17 @@
 #ifndef BOOST_PP_IS_ITERATING
-#  ifndef TSA_VU8_DETAIL_PROTO_HELPER_HPP
-#  define TSA_VU8_DETAIL_PROTO_HELPER_HPP
-#    include <vu8/config.hpp>
-
-#    include <boost/preprocessor/repetition.hpp>
-#    include <boost/preprocessor/punctuation/comma_if.hpp>
-#    include <boost/preprocessor/iteration/iterate.hpp>
-#    include <boost/mpl/vector.hpp>
-#    include <boost/type_traits/integral_constant.hpp>
-
-#    ifndef VU8_PROTO_MAX_SIZE
-#      define VU8_PROTO_MAX_SIZE VU8_PP_ITERATION_LIMIT
-#    endif
+#   ifndef TSA_VU8_DETAIL_PROTO_HELPER_HPP
+#   define TSA_VU8_DETAIL_PROTO_HELPER_HPP
+#       include <vu8/config.hpp>
+
+#       include <boost/preprocessor/repetition.hpp>
+#       include <boost/preprocessor/punctuation/comma_if.hpp>
+#       include <boost/preprocessor/iteration/iterate.hpp>
+#       include <boost/mpl/vector.hpp>
+#       include <boost/type_traits/integral_constant.hpp>
+
+#       ifndef VU8_PROTO_MAX_SIZE
+#         define VU8_PROTO_MAX_SIZE VU8_PP_ITERATION_LIMIT
+#       endif
 namespace vu8 {
 
 template <class T, class F> struct Class;
@@ -23,7 +23,7 @@ namespace mpl = boost::mpl;
 
 template <class R>
 struct FunProtoBase {
-  typedef R return_type;
+    typedef R return_type;
 };
 
 template <class T>
@@ -33,55 +33,55 @@ template <class C, class T>
 struct MemFunProto;
 
 } }
-#    define BOOST_PP_ITERATION_LIMITS (0, VU8_PROTO_MAX_SIZE - 1)
-#    define BOOST_PP_FILENAME_1       "vu8/detail/ProtoHelper.hpp"
-#    include BOOST_PP_ITERATE()
-#  endif // include guard
+#       define BOOST_PP_ITERATION_LIMITS (0, VU8_PROTO_MAX_SIZE - 1)
+#       define BOOST_PP_FILENAME_1       "vu8/detail/ProtoHelper.hpp"
+#       include BOOST_PP_ITERATE()
+#    endif // include guard
 #else // BOOST_PP_IS_ITERATING
 
-#  define n BOOST_PP_ITERATION()
-#  define VU8_PROTO_print(z, n, data) data
+#   define n BOOST_PP_ITERATION()
+#   define VU8_PROTO_print(z, n, data) data
 
 namespace vu8 { namespace detail {
 
 template <class R BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A)>
 struct FunProto<R ( BOOST_PP_ENUM_PARAMS(n, A) )> : FunProtoBase<R> {
-  typedef mpl::vector<BOOST_PP_ENUM_PARAMS(n, A)>   arguments;
-  typedef R(*function_type)(BOOST_PP_ENUM_PARAMS(n, A));
+    typedef mpl::vector<BOOST_PP_ENUM_PARAMS(n, A)>   arguments;
+    typedef R(*function_type)(BOOST_PP_ENUM_PARAMS(n, A));
 };
 
 template <class C, class R BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A)>
 struct MemFunProto<C, R ( BOOST_PP_ENUM_PARAMS(n, A) )> : FunProtoBase<R> {
-  typedef mpl::vector<BOOST_PP_ENUM_PARAMS(n, A)>   arguments;
-  typedef R(C::*method_type)(BOOST_PP_ENUM_PARAMS(n, A));
-  typedef boost::false_type IS_RETURN_WRAPPED_CLASS;
+    typedef mpl::vector<BOOST_PP_ENUM_PARAMS(n, A)>   arguments;
+    typedef R(C::*method_type)(BOOST_PP_ENUM_PARAMS(n, A));
+    typedef boost::false_type IS_RETURN_WRAPPED_CLASS;
 };
 
 template <class C, class R, class Factory BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A)>
 struct MemFunProto<C, vu8::Class<R, Factory> ( BOOST_PP_ENUM_PARAMS(n, A) )> : FunProtoBase<R> {
-  typedef mpl::vector<BOOST_PP_ENUM_PARAMS(n, A)>   arguments;
-  typedef R(C::*method_type)(BOOST_PP_ENUM_PARAMS(n, A));
-  typedef boost::true_type IS_RETURN_WRAPPED_CLASS;
-  typedef vu8::ClassSingleton<R, Factory> ClassSingleton;
+    typedef mpl::vector<BOOST_PP_ENUM_PARAMS(n, A)>   arguments;
+    typedef R(C::*method_type)(BOOST_PP_ENUM_PARAMS(n, A));
+    typedef boost::true_type IS_RETURN_WRAPPED_CLASS;
+    typedef vu8::ClassSingleton<R, Factory> ClassSingleton;
 };
 
 template <class C, class R BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A)>
 struct MemFunProto<C const, R ( BOOST_PP_ENUM_PARAMS(n, A) )> : FunProtoBase<R> {
-  typedef mpl::vector<BOOST_PP_ENUM_PARAMS(n, A)>   arguments;
-  typedef R(C::*method_type)(BOOST_PP_ENUM_PARAMS(n, A)) const;
-  typedef boost::false_type IS_RETURN_WRAPPED_CLASS;
+    typedef mpl::vector<BOOST_PP_ENUM_PARAMS(n, A)>   arguments;
+    typedef R(C::*method_type)(BOOST_PP_ENUM_PARAMS(n, A)) const;
+    typedef boost::false_type IS_RETURN_WRAPPED_CLASS;
 };
 
 template <class C, class R, class Factory BOOST_PP_COMMA_IF(n) BOOST_PP_ENUM_PARAMS(n, class A)>
 struct MemFunProto<C const, vu8::Class<R, Factory> ( BOOST_PP_ENUM_PARAMS(n, A) )> : FunProtoBase<R> {
-  typedef mpl::vector<BOOST_PP_ENUM_PARAMS(n, A)>   arguments;
-  typedef R(C::*method_type)(BOOST_PP_ENUM_PARAMS(n, A)) const;
-  typedef boost::true_type IS_RETURN_WRAPPED_CLASS;
-  typedef vu8::ClassSingleton<R, Factory> ClassSingleton;
+    typedef mpl::vector<BOOST_PP_ENUM_PARAMS(n, A)>   arguments;
+    typedef R(C::*method_type)(BOOST_PP_ENUM_PARAMS(n, A)) const;
+    typedef boost::true_type IS_RETURN_WRAPPED_CLASS;
+    typedef vu8::ClassSingleton<R, Factory> ClassSingleton;
 };
 
 } }
 
-#  undef n
+#   undef n
 
 #endif