[cpp] Add Map specializations for Int64 and Pointer values. Closes #4130

std/cpp/_std/haxe/ds/IntMap.hx

@@ -35,6 +35,11 @@ package haxe.ds;
   inline void set(int key, double value) { __int_hash_set_float(h,key,value); }
   inline void set(int key, ::String value) { __int_hash_set_string(h,key,value); }
 
+  template<typename V, typename H>
+  inline void set(int key, const ::cpp::Struct<V,H> &value) {__int_hash_set(h,key,value); }
+  template<typename V>
+  inline void set(int key, const ::cpp::Pointer<V> &value) {__int_hash_set(h,key,(Dynamic)value ); }
+
   template<typename VALUE>
   inline Void set(Dynamic &key, const VALUE &value) { set( (int)key, value ); return null(); }
 ")

std/cpp/_std/haxe/ds/ObjectMap.hx

@@ -34,6 +34,13 @@ package haxe.ds;
   inline void set(Dynamic key, float value) { __object_hash_set_float(h,key,value); }
   inline void set(Dynamic key, double value) { __object_hash_set_float(h,key,value); }
   inline void set(Dynamic key, ::String value) { __object_hash_set_string(h,key,value); }
+
+
+  template<typename V, typename H>
+  inline void set(Dynamic key, const ::cpp::Struct<V,H> &value) {__object_hash_set(h,key,value); }
+  template<typename V>
+  inline void set(Dynamic key, const ::cpp::Pointer<V> &value) {__object_hash_set(h,key,(Dynamic)value ); }
+
 ")
 @:coreApi
 class ObjectMap<K:{},V> implements haxe.Constraints.IMap<K,V> {

std/cpp/_std/haxe/ds/StringMap.hx

@@ -35,6 +35,11 @@ package haxe.ds;
   inline void set(String key, double value) { __string_hash_set_float(h,key,value); }
   inline void set(String key, ::String value) { __string_hash_set_string(h,key,value); }
 
+  template<typename V, typename H>
+  inline void set(String key, const ::cpp::Struct<V,H> &value) {__string_hash_set(h,key,value); }
+  template<typename V>
+  inline void set(String key, const ::cpp::Pointer<V> &value) {__string_hash_set(h,key,(Dynamic)value ); }
+
   template<typename VALUE>
   inline Void set(Dynamic &key, const VALUE &value) { set( (String)key, value ); return null(); }
 ")

std/cpp/_std/haxe/ds/WeakMap.hx

@@ -34,6 +34,11 @@ package haxe.ds;
   inline void set(Dynamic key, float value) { __object_hash_set_float(h,key,value,true); }
   inline void set(Dynamic key, double value) { __object_hash_set_float(h,key,value,true); }
   inline void set(Dynamic key, ::String value) { __object_hash_set_string(h,key,value,true); }
+
+  template<typename V, typename H>
+  inline void set(Dynamic key, const ::cpp::Struct<V,H> &value) {__object_hash_set(h,key,value,true); }
+  template<typename V>
+  inline void set(Dynamic key, const ::cpp::Pointer<V> &value) {__object_hash_set(h,key,(Dynamic)value,true ); }
 ")
 @:coreApi
 class WeakMap<K:{},V> implements haxe.Constraints.IMap<K,V> {

tests/unit/src/unit/issues/Issue4130.hx

@@ -0,0 +1,71 @@
+package unit.issues;
+
+import haxe.Int64;
+
+private class TestKey
+{
+   public function new() { }
+}
+
+class Issue4130 extends Test
+{
+   #if cpp
+	public function test()
+	{
+        var a = [1];
+
+        var val64 = Int64.make(42,24);
+        var valPtr = cpp.Pointer.arrayElem(a,0);
+
+        var int2Int64 = new haxe.ds.IntMap<Int64>();
+        int2Int64.set( 42, val64);
+        var key:Dynamic = 43;
+        int2Int64.set( key, val64);
+        eq(int2Int64.get(42),val64);
+        eq(int2Int64.get(43),val64);
+
+
+        var int2Ptr = new haxe.ds.IntMap< cpp.Pointer<Int> >();
+        int2Ptr.set( 42, valPtr );
+        int2Ptr.set( key, valPtr );
+        eq( int2Ptr.get(42), valPtr);
+        eq( int2Ptr.get(key), valPtr);
+
+
+        var string2Int64 = new haxe.ds.StringMap<Int64>();
+        string2Int64.set( "42", val64 );
+        var key:Dynamic = "43";
+        string2Int64.set( "43", val64 );
+        eq( string2Int64.get("42"), val64 );
+        eq( string2Int64.get(key), val64 );
+
+        var string2Ptr = new haxe.ds.StringMap< cpp.Pointer<Int> >();
+        string2Ptr.set( "42", valPtr );
+        string2Ptr.set( key, valPtr );
+        eq( string2Ptr.get("42"), valPtr );
+        eq( string2Ptr.get(key), valPtr );
+
+
+        var key = new TestKey();
+        var obj2Int64 = new haxe.ds.ObjectMap<TestKey,Int64>();
+        obj2Int64.set( key, val64);
+        eq( obj2Int64.get(key), val64 );
+
+        var obj2Ptr = new haxe.ds.ObjectMap<TestKey, cpp.Pointer<Int> >();
+        obj2Ptr.set( key, valPtr );
+        eq( obj2Ptr.get(key), valPtr );
+
+
+        var weak2Int64 = new haxe.ds.WeakMap<TestKey,Int64>();
+        weak2Int64.set( key, val64);
+        eq( weak2Int64.get(key),val64 );
+
+        var weak2Ptr = new haxe.ds.WeakMap<TestKey, cpp.Pointer<Int> >();
+        weak2Ptr.set( key, valPtr );
+        eq( weak2Ptr.get(key), valPtr );
+
+	}
+   #end
+}
+
+