Marshalling Types (#1189)

* Add marshal header for value type interop

* finalise boxed objects if the type has a destructor

* works with static cast

* add value type tests

* move more conversion functions to reference class

* forward declare everything to avoid order issues

* ValueType construction from boxed pointer

* ValueType no longer inherits from struct

* marshal reference interop with existing pointer types

* Fix trying to dereference a null pointer when creating a boxed object from a reference

* add compare traits specialisation for reference null check

* consistent null checking and throwing

* raise exceptions when value types are assigned null

* reference equality operations

* remove no return

* remove some un-needed constructors

* Make constructors use more templates and use reinterpret cast

* use tagged dispatch

* support pointer types being held in value type helper

* Add new marshal pointer type

* rename marshal types in prep for more pointer stuff

* support reinterpreting value type references

* seemingly working pointer marshalling types

* better null checking with pointer references

* add marshalling tests

* Add pointer collection tests

* Move enums into header files

* test abstract around pointers

* Pointer type changes

* add pointer reference to pointer casting

* add null test to pointer access

* add test for vector of value types

* add tests showing weird null behaviour

* move marshalling tests to existing native tests

* initial managed extern tests

* managed extern local tests for two different naming schemes

* reduce test duplication

* Add tests for classes holding managed externs

* change tests so that static functions are tested

* un-private point

* let enum abstract include meta handle it

* remove analyser meta

* Fix test related to recent pointer changes

* Add pointer ctor overload

* view marshalling type

* Change to value semantics

* Add view tests

* Update some tests

* String marshalling functions

* Marshalling tests

* view based string creation and support char16_t in various hxcpp types

* Marshalling string tests

* const ref a bit

* Don't use byte size in copyTo comparison check

* view extension tests

* Split across multiple headers

* typed read and write helper functions

* Add compare function

* cstring to view conversion function, and allow null pointers

* Add view to pointer conversions

* View length is now size_t

* Add endian specific read and write marshal functions

* Add OOB checks

* change the public api to use int64_t over size_t

* Fix string from view conversions to properly use the view length

* Add OOB exception tests

* bound check read and write

* make sure view write index is int64_t

* add tests for exceptions when reading or writing to small views

* guard including new marshal headers

* fix dodgy conditional

---------

Co-authored-by: Aidan Lee <aidan.lee@evcam.com>

Author: Aidan63

include/Array.h

@@ -39,6 +39,7 @@ template<> struct ReturnNull<double> { typedef Dynamic type; };
 template<> struct ReturnNull<float> { typedef Dynamic type; };
 template<> struct ReturnNull<bool> { typedef Dynamic type; };
 template<> struct ReturnNull<char> { typedef Dynamic type; };
+template<> struct ReturnNull<char16_t> { typedef Dynamic type; };
 template<> struct ReturnNull<signed char> { typedef Dynamic type; };
 template<> struct ReturnNull<unsigned char> { typedef Dynamic type; };
 template<> struct ReturnNull<short> { typedef Dynamic type; };
@@ -431,6 +432,7 @@ template<> struct ArrayClassId<unsigned char> { enum { id=hx::clsIdArrayByte };
 template<> struct ArrayClassId<signed char> { enum { id=hx::clsIdArrayByte }; };
 template<> struct ArrayClassId<unsigned short> { enum { id=hx::clsIdArrayShort }; };
 template<> struct ArrayClassId<signed short> { enum { id=hx::clsIdArrayShort }; };
+template<> struct ArrayClassId<char16_t> { enum { id = hx::clsIdArrayShort }; };
 template<> struct ArrayClassId<unsigned int> { enum { id=hx::clsIdArrayInt }; };
 template<> struct ArrayClassId<signed int> { enum { id=hx::clsIdArrayInt }; };
 template<> struct ArrayClassId<float> { enum { id=hx::clsIdArrayFloat32 }; };

include/Dynamic.h

@@ -24,6 +24,7 @@ class HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic : public hx::ObjectPtr<hx::Object>
    Dynamic(unsigned short inVal);
    Dynamic(unsigned char inVal);
    Dynamic(signed char inVal);
+   Dynamic(char16_t inVal);
    Dynamic(const cpp::CppInt32__ &inVal);
    Dynamic(bool inVal);
    Dynamic(double inVal);
@@ -71,6 +72,7 @@ class HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic : public hx::ObjectPtr<hx::Object>
    inline operator unsigned char () const { return mPtr ? mPtr->__ToInt() : 0; }
    inline operator char () const { return mPtr ? mPtr->__ToInt() : 0; }
    inline operator signed char () const { return mPtr ? mPtr->__ToInt() : 0; }
+   inline operator char16_t () const { return mPtr ? mPtr->__ToInt() : 0; }
    inline operator bool() const { return mPtr && mPtr->__ToInt(); }
    inline operator cpp::Int64() const { return mPtr ? mPtr->__ToInt64() : 0; }
    inline operator cpp::UInt64() const { return mPtr ? mPtr->__ToInt64() : 0; }
@@ -171,6 +173,7 @@ class HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic : public hx::ObjectPtr<hx::Object>
       bool operator op (unsigned short inRHS)  const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
       bool operator op (signed char inRHS)  const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
       bool operator op (unsigned char inRHS)  const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
+      bool operator op (char16_t inRHS)  const { return IsNumeric() && ((double)(*this) op (double)inRHS); } \
       bool operator op (bool inRHS)  const { return IsBool() && ((double)(*this) op (double)inRHS); } \
 
    bool operator != (const String &inRHS)  const { return !mPtr || ((String)(*this) != inRHS); }
@@ -184,6 +187,7 @@ class HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic : public hx::ObjectPtr<hx::Object>
    bool operator != (unsigned short inRHS)  const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
    bool operator != (signed char inRHS)  const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
    bool operator != (unsigned char inRHS)  const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
+   bool operator != (char16_t inRHS)  const { return !IsNumeric() || ((double)(*this) != (double)inRHS); }
    bool operator != (bool inRHS)  const { return !IsBool() || ((double)(*this) != (double)inRHS); }
 
 
@@ -229,6 +233,7 @@ class HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic : public hx::ObjectPtr<hx::Object>
     Dynamic operator+(const unsigned short &i) const;
     Dynamic operator+(const signed char &i) const;
     Dynamic operator+(const unsigned char &i) const;
+    Dynamic operator+(const char16_t& i) const;
     Dynamic operator+(const double &d) const;
     Dynamic operator+(const float &d) const;
     Dynamic operator+(const cpp::Variant &d) const;
@@ -270,6 +275,8 @@ class HXCPP_EXTERN_CLASS_ATTRIBUTES Dynamic : public hx::ObjectPtr<hx::Object>
         { return mPtr->__GetType()==vtInt ?  Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
       Dynamic operator op (const unsigned char &inRHS) const \
         { return mPtr->__GetType()==vtInt ?  Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
+      Dynamic operator op (const char16_t &inRHS) const \
+        { return mPtr->__GetType()==vtInt ?  Dynamic((int)(*this) op inRHS) : Dynamic((double)(*this) op inRHS); } \
       Dynamic operator op (const cpp::Int64 &inRHS) const \
         { return Dynamic((double)(*this) op inRHS); } \
       Dynamic operator op (const cpp::UInt64 &inRHS) const \
@@ -457,6 +464,7 @@ COMPARE_DYNAMIC_OP( >  )
    inline double operator op (const unsigned short &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
    inline double operator op (const signed char &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
    inline double operator op (const unsigned char &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
+   inline double operator op (const char16_t &inLHS,const Dynamic &inRHS) { return inLHS op (double)inRHS; } \
 
 ARITH_DYNAMIC( - )
 ARITH_DYNAMIC( + )

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); }
@@ -212,6 +215,7 @@ class Pointer
       hx::Object *obj = inVariant.asObject();
       ptr = obj  ? (T*)inVariant.valObject->__GetHandle() : 0;
    }
+   inline Pointer(const ::cpp::marshal::PointerReference<T>);
 
    template<typename O>
    inline Pointer( const O *inValue ) : ptr( (T*) inValue) { }
@@ -509,6 +513,11 @@ class Pointer_obj
    }
 
 
+    template<typename T>
+    inline static Pointer<T> addressOf(const ::cpp::marshal::ValueReference<T>&);
+
+    template<typename T>
+    inline static Pointer<T*> addressOf(const ::cpp::marshal::PointerReference<T>&);
 
    template<typename T>
 	inline static Pointer<T> addressOf(T &value)  { return Pointer<T>(&value); }

include/cpp/Variant.h

@@ -109,6 +109,7 @@ namespace cpp
       inline operator unsigned char () const { return asInt(); }
       inline operator char () const { return asInt(); }
       inline operator signed char () const { return asInt(); }
+      inline operator char16_t() const { return asInt(); }
       inline operator cpp::Int64 () const { return asInt64(); }
       inline operator cpp::UInt64 () const { return asInt64(); }
       inline bool operator !() const { return !asInt(); }
@@ -206,6 +207,7 @@ namespace cpp
    inline bool operator op (unsigned short inRHS)  const { return isNumeric() && (asDouble() op (double)inRHS); } \
    inline bool operator op (signed char inRHS)  const { return isNumeric() && (asDouble() op (double)inRHS); } \
    inline bool operator op (unsigned char inRHS)  const { return isNumeric() && (asDouble() op (double)inRHS); } \
+   inline bool operator op (char16_t inRHS)  const { return isNumeric() && (asDouble() op (double)inRHS); } \
    inline bool operator op (bool inRHS)  const { return isBool() && (asDouble() op (double)inRHS); } \
    inline bool operator op (const Dynamic &inRHS)  const { return Compare(inRHS) op 0; } \
 
@@ -278,6 +280,7 @@ namespace cpp
    inline double operator op (const unsigned int &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
    inline double operator op (const signed char &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
    inline double operator op (const unsigned char &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
+   inline double operator op (const char16_t &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
    inline double operator op (const signed short &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
    inline double operator op (const unsigned short &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
    inline double operator op (const cpp::Int64 &inLHS,const cpp::Variant &inRHS) { return inLHS op (double)inRHS; } \
@@ -604,6 +607,7 @@ HX_VARIANT_OP_ISEQ(short)
 HX_VARIANT_OP_ISEQ(unsigned short)
 HX_VARIANT_OP_ISEQ(signed char)
 HX_VARIANT_OP_ISEQ(unsigned char)
+HX_VARIANT_OP_ISEQ(char16_t)
 HX_VARIANT_OP_ISEQ(bool)
 
 inline bool operator < (bool inLHS,const cpp::Variant &inRHS) { return false; }
@@ -633,6 +637,8 @@ inline bool operator > (bool inLHS,const cpp::Variant &inRHS) { return false; }
       { return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
    inline bool operator op (unsigned char inLHS,const ::cpp::Variant &inRHS) \
       { return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
+   inline bool operator op (char16_t inLHS,const ::cpp::Variant &inRHS) \
+      { return inRHS.isNumeric() && (inLHS op (double)inRHS); } \
    inline bool operator op (const null &,const ::cpp::Variant &inRHS) \
       { return false; } \
 

include/cpp/marshal/Boxed.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "Definitions.inc"
+
+template<class T>
+inline void cpp::marshal::Boxed_obj<T>::finalise(::hx::Object* obj)
+{
+    auto ptr = reinterpret_cast<Boxed_obj<T>*>(obj);
+
+    ptr->value.~T();
+}
+
+template<class T>
+inline void cpp::marshal::Boxed_obj<T>::setFinaliser(std::true_type)
+{
+    ::hx::GCSetFinalizer(this, finalise);
+}
+
+template<class T>
+inline void cpp::marshal::Boxed_obj<T>::setFinaliser(std::false_type) {}
+
+template<class T>
+inline cpp::marshal::Boxed_obj<T>::Boxed_obj() : value()
+{
+    setFinaliser(std::is_destructible<T>{});
+}
+
+template<class T>
+inline cpp::marshal::Boxed_obj<T>::Boxed_obj(T* ptr) : value(*ptr)
+{
+    setFinaliser(std::is_destructible<T>{});
+}
+
+template<class T>
+template<class ...TArgs>
+inline cpp::marshal::Boxed_obj<T>::Boxed_obj(TArgs... args) : value(std::forward<TArgs>(args)...)
+{
+    setFinaliser(std::is_destructible<T>{});
+}