@cute-dw/core
Version:
This TypeScript library is the main part of a more powerfull package designed for the fast WEB software development. The cornerstone of the library is the **DataStore** class, which might be useful when you need a full control of the data, but do not need
275 lines • 30.2 kB
JavaScript
import { NullPointerException } from "../util/exception/NullPointerException";
import { IllegalArgumentException } from "../util/exception/IllegalArgumentException";
import { IllegalStateException } from "../util/exception/IllegalStateException";
import { Ciphers } from "../util/Ciphers";
import { ArrayList } from "./ArrayList";
const DEFAULT_HASH_SIZE = 32;
const MAX_LIST_SIZE = 8192; // 4096
const MAX_LOCATIONS = 5;
/**
* **Hash table** (hash map) is a data structure which implements an _associative array_ abstract data type, a structure that can _map keys
* to values_. A hash table uses a _hash function_ to compute an index into an array of buckets or slots,
* from which the desired value can be found
*/
export class HashTable {
constructor() {
this._hashSize = DEFAULT_HASH_SIZE;
this._buckets = new ArrayList();
this._keys = new Array();
this._initialize(this._hashSize);
}
_initialize(hashSize) {
this._buckets.clear();
for (let i = 0; i < hashSize; i++) {
this._buckets.add(new Array());
}
this._keys = [];
}
_resize() {
const oldDic = new ArrayList();
oldDic.appendAll(this._buckets);
this._initialize(Math.min(oldDic.size * 4, MAX_LIST_SIZE));
this._buckets.appendAll(oldDic);
}
/**
* @override
*/
clear() {
this._initialize(this._hashSize);
}
/**
* @override
*/
isEmpty() {
return this.size == 0;
}
/**
* @override
*/
get size() {
return this._keys.length;
}
/**
* Returns the value to which the `key` is mapped in this dictionary, or `undefined` if this map contains no mapping for the key
* @param key The key whose associated value is to be returned
* @returns The value to which the specified key is mapped, or `undefined` if this map contains no mapping for the key
*/
get(key) {
if (key == null) {
return undefined;
}
const aBucket = this._buckets.get(Ciphers.keyHash(String(key), this._buckets.size));
if (aBucket) {
for (let pair of aBucket) {
if (pair.key === key) {
return pair.value;
}
}
}
return undefined;
}
/**
* Returns the value to which the `key` is mapped in this dictionary, or `defaultValue` if this map contains no mapping for the key
* @param key The key whose associated value is to be returned
* @param defaultValue Default value that will be returned if there is no mapping for the `key`
* @returns The value to which the specified key is mapped, or `defaultValue` if this map contains no mapping for the key
*/
getOrDefault(key, defaultValue) {
return this.get(key) ?? defaultValue;
}
/**
* Tests if some key maps into the specified value in this hashtable
* @param key A key value
* @returns _true_ if the map contains the entry with the key `key`, or _false_ otherwise
* @see {@link contains}
* @see {@link containsKey}
*/
has(key) {
return this.containsKey(key);
}
/**
* Tests if some key maps into the specified value in this hashtable
* @param key A key value
* @returns _true_ if the map contains the entry with the key `key`, or _false_ otherwise
* @see {@link has}
* @see {@link containsKey}
*/
contains(key) {
return this.containsKey(key);
}
/**
* @override
* @see {@link has}
* @see {@link contains}
* @see {@link containsValue}
*/
containsKey(key) {
return (this._keys.indexOf(key) >= 0);
}
/**
* @override
* @see {@link containsKey}
*/
containsValue(value) {
for (let aBucket of this._buckets) {
for (let anEntry of aBucket) {
if (anEntry.value === value) {
return true;
}
}
}
return false;
}
/**
* Returns a `Set` view of the keys contained in this map
*/
keySet() {
let set = new Set();
this._keys.forEach(key => set.add(key));
return set;
}
/**
* Maps the specified key to the specified value in this hashtable
* @param key The hashtable key
* @param value The value
* @returns The previous value of the specified key in this hashtable, or `undefined` if it did not have one
* @throws `IllegalArgumentException` if the `key` or `value` is _null_ or _undefined_
* @see {@link set}
*/
put(key, value) {
if (key == null || value == null) {
throw new IllegalArgumentException();
}
const keyHash = Ciphers.keyHash(String(key), this._buckets.size);
const aBucket = this._buckets.get(keyHash);
if (!aBucket) {
throw new IllegalStateException();
}
let count = -1;
let index = -1;
for (let pair of aBucket) {
count++;
if (pair.key === key) {
index = count;
break;
}
}
let oldValue = undefined;
if (index == -1) {
const pair = { key, value };
index = aBucket.push(pair);
this._keys.push(key);
}
else {
oldValue = aBucket[index].value;
aBucket[index].value = value;
}
if (index > MAX_LOCATIONS && this._buckets.size < MAX_LIST_SIZE) {
// this bucket is big, grow dict
this._resize();
}
return oldValue;
}
/**
* Copies all the mappings from the specified source map to this map
* @param map Source `Map` object
* @throws `NullPointerException` if the `map` is a nullish value
* @see {@link put}
*/
putAll(map) {
if (map == null) {
throw new NullPointerException();
}
map.forEach((value, key) => this.put(key, value));
}
/**
* Removes the key (and its corresponding value) from this hashtable
* @param key The key that needs to be removed
* @returns _true_ if the entry with the key `key` was deleted, or _false_ otherwise
* @see {@link remove}
*/
delete(key) {
if (key == null)
return false;
const aBucket = this._buckets.get(Ciphers.keyHash(String(key), this._buckets.size));
if (aBucket) {
let index = -1;
let keysInd;
for (let pair of aBucket) {
index++;
if (pair.key === key) {
aBucket.splice(index, 1);
keysInd = this._keys.indexOf(key);
if (keysInd >= 0)
this._keys.splice(keysInd, 1);
return true;
}
}
}
return false;
}
/**
* Maps the specified key to the specified value in this hashtable and returns a reference to `this` value.
* If a `key` or a `value` equals to _null_ or _undefined_ value operation is ignored.
* @param key A key of the key/value pair
* @param value A value of the key/value pair
* @returns `this` value
* @see {@link put}
*/
set(key, value) {
if (!(key == null || value == null)) {
this.put(key, value);
}
return this;
}
/**
* Removes the key (and its corresponding value) from this hashtable
* @param key The key that needs to be removed
* @returns The value to which the key had been mapped in this hashtable, or `null` if the key did not have a mapping
* @throws `IllegalArgumentException` if the `key` is _null_ or _undefined_
*/
remove(key) {
if (key == null) {
throw new IllegalArgumentException();
}
const aBucket = this._buckets.get(Ciphers.keyHash(String(key), this._buckets.size));
if (aBucket) {
let index = -1;
let keysInd;
for (let pair of aBucket) {
index++;
if (pair.key === key) {
const oldEntry = aBucket.splice(index, 1)[0];
keysInd = this._keys.indexOf(key);
if (keysInd >= 0)
this._keys.splice(keysInd, 1);
return oldEntry.value;
}
}
}
return undefined;
}
/**
* @override
*/
keys() {
return [...this._keys];
}
/**
* @override
*/
values() {
let arr = new Array();
this._keys.forEach(key => arr.push(this.get(key)));
return arr;
}
/**
* Executes a `callBack` function for each entry in this dictionary
* @param callBack Function to call
* @param thisArg A reference to `this` object
*/
forEach(callBack, thisArg) {
this._keys.forEach(key => callBack(this.get(key), key, this), thisArg);
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"HashTable.js","sourceRoot":"","sources":["../../../../../projects/cute-core/src/lib/collections/HashTable.ts"],"names":[],"mappings":"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","sourcesContent":["import { NullPointerException } from \"../util/exception/NullPointerException\";\r\nimport { IllegalArgumentException } from \"../util/exception/IllegalArgumentException\";\r\nimport { IllegalStateException } from \"../util/exception/IllegalStateException\";\r\nimport { Ciphers } from \"../util/Ciphers\";\r\nimport { ArrayList } from \"./ArrayList\";\r\nimport { Dictionary} from \"./Dictionary\";\r\nimport { Entry } from \"./AbstractMap\";\r\n\r\nconst DEFAULT_HASH_SIZE = 32;\r\nconst MAX_LIST_SIZE = 8192;  // 4096\r\nconst MAX_LOCATIONS = 5\r\n\r\n/**\r\n * **Hash table** (hash map) is a data structure which implements an _associative array_ abstract data type, a structure that can _map keys\r\n * to values_. A hash table uses a _hash function_ to compute an index into an array of buckets or slots,\r\n * from which the desired value can be found\r\n */\r\nexport class HashTable<K,V> implements Dictionary<K,V> {\r\n  private _hashSize = DEFAULT_HASH_SIZE;\r\n  private _buckets: ArrayList<Array<Entry<K,V>>> = new ArrayList();\r\n  private _keys = new Array<K>();\r\n\r\n  constructor() {\r\n    this._initialize(this._hashSize);\r\n  }\r\n\r\n  private _initialize(hashSize: number): void {\r\n    this._buckets.clear();\r\n    for (let i = 0; i < hashSize; i++) {\r\n      this._buckets.add(new Array<Entry<K,V>>());\r\n    }\r\n    this._keys = [];\r\n  }\r\n\r\n  private _resize(): void {\r\n    const oldDic = new ArrayList<Array<Entry<K,V>>>();\r\n    oldDic.appendAll<Array<Entry<K,V>>>(this._buckets);\r\n    this._initialize(Math.min(oldDic.size * 4, MAX_LIST_SIZE));\r\n    this._buckets.appendAll<Array<Entry<K,V>>>(oldDic);\r\n  }\r\n  /**\r\n   * @override\r\n   */\r\n  clear(): void {\r\n    this._initialize(this._hashSize);\r\n  }\r\n  /**\r\n   * @override\r\n   */\r\n  isEmpty(): boolean {\r\n    return this.size == 0;\r\n  }\r\n  /**\r\n   * @override\r\n   */\r\n  get size(): number {\r\n    return this._keys.length;\r\n  }\r\n  /**\r\n   * Returns the value to which the `key` is mapped in this dictionary, or `undefined` if this map contains no mapping for the key\r\n   * @param key The key whose associated value is to be returned\r\n   * @returns The value to which the specified key is mapped, or `undefined` if this map contains no mapping for the key\r\n   */\r\n   get(key: K): V | undefined {\r\n    if (key == null) {\r\n      return undefined;\r\n    }\r\n    const aBucket = this._buckets.get(Ciphers.keyHash(String(key), this._buckets.size));\r\n    if (aBucket) {\r\n      for (let pair of aBucket) {\r\n        if ((pair as Entry<K,V>).key === key) {\r\n          return (pair as Entry<K,V>).value!;\r\n        }\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n  /**\r\n   * Returns the value to which the `key` is mapped in this dictionary, or `defaultValue` if this map contains no mapping for the key\r\n   * @param key The key whose associated value is to be returned\r\n   * @param defaultValue Default value that will be returned if there is no mapping for the `key`\r\n   * @returns The value to which the specified key is mapped, or `defaultValue` if this map contains no mapping for the key\r\n   */\r\n  getOrDefault(key: K, defaultValue: V): V {\r\n    return this.get(key) ?? defaultValue;\r\n  }\r\n  /**\r\n   * Tests if some key maps into the specified value in this hashtable\r\n   * @param key A key value\r\n   * @returns _true_ if the map contains the entry with the key `key`, or _false_ otherwise\r\n   * @see {@link contains}\r\n   * @see {@link containsKey}\r\n   */\r\n  has(key: K): boolean {\r\n    return this.containsKey(key);\r\n  }\r\n  /**\r\n   * Tests if some key maps into the specified value in this hashtable\r\n   * @param key A key value\r\n   * @returns _true_ if the map contains the entry with the key `key`, or _false_ otherwise\r\n   * @see {@link has}\r\n   * @see {@link containsKey}\r\n   */\r\n  contains(key: K): boolean {\r\n    return this.containsKey(key);\r\n  }\r\n  /**\r\n   * @override\r\n   * @see {@link has}\r\n   * @see {@link contains}\r\n   * @see {@link containsValue}\r\n   */\r\n  containsKey(key: K): boolean {\r\n    return (this._keys.indexOf(key) >= 0);\r\n  }\r\n  /**\r\n   * @override\r\n   * @see {@link containsKey}\r\n   */\r\n  containsValue(value: V): boolean {\r\n    for (let aBucket of this._buckets) {\r\n      for (let anEntry of aBucket!) {\r\n        if (anEntry.value === value) {\r\n          return true;\r\n        }\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n  /**\r\n   * Returns a `Set` view of the keys contained in this map\r\n   */\r\n  keySet(): Set<K> {\r\n    let set: Set<K> = new Set();\r\n    this._keys.forEach(key => set.add(key));\r\n    return set;\r\n  }\r\n  /**\r\n   * Maps the specified key to the specified value in this hashtable\r\n   * @param key The hashtable key\r\n   * @param value The value\r\n   * @returns The previous value of the specified key in this hashtable, or `undefined` if it did not have one\r\n   * @throws `IllegalArgumentException` if the `key` or `value` is _null_ or _undefined_\r\n   * @see {@link set}\r\n   */\r\n  put(key: K, value: V): V | undefined {\r\n\r\n    if (key == null || value == null) {\r\n      throw new IllegalArgumentException();\r\n    }\r\n\r\n    const keyHash = Ciphers.keyHash(String(key), this._buckets.size);\r\n    const aBucket = this._buckets.get(keyHash);\r\n    if (!aBucket) {\r\n      throw new IllegalStateException();\r\n    }\r\n\r\n    let count = -1;\r\n    let index = -1;\r\n    for (let pair of aBucket) {\r\n      count++;\r\n      if (pair.key === key) {\r\n        index = count;\r\n        break;\r\n      }\r\n    }\r\n\r\n    let oldValue: V | undefined = undefined;\r\n\r\n    if (index == -1) {\r\n      const pair: Entry<K,V> = { key, value };\r\n      index = aBucket.push(pair);\r\n      this._keys.push(key);\r\n    } else {\r\n      oldValue = aBucket[index].value!;\r\n      aBucket[index].value = value;\r\n    }\r\n\r\n    if (index > MAX_LOCATIONS && this._buckets.size < MAX_LIST_SIZE) {\r\n      // this bucket is big, grow dict\r\n      this._resize();\r\n    }\r\n\r\n    return oldValue;\r\n  }\r\n  /**\r\n   * Copies all the mappings from the specified source map to this map\r\n   * @param map Source `Map` object\r\n   * @throws `NullPointerException` if the `map` is a nullish value\r\n   * @see {@link put}\r\n   */\r\n  putAll(map: Map<K,V>|HashTable<K,V>): void {\r\n    if (map == null) {\r\n      throw new NullPointerException();\r\n    }\r\n    map.forEach((value, key)=>this.put(key, value));\r\n  }\r\n  /**\r\n   * Removes the key (and its corresponding value) from this hashtable\r\n   * @param key The key that needs to be removed\r\n   * @returns _true_ if the entry with the key `key` was deleted, or _false_ otherwise\r\n   * @see {@link remove}\r\n   */\r\n  delete(key: K): boolean {\r\n    if (key == null) return false;\r\n    const aBucket = this._buckets.get(Ciphers.keyHash( String(key), this._buckets.size));\r\n    if (aBucket) {\r\n      let index = -1;\r\n      let keysInd;\r\n      for (let pair of aBucket) {\r\n        index++;\r\n        if (pair.key === key) {\r\n          aBucket.splice(index, 1);\r\n          keysInd = this._keys.indexOf(key);\r\n          if (keysInd >= 0 ) this._keys.splice(keysInd, 1);\r\n          return true;\r\n        }\r\n      }\r\n    }\r\n    return false\r\n  }\r\n  /**\r\n   * Maps the specified key to the specified value in this hashtable and returns a reference to `this` value.\r\n   * If a `key` or a `value` equals to _null_ or _undefined_ value operation is ignored.\r\n   * @param key A key of the key/value pair\r\n   * @param value A value of the key/value pair\r\n   * @returns `this` value\r\n   * @see {@link put}\r\n   */\r\n  set(key:K, value:V): this {\r\n    if (!(key == null || value == null)) {\r\n      this.put(key, value);\r\n    }\r\n    return this;\r\n  }\r\n  /**\r\n   * Removes the key (and its corresponding value) from this hashtable\r\n   * @param key The key that needs to be removed\r\n   * @returns The value to which the key had been mapped in this hashtable, or `null` if the key did not have a mapping\r\n   * @throws `IllegalArgumentException` if the `key` is _null_ or _undefined_\r\n   */\r\n  remove(key: K): V | undefined {\r\n    if (key == null) {\r\n      throw new IllegalArgumentException();\r\n    }\r\n\r\n    const aBucket = this._buckets.get(Ciphers.keyHash( String(key), this._buckets.size));\r\n    if (aBucket) {\r\n      let index = -1;\r\n      let keysInd;\r\n      for (let pair of aBucket) {\r\n        index++;\r\n        if (pair.key === key) {\r\n          const oldEntry = aBucket.splice(index, 1)[0];\r\n          keysInd = this._keys.indexOf(key);\r\n          if (keysInd >= 0 ) this._keys.splice(keysInd, 1);\r\n          return oldEntry.value!;\r\n        }\r\n      }\r\n    }\r\n    return undefined;\r\n  }\r\n  /**\r\n   * @override\r\n   */\r\n  keys(): Array<K> {\r\n    return [...this._keys];\r\n  }\r\n  /**\r\n   * @override\r\n   */\r\n  values(): Array<V> {\r\n    let arr = new Array<V>();\r\n    this._keys.forEach(key => arr.push(this.get(key)!));\r\n    return arr;\r\n  }\r\n  /**\r\n   * Executes a `callBack` function for each entry in this dictionary\r\n   * @param callBack Function to call\r\n   * @param thisArg A reference to `this` object\r\n   */\r\n  forEach(callBack: (value: V, key: K, map: HashTable<K,V>)=>void, thisArg?: any): void {\r\n    this._keys.forEach(key=>callBack(this.get(key)!, key, this), thisArg );\r\n  }\r\n\r\n}\r\n"]}