Marshalling Types

include/cpp/Pointer.h

@@ -131,12 +131,15 @@ class Struct
    // This allows 'StaticCast' to be used from arrays
    typedef Dynamic Ptr;
 
-   inline Struct( ) {  }
+   inline Struct( ) : value() {  }
    inline Struct( const T &inRHS ) : value(inRHS) {  }
    inline Struct( const null &) { value = T(); }
    inline Struct( const Reference<T> &);
    inline Struct( const Dynamic &inRHS) { fromDynamic(inRHS.mPtr); }
 
+   template<class... TArgs>
+   Struct(TArgs... args) : value(std::forward<TArgs>(args)...) {}
+
    inline Struct<T,HANDLER> &operator=( const T &inRHS ) { value = inRHS; return *this; }
    inline Struct<T,HANDLER> &operator=( const null & ) { value = T(); return *this; }
    inline Struct<T,HANDLER> &operator=( const Dynamic &inRHS ) { return *this = Struct<T,HANDLER>(inRHS); }
@@ -509,6 +512,8 @@ class Pointer_obj
    }
 
 
+    template<typename T>
+    inline static Pointer<T> addressOf(const ::cpp::marshal::ValueReference<T>&);
 
    template<typename T>
 	inline static Pointer<T> addressOf(T &value)  { return Pointer<T>(&value); }

include/hx/LessThanEq.h

@@ -246,6 +246,33 @@ struct CompareTraits< T * >
    inline static bool isNull(T *inValue) { return !inValue; }
 };
 
+template <typename T>
+struct CompareTraits< cpp::marshal::ValueReference<T> >
+{
+    enum { type = (int)CompareAsDynamic };
+
+    inline static int toInt(Dynamic inValue) { return inValue; }
+    inline static double toDouble(Dynamic inValue) { return inValue; }
+    inline static cpp::Int64 toInt64(Dynamic inValue) { return inValue; }
+    inline static String toString(Dynamic inValue) { return inValue; }
+    inline static hx::Object* toObject(Dynamic inValue) { return inValue.mPtr; }
+    inline static int getDynamicCompareType(const ::Dynamic&) { return type; }
+    inline static bool isNull(const ::cpp::marshal::ValueReference<T>& ref) { return nullptr == ref.ptr; }
+};
+
+template <typename T>
+struct CompareTraits< cpp::marshal::PointerReference<T> >
+{
+    enum { type = (int)CompareAsDynamic };
+
+    inline static int toInt(Dynamic inValue) { return inValue; }
+    inline static double toDouble(Dynamic inValue) { return inValue; }
+    inline static cpp::Int64 toInt64(Dynamic inValue) { return inValue; }
+    inline static String toString(Dynamic inValue) { return inValue; }
+    inline static hx::Object* toObject(Dynamic inValue) { return inValue.mPtr; }
+    inline static int getDynamicCompareType(const ::Dynamic&) { return type; }
+    inline static bool isNull(const ::cpp::marshal::PointerReference<T>& ref) { return nullptr == ref.ptr || nullptr == *ref.ptr; }
+};
 
 template<typename T1>
 hx::Object *GetExistingObject(const T1 &v1)
@@ -410,9 +437,37 @@ inline bool TestLessEq(const T1 &v1, const T2 &v2)
 template<typename T1, typename T2>
 bool IsEq(const T1 &v1, const T2 &v2) { return TestLessEq<false,true,T1,T2>(v1,v2); }
 
+template<typename T1, typename T2>
+bool IsEq(const ::cpp::marshal::ValueReference<T1>& v1, const ::cpp::marshal::ValueReference<T2>& v2) { return v1 == v2; }
+
+template<typename T1, typename T2>
+bool IsEq(const ::cpp::marshal::PointerReference<T1>& v1, const ::cpp::marshal::PointerReference<T2>& v2)
+{
+    if (nullptr == v1.ptr && nullptr == v2.ptr)
+    {
+        return true;
+    }
+    if (nullptr == v1.ptr && nullptr != v2.ptr)
+    {
+        return nullptr == *v2.ptr;
+    }
+    if (nullptr == v2.ptr && nullptr != v1.ptr)
+    {
+        return nullptr == *v1.ptr;
+    }
+
+    return *v1.ptr == *v2.ptr;
+}
+
 template<typename T1, typename T2>
 bool IsNotEq(const T1 &v1, const T2 &v2) { return TestLessEq<false,false,T1,T2>(v1,v2); }
 
+template<typename T1, typename T2>
+bool IsNotEq(const ::cpp::marshal::ValueReference<T1>& v1, const ::cpp::marshal::ValueReference<T2>& v2) { return v1 != v2; }
+
+template<typename T1, typename T2>
+bool IsNotEq(const ::cpp::marshal::PointerReference<T1>& v1, const ::cpp::marshal::PointerReference<T2>& v2) { return IsEq(v1, v2) == false; }
+
 template<typename T1, typename T2>
 bool IsLess(const T1 &v1, const T2 &v2) { return TestLessEq<true,false,T1,T2>(v1,v2); }
 

include/hxcpp.h

@@ -259,6 +259,12 @@ namespace hx { template<typename O> class ObjectPtr; }
 namespace cpp { template<typename S,typename H> class Struct; }
 namespace cpp { template<typename T> class Pointer; }
 namespace cpp { template<typename T> class Function; }
+namespace cpp { namespace marshal { template<class T> class Boxed_obj; } }
+namespace cpp { namespace marshal { template<class T> using Boxed =::hx::ObjectPtr<Boxed_obj<T>>; } }
+namespace cpp { namespace marshal { template<class T> class ValueType; } }
+namespace cpp { namespace marshal { template<class T> class ValueReference; } }
+namespace cpp { namespace marshal { template<class T> class PointerType; } }
+namespace cpp { namespace marshal { template<class T> class PointerReference; } }
 template<typename ELEM_> class Array_obj;
 template<typename ELEM_> class Array;
 namespace hx {
@@ -348,6 +354,7 @@ typedef PropertyAccessMode PropertyAccess;
 #endif
 #include <hx/StdLibs.h>
 #include <cpp/Pointer.h>
+#include <cpp/Marshal.h>
 #include <hx/Native.h>
 #include <hx/Operators.h>
 #include <hx/Functions.h>

test/RunTests.hx

@@ -56,6 +56,13 @@ class RunTests
 
    }
 
+   public static function marshalling()
+   {
+      setDir("marshalling");
+
+      command("haxe", [ "build.hxml" ]);
+      command("bin" + sep + "Main-debug", []);
+   }
 
    public static function debugger()
    {
@@ -188,6 +195,9 @@ class RunTests
       //run("opMatrix", opMatrix);
       run("haxe", runHaxe);
       run("telemetry", runTelemetry);
+#if (haxe_ver >= 5)
+      run("marshalling", marshalling);
+#end
       run("std32", std32);
       run("std64", std64);
       run("native", native);

test/native/Native.hx

@@ -1,5 +1,8 @@
 package;
 
+#if (haxe_ver>=5)
+@:buildXml("<include name='${this_dir}/../tests/marshalling/Build.xml'/>")
+#end
 class Native
 {
 	static function main()
@@ -12,7 +15,34 @@ class Native
 			new tests.TestNativeGen(),
 			new tests.TestNonVirtual(),
 			new tests.TestPtr(),
-			new tests.TestNativeEnum()
+			new tests.TestNativeEnum(),
+
+			#if (haxe_ver>=5)
+            new tests.marshalling.classes.TestLocalValueType(),
+            new tests.marshalling.classes.TestClassValueType(),
+            new tests.marshalling.classes.TestInterfaceValueType(),
+            new tests.marshalling.classes.TestEnumValueType(),
+            new tests.marshalling.classes.TestAbstractValueType(),
+            new tests.marshalling.classes.TestValueTypeInterop(),
+            new tests.marshalling.classes.TestValueTypeCollections(),
+            new tests.marshalling.classes.TestValueTypeFields(),
+            new tests.marshalling.classes.TestInheritance(),
+            new tests.marshalling.enums.TestValueTypeEnumAbstract(),
+            new tests.marshalling.enums.TestValueTypeEnumClassAbstract(),
+            new tests.marshalling.pointers.TestLocalPointers(),
+            new tests.marshalling.pointers.TestClassPointers(),
+            new tests.marshalling.pointers.TestInterfacePointers(),
+            new tests.marshalling.pointers.TestInheritancePointers(),
+            new tests.marshalling.pointers.TestEnumPointers(),
+            new tests.marshalling.pointers.TestPointerFields(),
+            new tests.marshalling.pointers.TestPointerCollections(),
+            new tests.marshalling.pointers.TestAbstractPointer(),
+            new tests.marshalling.pointers.TestPointerInterop(),
+            new tests.marshalling.managed.TestLocalNonStandardManagedClass(),
+            new tests.marshalling.managed.TestLocalStandardManagedClass(),
+            new tests.marshalling.managed.TestClassNonStandardManagedClass(),
+            new tests.marshalling.managed.TestClassStandardManagedClass()
+			#end
 		]);
 	}
 }

test/native/compile.hxml

@@ -1,4 +1,4 @@
 -m Native
--D HXCPP_DEBUGGER
 -L utest
+-D HXCPP-DEBUGGER
 --cpp bin