@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
151 lines • 18.7 kB
JavaScript
import { Comparator } from "./Comparator";
import { NullPointerException } from "./exception/NullPointerException";
import { HashSet } from "../collections/HashSet";
import { ArrayList } from "../collections/ArrayList";
import { HashMap } from "../collections/HashMap";
/**
* This class consists exclusively of static methods that operate on or return collections.
*/
export class Collections {
/**
* Adds all of the specified elements to the specified collection
* @param c Collection object
* @param elements Elements to add to the collection `c`
* @returns _true_ if the collection changed as a result of this call, or _false_ otherwise
*/
static addAll(c, ...elements) {
if (!c) {
throw new NullPointerException();
}
let nCount = 0;
for (let el of elements) {
if (c.add(el)) {
nCount++;
}
}
return nCount > 0;
}
/**
* Returns the number of elements in the specified collection equal to the specified object
* @param c The collection in which to determine the frequency of o
* @param o The object whose frequency is to be determined
* @returns The number of elements in c equal to o
*/
static frequency(c, o) {
let nCount = 0;
for (const elem of c) {
if (Object.is(elem, o)) {
nCount++;
}
}
return nCount;
}
/**
* Returns the maximum element of the given collection, according to the _natural ordering_ of its elements or to the order induced by the specified comparator
* @param c The collection whose maximum element is to be determined
* @param comparator The comparator with which to determine the maximum element. An _undefined_ value indicates that the elements' natural ordering should be used.
* @returns The maximum element of the given collection, according to the specified comparator. Returns _undefined_ if the collection `c` is empty.
*/
static max(c, comparator) {
let maxElem = undefined;
if (c && c.size > 0) {
comparator = comparator ?? Comparator.getInstance();
for (const elem of c) {
if (maxElem === undefined) {
maxElem = elem;
}
else if (comparator.greaterThan(elem, maxElem)) {
maxElem = elem;
}
}
}
return maxElem;
}
/**
* Returns the minimum element of the given collection, according to the _natural ordering_ of its elements or to the order induced by the specified comparator
* @param c The collection whose minimum element is to be determined
* @param comparator The comparator with which to determine the minimum element. An _undefined_ value indicates that the elements' natural ordering should be used.
* @returns The minimum element of the given collection, according to the specified comparator. Returns _undefined_ if the collection `c` is empty.
*/
static min(c, comparator) {
let minElem = undefined;
if (c && c.size > 0) {
comparator = comparator ?? Comparator.getInstance();
for (const elem of c) {
if (minElem === undefined) {
minElem = elem;
}
else if (comparator.lessThan(elem, minElem)) {
minElem = elem;
}
}
}
return minElem;
}
/**
* Replaces all occurrences of one specified value in a list with another
* @param list The list in which replacement is to occur
* @param oldVal The old value to be replaced
* @param newVal The new value with which `oldVal` is to be replaced
* @returns _true_ if the `list` was changed, _false_ otherwise
*/
static replaceAll(list, oldVal, newVal) {
let nCount = 0;
if (list && oldVal !== newVal) {
list.every((value, index) => {
if (value === oldVal) {
nCount++;
list.set(index, newVal);
}
return true;
});
}
return nCount > 0;
}
/**
* Reverses the order of the elements in the specified list
* @param list The list whose elements are to be reversed
* @returns The list argument itself
*/
static reverse(list) {
if (list && list.size > 0) {
const arr = list.toArray().reverse();
for (let i = 0; i < arr.length; i++) {
list.set(i, arr[i]);
}
}
return list;
}
/**
* Returns an immutable set containing only the specified object
* @param object The sole object to be stored in the returned set
* @returns An immutable set containing only the specified object
* @since 0.5.0
*/
static singleton(object) {
const set = new HashSet([object]);
return set;
}
/**
* Returns an immutable list containing only the specified object.
* @param object The sole object to be stored in the returned list
* @returns An immutable list containing only the specified object
* @since 0.5.0
*/
static singletonList(object) {
const list = new ArrayList([object]);
return list;
}
/**
* Returns an _immutable_ map, mapping only the specified key to the specified value.
* @param key The sole key to be stored in the returned map
* @param value The value to which the returned map maps key
* @returns An immutable map containing only the specified key-value mapping
* @since 0.5.0
*/
static singletonMap(key, value) {
const map = new HashMap([[key, value]]);
return map;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Collections.js","sourceRoot":"","sources":["../../../../../projects/cute-core/src/lib/util/Collections.ts"],"names":[],"mappings":"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","sourcesContent":["import { Collection, Element } from \"../collections/Collection\";\r\nimport {ImmutableList, List} from \"../collections/List\";\r\nimport { Comparator } from \"./Comparator\";\r\nimport { NullPointerException } from \"./exception/NullPointerException\";\r\nimport {ImmutableSet} from \"../collections/AbstractSet\";\r\nimport {HashSet} from \"../collections/HashSet\";\r\nimport {ArrayList} from \"../collections/ArrayList\";\r\nimport {HashMap} from \"../collections/HashMap\";\r\nimport {ImmutableMap} from \"../collections/AbstractMap\";\r\n\r\n/**\r\n * This class consists exclusively of static methods that operate on or return collections.\r\n */\r\nexport class Collections {\r\n  /**\r\n   * Adds all of the specified elements to the specified collection\r\n   * @param c Collection object\r\n   * @param elements Elements to add to the collection `c`\r\n   * @returns _true_ if the collection changed as a result of this call, or _false_ otherwise\r\n   */\r\n  static addAll<T>(c: Collection<T>, ...elements: Element<T>[]): boolean {\r\n    if (!c) {\r\n      throw new NullPointerException();\r\n    }\r\n    let nCount=0;\r\n    for (let el of elements) {\r\n      if (c.add(el)) {\r\n        nCount++;\r\n      }\r\n    }\r\n    return nCount > 0;\r\n  }\r\n  /**\r\n   * Returns the number of elements in the specified collection equal to the specified object\r\n   * @param c The collection in which to determine the frequency of o\r\n   * @param o The object whose frequency is to be determined\r\n   * @returns The number of elements in c equal to o\r\n   */\r\n  static frequency<T>(c: Collection<T>, o: Element<T>): number {\r\n    let nCount = 0;\r\n    for (const elem of c) {\r\n      if ( Object.is(elem, o) ) {\r\n        nCount++;\r\n      }\r\n    }\r\n    return nCount;\r\n  }\r\n  /**\r\n   * Returns the maximum element of the given collection, according to the _natural ordering_ of its elements or to the order induced by the specified comparator\r\n   * @param c The collection whose maximum element is to be determined\r\n   * @param comparator The comparator with which to determine the maximum element. An _undefined_ value indicates that the elements' natural ordering should be used.\r\n   * @returns The maximum element of the given collection, according to the specified comparator. Returns _undefined_ if the collection `c` is empty.\r\n   */\r\n  static max<T>(c: Collection<T>, comparator?: Comparator<T>): Element<T> | undefined {\r\n    let maxElem: Element<T> | undefined = undefined;\r\n    if (c && c.size > 0) {\r\n      comparator = comparator ?? Comparator.getInstance();\r\n      for (const elem of c) {\r\n        if (maxElem === undefined) {\r\n          maxElem = elem;\r\n        } else if (comparator.greaterThan(elem, maxElem)) {\r\n          maxElem = elem;\r\n        }\r\n      }\r\n    }\r\n    return maxElem;\r\n  }\r\n  /**\r\n   * Returns the minimum element of the given collection, according to the _natural ordering_ of its elements or to the order induced by the specified comparator\r\n   * @param c The collection whose minimum element is to be determined\r\n   * @param comparator The comparator with which to determine the minimum element. An _undefined_ value indicates that the elements' natural ordering should be used.\r\n   * @returns The minimum element of the given collection, according to the specified comparator. Returns _undefined_ if the collection `c` is empty.\r\n   */\r\n  static min<T>(c: Collection<T>, comparator?: Comparator<T>): Element<T> | undefined {\r\n    let minElem: Element<T> | undefined = undefined;\r\n    if (c && c.size > 0) {\r\n      comparator = comparator ?? Comparator.getInstance();\r\n      for (const elem of c) {\r\n        if (minElem === undefined) {\r\n          minElem = elem;\r\n        } else if (comparator.lessThan(elem, minElem)) {\r\n          minElem = elem;\r\n        }\r\n      }\r\n    }\r\n    return minElem;\r\n  }\r\n  /**\r\n   * Replaces all occurrences of one specified value in a list with another\r\n   * @param list The list in which replacement is to occur\r\n   * @param oldVal The old value to be replaced\r\n   * @param newVal The new value with which `oldVal` is to be replaced\r\n   * @returns _true_ if the `list` was changed, _false_ otherwise\r\n   */\r\n  static replaceAll<T>(list: List<T>, oldVal: Element<T>, newVal: Element<T>): boolean {\r\n    let nCount = 0;\r\n    if (list && oldVal !== newVal) {\r\n      list.every((value, index) => {\r\n        if (value === oldVal) {\r\n          nCount++;\r\n          list.set(index, newVal);\r\n        }\r\n        return true;\r\n      });\r\n    }\r\n    return nCount > 0;\r\n  }\r\n  /**\r\n   * Reverses the order of the elements in the specified list\r\n   * @param list The list whose elements are to be reversed\r\n   * @returns The list argument itself\r\n   */\r\n  static reverse<T>(list: List<T>): List<T> {\r\n    if (list && list.size > 0) {\r\n      const arr = list.toArray().reverse();\r\n      for (let i=0; i < arr.length; i++) {\r\n        list.set(i, arr[i]);\r\n      }\r\n    }\r\n    return list;\r\n  }\r\n  /**\r\n   * Returns an immutable set containing only the specified object\r\n   * @param object The sole object to be stored in the returned set\r\n   * @returns An immutable set containing only the specified object\r\n   * @since 0.5.0\r\n   */\r\n  static singleton<T=unknown>(object: T): ImmutableSet<T> {\r\n    const set: HashSet<T> = new HashSet([object]);\r\n    return <ImmutableSet<T>> set;\r\n  }\r\n  /**\r\n   * Returns an immutable list containing only the specified object.\r\n   * @param object The sole object to be stored in the returned list\r\n   * @returns An immutable list containing only the specified object\r\n   * @since 0.5.0\r\n   */\r\n  static singletonList<T=unknown>(object: T): ImmutableList<T> {\r\n    const list: List<T> = new ArrayList([object]);\r\n    return <ImmutableList<T>> list;\r\n  }\r\n  /**\r\n   * Returns an _immutable_ map, mapping only the specified key to the specified value.\r\n   * @param key The sole key to be stored in the returned map\r\n   * @param value The value to which the returned map maps key\r\n   * @returns An immutable map containing only the specified key-value mapping\r\n   * @since 0.5.0\r\n   */\r\n  static singletonMap<K,V>(key: K, value:V): ImmutableMap<K,V> {\r\n    const map: HashMap<K,V> = new HashMap([[key, value]]);\r\n    return <ImmutableMap<K,V>> map;\r\n  }\r\n\r\n}\r\n"]}