1/* 2 * Copyright (c) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15declare function requireNapi(s: string): any; 16 17let flag = false; 18let fastHashMap = undefined; 19let arkPritvate = globalThis["ArkPrivate"] || undefined; 20if (arkPritvate !== undefined) { 21 fastHashMap = arkPritvate.Load(arkPritvate.HashMap); 22} else { 23 flag = true; 24} 25 26if (flag || fastHashMap === undefined) { 27 const HashMapAbility = requireNapi("util.struct"); 28 interface IterableIterator<T> { 29 next: () => { 30 value: T | undefined; 31 done: boolean; 32 }; 33 } 34 class HandlerHashMap<K, V> { 35 set(target: HashMap<K, V>, p: any, value: any): boolean { 36 if (p in target) { 37 target[p] = value; 38 return true; 39 } 40 return false; 41 } 42 defineProperty(target: HashMap<K, V>, p: any): boolean { 43 throw new Error("Can't define Property on HashMap Object"); 44 } 45 deleteProperty(target: HashMap<K, V>, p: any): boolean { 46 throw new Error("Can't delete Property on HashMap Object"); 47 } 48 setPrototypeOf(target: HashMap<K, V>, p: any): boolean { 49 throw new Error("Can't set Prototype on HashMap Object"); 50 } 51 } 52 class HashMap<K, V> extends HashMapAbility.DictionaryClass<K, V> { 53 constructor() { 54 super(); 55 return new Proxy(this, new HandlerHashMap()); 56 } 57 get length() { 58 return this.memberNumber; 59 } 60 isEmpty(): boolean { 61 return this.memberNumber === 0; 62 } 63 hasKey(key: K): boolean { 64 return super.hasKey(key); 65 } 66 hasValue(value: V): boolean { 67 return super.Values().indexOf(value) > -1; 68 } 69 get(key: K): V { 70 return this.getValueByKey(key); 71 } 72 setAll(map: HashMap<K, V>): void { 73 if(!(map instanceof HashMap)) { 74 throw new TypeError("Incoming object is not JSAPIHashMap"); 75 } 76 let memebers = map.keyValueArray; 77 for (let i = 0; i < memebers.length; i++) { 78 this.put(memebers[i].key, memebers[i].value); 79 } 80 } 81 set(key: K, value: V): Object { 82 return super.put(key, value); 83 } 84 remove(key: K): V { 85 let result = this.removeMember(key); 86 return result; 87 } 88 clear(): void { 89 super.clear(); 90 } 91 keys(): IterableIterator<K> { 92 let data = this; 93 let count = 0; 94 return { 95 next: function () { 96 let done = count >= data.memberNumber; 97 let value = !done ? data.keyValueArray[count].key : undefined; 98 count++; 99 return { 100 done: done, 101 value: value, 102 }; 103 }, 104 }; 105 } 106 values(): IterableIterator<V> { 107 let data = this; 108 let count = 0; 109 return { 110 next: function () { 111 let done = count >= data.memberNumber; 112 let value = !done ? data.keyValueArray[count].value : undefined; 113 count++; 114 return { 115 done: done, 116 value: value, 117 }; 118 }, 119 }; 120 } 121 replace(key: K, newValue: V): boolean { 122 return super.replaceMember(key, newValue); 123 } 124 forEach(callbackfn: (value?: V, key?: K, map?: HashMap<K, V>) => void, 125 thisArg?: Object): void { 126 let tagetArray = this.keyValueArray; 127 for (let i = 0; i < tagetArray.length; i++) { 128 callbackfn.call(thisArg, tagetArray[i].value, tagetArray[i].key, this); 129 } 130 } 131 entries(): IterableIterator<[K, V]> { 132 let data = this; 133 let count = 0; 134 return { 135 next: function () { 136 let done = count >= data.memberNumber; 137 let value = !done ? data.keyValueArray[count].entry() : undefined; 138 count++; 139 return { 140 done: done, 141 value: value, 142 }; 143 }, 144 }; 145 } 146 [Symbol.iterator](): IterableIterator<[K, V]> { 147 let data = this; 148 let count = 0; 149 return { 150 next: function () { 151 let done = count >= data.memberNumber; 152 let value = !done ? data.keyValueArray[count].entry() : undefined; 153 count++; 154 return { 155 done: done, 156 value: value, 157 }; 158 }, 159 }; 160 } 161 } 162 Object.freeze(HashMap); 163 fastHashMap = HashMap; 164} 165export default fastHashMap; 166