feat(generator): add converter for class wrapper

Author: engsr6982

generator/binder/templates/class_wrapper.h.j2

@@ -18,6 +18,15 @@ public:
     : ScriptClass(ScriptClass::ConstructFromCpp<{{get_wrapper_class_name(class_info)}}>{}),
       mResourceHolder(std::move(res)) {}
 
+    explicit {{get_wrapper_class_name(class_info)}}(Local<Object> const& thiz, {{class_full_name}}* res)
+    : ScriptClass(thiz), mResourceHolder(res) {}
+
+    explicit {{get_wrapper_class_name(class_info)}}(Local<Object> const& thiz, std::shared_ptr<{{class_full_name}}> res)
+    : ScriptClass(thiz), mResourceHolder(std::move(res)) {}
+
+    explicit {{get_wrapper_class_name(class_info)}}(Local<Object> const& thiz, std::unique_ptr<{{class_full_name}}> res)
+    : ScriptClass(thiz), mResourceHolder(std::move(res)) {}
+
     [[nodiscard]] static Local<Object> newInstance({{class_full_name}}* res) { return (new {{get_wrapper_class_name(class_info)}}(res))->getScriptObject(); }
     [[nodiscard]] static Local<Object> newInstance(std::shared_ptr<{{class_full_name}}> res) { return (new {{get_wrapper_class_name(class_info)}}(std::move(res)))->getScriptObject(); }
     [[nodiscard]] static Local<Object> newInstance(std::unique_ptr<{{class_full_name}}> res) { return (new {{get_wrapper_class_name(class_info)}}(std::move(res)))->getScriptObject(); }
@@ -33,3 +42,6 @@ public:
 public:
     static ClassDefine<{{get_wrapper_class_name(class_info)}}> builder;
 };
+
+// implementation Converter
+ImplConverter({{class_full_name}}, {{get_wrapper_class_name(class_info)}});

src/converter/Convert.h

@@ -3,7 +3,7 @@
 
 #include "detail/StlConverter.hpp"
 
-// #include "ProjectConverters.hpp" // circular reference, please include manually
+#include "ConverterTemplate.hpp" // circular reference, please include manually
 
 
 namespace jse {

src/converter/ConverterTemplate.hpp

@@ -0,0 +1,33 @@
+#pragma once
+#include "detail/Converter.hpp"
+
+
+#define ImplConverter(NATIVE_TYPE, WRAPPER_TYPE)                                                                       \
+    namespace detail {                                                                                                 \
+    template <>                                                                                                        \
+    struct Converter<NATIVE_TYPE> {                                                                                    \
+        static Local<Value> toScript(NATIVE_TYPE* res) { return WRAPPER_TYPE::newInstance(res); }                      \
+        static Local<Value> toScript(std::shared_ptr<NATIVE_TYPE> res) {                                               \
+            return WRAPPER_TYPE::newInstance(std::move(res));                                                          \
+        }                                                                                                              \
+        static Local<Value> toScript(std::unique_ptr<NATIVE_TYPE> res) {                                               \
+            return WRAPPER_TYPE::newInstance(std::move(res));                                                          \
+        }                                                                                                              \
+        static NATIVE_TYPE* toCpp(Local<Value> const& val) {                                                           \
+            if (EngineScope::currentEngine()->isInstanceOf<WRAPPER_TYPE>(val)) {                                       \
+                return EngineScope ::currentEngine()->getNativeInstance<WRAPPER_TYPE>(val)->get();                     \
+            }                                                                                                          \
+            throw script::Exception("Failed to convert value to " #NATIVE_TYPE);                                       \
+        }                                                                                                              \
+    };                                                                                                                 \
+    template <>                                                                                                        \
+    struct Converter<WRAPPER_TYPE> {                                                                                   \
+        static Local<Value>  toScript(WRAPPER_TYPE* res) { return res->getScriptObject(); }                            \
+        static WRAPPER_TYPE* toCpp(Local<Value> const& val) {                                                          \
+            if (EngineScope::currentEngine()->isInstanceOf<WRAPPER_TYPE>(val)) {                                       \
+                return EngineScope ::currentEngine()->getNativeInstance<WRAPPER_TYPE>(val);                            \
+            }                                                                                                          \
+            throw script::Exception("Failed to convert value to " #WRAPPER_TYPE);                                      \
+        }                                                                                                              \
+    };                                                                                                                 \
+    }