Haxe - Die richtige Methode zum Implementieren von Map mit Int64-Schlüsseln, die serialisiert werden können (natives Ziel)

Question

Ich muss wissen, was wäre der richtige Weg, um Maps mit 64-Bit-Schlüsseln zu implementieren. Es wird nicht so viele Elemente in ihnen geben, ich brauche nur verschiedene Bits des Schlüssels für verschiedene Dinge mit ausreichend großen Adressraum und ich brauche es sehr schnell, so String Schlüssel wäre wahrscheinlich zu langsam. Bisher habe ich versucht:

import haxe.Int64; 
import haxe.Unserializer; 
import haxe.Serializer; 

class Test { 
    static function main() { 

     var key:Int64 = 1 << 63 | 0x00000001; 

     var omap:Map<Int64, String> = new Map<Int64, String>(); 
     omap.set(key, "test"); 

     var smap:Map<Int64, String> = Unserializer.run(Serializer.run(omap)); 

     var key2:Int64 = 1 << 63 | 0x00000001; 
     trace(key+" "+smap.get(key2)); 
    } 
} 

http://try.haxe.org/#7CDb2

die offensichtlich nicht funktioniert, weil haxe.Int64 eine Objektinstanz erstellt. Die Verwendung von cpp.Int64 funktioniert, weil es aus irgendeinem Grund in meinem cpp-Code auf 32-Bit-Ganzzahl zurückfällt und ich weiß nicht, was ich falsch mache. Wie kann ich es zwingen, 64 Bit zu "bleiben", oder sollte ich es anders machen?

Answer 1

EDIT: Dies ist derzeit nicht wegen Fehler/aktuelle Implementierung in hxcpp auf nativen Ziele arbeiten: https://github.com/HaxeFoundation/hxcpp/issues/523

ich diese Abhilfe/Wrapper herausgefunden, was die effizienteste Lösung nicht möglich sein kann, aber es scheint Arbeit.

import haxe.Int64; 
import haxe.Unserializer; 
import haxe.Serializer; 

class Test { 
    static function main() { 

     var key:Int64 = Int64.make(1000,1); 

     var omap:Int64Map<String> = new Int64Map(); 
     omap.set(key, "test"); 

     var smap:Int64Map<String> = Unserializer.run(Serializer.run(omap)); 

     var key2:Int64 = Int64.make(1000,1); 
     trace(key+" "+smap.get(key2)); 
    } 
} 

class Int64Map<V> { 

    private var map:Map<Int64,V>; 

    public function new() : Void { 
     this.map = new Map<Int64,V>(); 
    } 

    public function set(key:Int64, value:V):Void { 
     this.map.set(key, value); 
    } 

    public inline function get(key:Int64):Null<V> { 
     var skey:Null<Int64> = getMapKey(key); 
     if (skey != null) return this.map.get(skey); 
     return null; 
    } 

    public inline function exists(key:Int64):Bool { 
     return (getMapKey(key) != null); 
    } 

    public function remove(key : Int64) : Bool { 
     var skey:Null<Int64> = getMapKey(key); 
     if (skey != null) return this.map.remove(skey); 
     return false; 
    } 

    public function keys() : Iterator<Int64> { 
     return this.map.keys(); 
    } 

    public function toString() : String { 
     return this.map.toString(); 
    } 

    public function iterator() : Iterator<V> { 
     return this.map.iterator(); 
    } 



    private function getMapKey(key:Int64):Null<Int64> { 
     for (ikey in this.map.keys()){ 
      if (Int64.eq(key, ikey)){ 
       return ikey; 
      } 
     } 
     return null; 
    } 

} 

http://try.haxe.org/#57686