Add optimized map access for cppia

src/generators/gencpp.ml

@@ -2246,6 +2246,16 @@ let is_map_get_call obj member =
    )
 ;;
 
+let is_map_set_call obj member =
+   member.cf_name="set" &&
+   (match obj.cpptype  with
+   | TCppInst({cl_path=(["haxe";"ds"],"IntMap")}) -> true
+   | TCppInst({cl_path=(["haxe";"ds"],"StringMap")}) -> true
+   | TCppInst({cl_path=(["haxe";"ds"],"ObjectMap")}) -> true
+   | _ -> false
+   )
+;;
+
 
 
 let is_array_concat_call obj member =
@@ -2689,13 +2699,13 @@ let retype_expression ctx request_type function_args function_type expression_tr
                   | _ -> abort "First parameter of template function must be a Class" retypedFunc.cpppos
                   )
 
-               | CppFunction( FuncInstance(obj, InstPtr, member), _ ) when not forCppia && is_map_get_call obj member ->
+               | CppFunction( FuncInstance(obj, InstPtr, member), _ ) when is_map_get_call obj member ->
                   let retypedArgs = List.map (retype TCppDynamic ) args in
                   let fname, cppType = match return_type with
-                  | TCppVoid | TCppScalar("bool")  -> "get_bool", return_type
-                  | TCppScalar("int")  -> "get_int", return_type
-                  | TCppScalar("Float")  -> "get_float", return_type
-                  | TCppString  -> "get_string", return_type
+                  | TCppVoid | TCppScalar("bool")  -> (if forCppia then "getBool" else "get_bool"), return_type
+                  | TCppScalar("int")  -> (if forCppia then "getInt" else "get_int"), return_type
+                  | TCppScalar("Float")  -> (if forCppia then "getFloat" else "get_float"), return_type
+                  | TCppString  -> (if forCppia then "getString" else "get_string"), return_type
                   | _ -> "get", TCppDynamic
                   in
                   let func = FuncInstance(obj, InstPtr, {member with cf_name=fname}) in
@@ -2708,6 +2718,19 @@ let retype_expression ctx request_type function_args function_type expression_tr
                      CppCall( func, retypedArgs), cppType
 
 
+               | CppFunction( FuncInstance(obj, InstPtr, member), _ ) when forCppia && is_map_set_call obj member ->
+                  let retypedArgs = List.map (retype TCppDynamic ) args in
+                  let fname = match retypedArgs with
+                  | [_;{cpptype=TCppScalar("bool")}]  -> "setBool"
+                  | [_;{cpptype=TCppScalar("int")}]  -> "setInt"
+                  | [_;{cpptype=TCppScalar("Float")}]  -> "setFloat"
+                  | [_;{cpptype=TCppString}]  -> "setString"
+                  | _ -> "set"
+                  in
+                  let func = FuncInstance(obj, InstPtr, {member with cf_name=fname}) in
+                  CppCall( func, retypedArgs), cppType
+
+
                | CppFunction( FuncInstance(obj,InstPtr,member) as func, returnType ) when cpp_can_static_cast returnType cppType ->
                   let retypedArgs = List.map (retype TCppDynamic ) args in
                   let call = mk_cppexpr (CppCall(func,retypedArgs)) returnType in

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

@@ -92,4 +92,16 @@ package haxe.ds;
 	public function toString() : String {
 		return untyped __global__.__int_hash_to_string(h);
 	}
+
+   #if (scriptable)
+   private function setString(key:Int,val:String) : Void { untyped __int_hash_set_string(h,key,val); }
+   private function setInt(key:Int,val:Int) : Void { untyped __int_hash_set_int(h,key,val); }
+   private function setBool(key:Int,val:Bool) : Void { untyped __int_hash_set_int(h,key,val); }
+   private function setFloat(key:Int,val:Float) : Void { untyped __int_hash_set_float(h,key,val); }
+
+   private function getString(key:Int) : String { return untyped __int_hash_get_string(h,key); }
+   private function getInt(key:Int) : Int { return untyped __int_hash_get_int(h,key); }
+   private function getBool(key:Int) : Bool { return untyped __int_hash_get_bool(h,key); }
+   private function getFloat(key:Int) : Float { return untyped __int_hash_get_float(h,key); }
+   #end
 }

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

@@ -91,4 +91,16 @@ class ObjectMap<K:{},V> implements haxe.Constraints.IMap<K,V> {
 	public function toString() : String {
 		return untyped __global__.__object_hash_to_string(h);
 	}
+
+   #if (scriptable)
+   private function setString(key:Dynamic,val:String) : Void { untyped __object_hash_set_string(h,key,val); }
+   private function setInt(key:Dynamic,val:Int) : Void { untyped __object_hash_set_int(h,key,val); }
+   private function setBool(key:Dynamic,val:Bool) : Void { untyped __object_hash_set_int(h,key,val); }
+   private function setFloat(key:Dynamic,val:Float) : Void { untyped __object_hash_set_float(h,key,val); }
+
+   private function getString(key:Dynamic) : String { return untyped __object_hash_get_string(h,key); }
+   private function getInt(key:Dynamic) : Int { return untyped __object_hash_get_int(h,key); }
+   private function getBool(key:Dynamic) : Bool { return untyped __object_hash_get_bool(h,key); }
+   private function getFloat(key:Dynamic) : Float { return untyped __object_hash_get_float(h,key); }
+   #end
 }

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

@@ -91,4 +91,16 @@ package haxe.ds;
 	public function toString() : String {
 		return untyped __global__.__string_hash_to_string(h);
 	}
+
+   #if (scriptable)
+   private function setString(key:String,val:String) : Void { untyped __string_hash_set_string(h,key,val); }
+   private function setInt(key:String,val:Int) : Void { untyped __string_hash_set_int(h,key,val); }
+   private function setBool(key:String,val:Bool) : Void { untyped __string_hash_set_int(h,key,val); }
+   private function setFloat(key:String,val:Float) : Void { untyped __string_hash_set_float(h,key,val); }
+
+   private function getString(key:String) : String { return untyped __string_hash_get_string(h,key); }
+   private function getInt(key:String) : Int { return untyped __string_hash_get_int(h,key); }
+   private function getBool(key:String) : Bool { return untyped __string_hash_get_bool(h,key); }
+   private function getFloat(key:String) : Float { return untyped __string_hash_get_float(h,key); }
+   #end
 }