From fd855bd6319fbf9d4706d5f4b586ffdab7526402 Mon Sep 17 00:00:00 2001 From: Jeongho Nam Date: Sat, 8 Oct 2016 02:02:27 +0900 Subject: [PATCH] TypeScript-STL & Samchon-Framework (#11818) For TS2.0 --- samchon-collection/samchon-collection.d.ts | 6 +- samchon-framework/index.d.ts | 10266 +++++++++----- typescript-stl/index.d.ts | 13713 ++++++++++--------- 3 files changed, 13963 insertions(+), 10022 deletions(-) diff --git a/samchon-collection/samchon-collection.d.ts b/samchon-collection/samchon-collection.d.ts index 5f62a81d42..6d6d7e78e2 100644 --- a/samchon-collection/samchon-collection.d.ts +++ b/samchon-collection/samchon-collection.d.ts @@ -1,4 +1,4 @@ -// Type definitions for Samchon Collection v0.0.2 +// Type definitions for Samchon Collection v0.0.4 // Project: https://github.com/samchon/framework // Definitions by: Jeongho Nam // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped @@ -7,7 +7,7 @@ declare module "samchon-collection" { - import collection = samchon.collection; - export = collection; + import collections = samchon.collections; + export = collections; } diff --git a/samchon-framework/index.d.ts b/samchon-framework/index.d.ts index b34eec8e6f..fb3e02bf53 100644 --- a/samchon-framework/index.d.ts +++ b/samchon-framework/index.d.ts @@ -1,4 +1,4 @@ -// Type definitions for Samchon Framework v2.0.0-beta.8 +// Type definitions for Samchon Framework v2.0.0-gamma.4 // Project: https://github.com/samchon/framework // Definitions by: Jeongho Nam // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped @@ -7,63 +7,110 @@ declare module "samchon-framework" { - export = samchon; + export = samchon; } /** *

Samchon-Framework

* - *

- *

+ * + * * - *

Samchon, a SDN (Software Defined Network) framework.

+ * Samchon, a SDN (Software Defined Network) framework. * - *

With Samchon Framework, you can implement distributed processing system within framework of OOD like - * handling S/W objects (classes). You can realize cloud and distributed system very easily with provided - * system templates and even integration with C++ is possible.

+ * With Samchon Framework, you can implement distributed processing system within framework of OOD like handling S/W + * objects (classes). You can realize cloud and distributed system very easily with provided system templates and even + * integration with C++ is possible. * - *

The goal, ultimate utilization model of Samchon Framework is, building cloud system with NodeJS and - * takING heavy works to C++ distributed systems with provided modules (those are system templates).

+ * The goal, ultimate utilization model of Samchon Framework is, building cloud system with NodeJS and taking heavy works + * to C++ distributed systems with provided modules (those are system templates). * * @git https://github.com/samchon/framework * @author Jeongho Nam */ declare namespace samchon { /** - *

Running on Node.

+ * Running on Node. * - *

Test whether the JavaScript is running on Node.

+ * Test whether the JavaScript is running on Node. * * @references http://stackoverflow.com/questions/17575790/environment-detection-node-js-or-browser */ function is_node(): boolean; } -declare namespace samchon.collection { +declare namespace samchon.collections { /** * A {@link Vector} who can detect element I/O events. * - *
    - *
  • insert typed events:
      - *
    • {@link assign}
      • - *
    • {@link insert}
      • - *
    • {@link push}
      • - *
    • {@link push_back}
      • - *
    • {@link unshift}
      • - *
    • - *
  • erase typed events:
      - *
    • {@link assign}
      • - *
    • {@link clear}
      • - *
    • {@link erase}
      • - *
    • {@link pop_back}
      • - *
    • {@link shift}
      • - *
    • {@link pop}
      • - *
    • {@link splice}
      • - *
    • - *
  • erase typed events:
      - *
    • {@link sort}
      • - *
    • - *
+ * Below is the list of methods who are dispatching {@link CollectionEvent}: + * - *insert* typed events: + * - {@link assign} + * - {@link insert} + * - {@link push} + * - {@link push_back} + * - {@link unshift} + * - *erase* typed events: + * - {@link assign} + * - {@link clear} + * - {@link erase} + * - {@link pop_back} + * - {@link shift} + * - {@link pop} + * - {@link splice} + * - *refresh* typed events: + * - {@link refresh} * + * #### [Inherited] {@link Vector} + * {@link Vector Vectors}s are sequence containers representing arrays that can change in size. + * + * Just like arrays, {@link Vector}s use contiguous storage locations for their elements, which means that their + * elements can also be accessed using offsets on regular pointers to its elements, and just as efficiently as in + * arrays. But unlike arrays, their size can change dynamically, with their storage being handled automatically + * by the container. + * + * Internally, {@link Vector}s use a dynamically allocated array to store their elements. This array may need to + * be reallocated in order to grow in size when new elements are inserted, which implies allocating a new array + * and moving all elements to it. This is a relatively expensive task in terms of processing time, and thus, + * {@link Vector}s do not reallocate each time an element is added to the container. + * + * Instead, {@link Vector} containers may allocate some extra storage to accommodate for possible growth, and + * thus the container may have an actual {@link capacity} greater than the storage strictly needed to contain its + * elements (i.e., its {@link size}). Libraries can implement different strategies for growth to balance between + * memory usage and reallocations, but in any case, reallocations should only happen at logarithmically growing + * intervals of {@link size} so that the insertion of individual elements at the end of the {@link Vector} can be + * provided with amortized constant time complexity (see {@link push_back push_back()}). + * + * Therefore, compared to arrays, {@link Vector}s consume more memory in exchange for the ability to manage + * storage and grow dynamically in an efficient way. + * + * Compared to the other dynamic sequence containers ({@link Deque}s, {@link List}s), {@link Vector Vectors} are + * very efficient accessing its elements (just like arrays) and relatively efficient adding or removing elements + * from its end. For operations that involve inserting or removing elements at positions other than the end, they + * perform worse than the others, and have less consistent iterators and references than {@link List}s. + * + * + * + * + * + *

Container properties

+ *
+ *
Sequence
+ *
+ * Elements in sequence containers are ordered in a strict linear sequence. Individual elements are + * accessed by their position in this sequence. + *
+ * + *
Dynamic array
+ *
+ * Allows direct access to any element in the sequence, even through pointer arithmetics, and provides + * relatively fast addition/removal of elements at the end of the sequence. + *
+ *
+ * + * @param Type of the elements. + * + * @reference http://www.cplusplus.com/reference/vector/vector + * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections) * @author Jeongho Nam */ class ArrayCollection extends std.Vector implements ICollection { @@ -74,7 +121,7 @@ declare namespace samchon.collection { /** * @inheritdoc */ - push(...items: U[]): number; + push(...items: T[]): number; /** * @inheritdoc */ @@ -170,6 +217,7 @@ declare namespace samchon.library { * A basic event class of Samchon Framework. * * @reference https://developer.mozilla.org/en-US/docs/Web/API/Event + * @handbook https://github.com/samchon/framework/wiki/TypeScript-Library-EventDispatcher * @author Jeongho Nam */ class BasicEvent { @@ -201,7 +249,7 @@ declare namespace samchon.library { /** * @inheritdoc */ - type: string; + readonly type: string; /** * @inheritdoc */ @@ -209,89 +257,98 @@ declare namespace samchon.library { /** * @inheritdoc */ - currentTarget: IEventDispatcher; + readonly currentTarget: IEventDispatcher; /** * @inheritdoc */ - isTrusted: boolean; + readonly isTrusted: boolean; /** * @inheritdoc */ - bubbles: boolean; + readonly bubbles: boolean; /** * @inheritdoc */ - cancelable: boolean; + readonly cancelable: boolean; /** * @inheritdoc */ - eventPhase: number; + readonly eventPhase: number; /** * @inheritdoc */ - defaultPrevented: boolean; + readonly defaultPrevented: boolean; /** * @inheritdoc */ - srcElement: Element; + readonly srcElement: Element; /** * @inheritdoc */ - cancelBubble: boolean; + readonly cancelBubble: boolean; /** * @inheritdoc */ - timeStamp: number; + readonly timeStamp: number; /** * Don't know what it is. */ - returnValue: boolean; + readonly returnValue: boolean; } } -declare namespace samchon.collection { +declare namespace samchon.collections { /** * Type of function pointer for listener of {@link CollectionEvent CollectionEvents}. */ type CollectionEventListener = (event: CollectionEvent) => void; } -declare namespace samchon.collection { +declare namespace samchon.collections { /** + * An event occured in a {@link ICollection collection} object. + * + * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections) * @author Jeongho Nam */ class CollectionEvent extends library.BasicEvent { /** * @hidden */ - protected first_: std.Iterator; + private first_; + /** + * @hidden + */ + private last_; /** * @hidden */ - protected last_: std.Iterator; private temporary_container_; + /** + * @hidden + */ private origin_first_; /** * Initialization Constructor. * * @param type Type of collection event. - * @param first - * @param last + * @param first An {@link Iterator} to the initial position in this {@link CollectionEvent}. + * @param last An {@link Iterator} to the final position in this {@link CollectionEvent}. */ constructor(type: string, first: std.Iterator, last: std.Iterator); constructor(type: "insert", first: std.Iterator, last: std.Iterator); constructor(type: "erase", first: std.Iterator, last: std.Iterator); constructor(type: "refresh", first: std.Iterator, last: std.Iterator); /** - * Get associative target, the container. + * Associative target, the {@link ICollection collection}. */ - target: ICollection; + readonly target: ICollection; /** - * Get range of the first. + * An {@link Iterator} to the initial position in this {@link CollectionEvent}. */ - first: std.Iterator; + readonly first: std.Iterator; /** - * Get range of the last. + * An {@link Iterator} to the final position in this {@link CollectionEvent}. */ - last: std.Iterator; + readonly last: std.Iterator; /** * @inheritdoc */ @@ -301,34 +358,78 @@ declare namespace samchon.collection { /** * @hidden */ -declare namespace samchon.collection.CollectionEvent { +declare namespace samchon.collections.CollectionEvent { const INSERT: "insert"; const ERASE: "erase"; const REFRESH: "refresh"; } -declare namespace samchon.collection { +declare namespace samchon.collections { /** * A {@link Deque} who can detect element I/O events. * - *

Below are list of methods who are dispatching {@link CollectionEvent}:

+ * Below is the list of methods who are dispatching {@link CollectionEvent}: + * - *insert* typed events: + * - {@link assign} + * - {@link insert} + * - {@link push} + * - {@link push_front} + * - {@link push_back} + * - *erase* typed events: + * - {@link assign} + * - {@link clear} + * - {@link erase} + * - {@link pop_front} + * - {@link pop_back} + * - *refresh* typed events: + * - {@link refresh} * - *
    - *
  • insert typed events:
      - *
    • {@link assign}
      • - *
    • {@link insert}
      • - *
    • {@link push}
      • - *
    • {@link push_front}
      • - *
    • {@link push_back}
      • - *
    • - *
  • erase typed events:
      - *
    • {@link assign}
      • - *
    • {@link clear}
      • - *
    • {@link erase}
      • - *
    • {@link pop_front}
      • - *
    • {@link pop_back}
      • - *
    • - *
+ * #### [Inherited] {@link Deque} + * {@link Deque} (usually pronounced like "*deck*") is an irregular acronym of **d**ouble-**e**nded **q**ueue. + * Double-ended queues are sequence containers with dynamic sizes that can be expanded or contracted on both ends + * (either its front or its back). * + * Specific libraries may implement deques in different ways, generally as some form of dynamic array. But in any + * case, they allow for the individual elements to be accessed directly through random access iterators, with + * storage handled automatically by expanding and contracting the container as needed. + * + * Therefore, they provide a functionality similar to vectors, but with efficient insertion and deletion of + * elements also at the beginning of the sequence, and not only at its end. But, unlike {@link Vector Vectors}, + * {@link Deque Deques} are not guaranteed to store all its elements in contiguous storage locations: accessing + * elements in a deque by offsetting a pointer to another element causes undefined behavior. + * + * Both {@link Vector}s and {@link Deque}s provide a very similar interface and can be used for similar purposes, + * but internally both work in quite different ways: While {@link Vector}s use a single array that needs to be + * occasionally reallocated for growth, the elements of a {@link Deque} can be scattered in different chunks of + * storage, with the container keeping the necessary information internally to provide direct access to any of its + * elements in constant time and with a uniform sequential interface (through iterators). Therefore, + * {@link Deque Deques} are a little more complex internally than {@link Vector}s, but this allows them to grow + * more efficiently under certain circumstances, especially with very long sequences, where reallocations become + * more expensive. + * + * For operations that involve frequent insertion or removals of elements at positions other than the beginning or + * the end, {@link Deque Deques} perform worse and have less consistent iterators and references than + * {@link List Lists}. + * + * + * + * + * + *

Container properties

+ *
+ *
Sequence
+ *
Elements in sequence containers are ordered in a strict linear sequence. Individual elements + * are accessed by their position in this sequence.
+ * + *
Dynamic array
+ *
Generally implemented as a dynamic array, it allows direct access to any element in the + * sequence and provides relatively fast addition/removal of elements at the beginning or the end + * of the sequence.
+ *
+ * + * @param Type of the elements. + * + * @reference http://www.cplusplus.com/reference/deque/deque/ + * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections) * @author Jeongho Nam */ class DequeCollection extends std.Deque implements ICollection { @@ -339,7 +440,7 @@ declare namespace samchon.collection { /** * @inheritdoc */ - push(...items: U[]): number; + push(...items: T[]): number; /** * @inheritdoc */ @@ -418,30 +519,72 @@ declare namespace samchon.collection { removeEventListener(type: "refresh", listener: CollectionEventListener, thisArg: Object): void; } } -declare namespace samchon.collection { +declare namespace samchon.collections { /** * A {@link HashMap} who can detect element I/O events. * - *
    - *
  • insert typed events:
      - *
    • {@link assign}
      • - *
    • {@link insert}
      • - *
    • {@link push}
      • - *
    • {@link set}
      • - *
    • {@link insert_or_assign}
      • - *
    • - *
  • erase typed events:
      - *
    • {@link assign}
      • - *
    • {@link clear}
      • - *
    • {@link erase}
      • - *
    • {@link extract}
      • - *
    • - *
  • refresh typed events:
      - *
    • {@link set}
      • - *
    • {@link insert_or_assign}
      • - *
    • - *
+ * Below is the list of methods who are dispatching {@link MapCollectionEvent}: + * - *insert* typed events: + * - {@link assign} + * - {@link insert} + * - {@link insert_or_assign} + * - {@link emplace} + * - {@link set} + * - {@link push} + * - *erase* typed events: + * - {@link assign} + * - {@link clear} + * - {@link erase} + * - {@link extract} + * - *refresh* typed events: + * - {@link refresh} * + * #### [Inherited] {@link HashMap} + * {@link HashMap HashMaps} are associative containers that store elements formed by the combination of a + * *key value* and a *mapped value*, and which allows for fast retrieval of individual elements based on their + * *keys*. + * + * In an {@link HashMap}, the *key value* is generally used to uniquely identify the element, while the + * *mapped value* is an object with the content associated to this *key*. Types of *key* and *mapped value* may + * differ. + * + * Internally, the elements in the {@link HashMap} are not sorted in any particular order with respect to either + * their *key* or *mapped values*, but organized into *buckets* depending on their hash values to allow for fast + * access to individual elements directly by their *key values* (with a constant average time complexity on + * average). + * + * {@link HashMap} containers are faster than {@link TreeMap} containers to access individual elements by their + * *key*, although they are generally less efficient for range iteration through a subset of their elements. + * + * + * + * + * + *

Container properties

+ *
+ *
Associative
+ *
Elements in associative containers are referenced by their *key* and not by their absolute + * position in the container.
+ * + *
Hashed
+ *
Hashed containers organize their elements using hash tables that allow for fast access to elements + * by their *key*.
+ * + *
Map
+ *
Each element associates a *key* to a *mapped value*: + * *Keys* are meant to identify the elements whose main content is the *mapped value*.
+ * + *
Unique keys
+ *
No two elements in the container can have equivalent keys.
+ *
+ * + * @param Type of the key values. + * Each element in an {@link HashMap} is uniquely identified by its key value. + * @param Type of the mapped value. + * Each element in an {@link HashMap} is used to store some data as its mapped value. + * + * @reference http://www.cplusplus.com/reference/unordered_map/unordered_map + * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections) * @author Jeongho Nam */ class HashMapCollection extends std.HashMap implements ICollection> { @@ -507,23 +650,69 @@ declare namespace samchon.collection { removeEventListener(type: "refresh", listener: MapCollectionEventListener, thisArg: Object): void; } } -declare namespace samchon.collection { +declare namespace samchon.collections { /** * A {@link HashMultiMap} who can detect element I/O events. * - *
    - *
  • insert typed events:
      - *
    • {@link assign}
      • - *
    • {@link insert}
      • - *
    • {@link push}
      • - *
    • - *
  • erase typed events:
      - *
    • {@link assign}
      • - *
    • {@link clear}
      • - *
    • {@link erase}
      • - *
    • - *
+ * Below is the list of methods who are dispatching {@link MapCollectionEvent}: + * - *insert* typed events: + * - {@link assign} + * - {@link insert} + * - {@link emplace} + * - {@link push} + * - *erase* typed events: + * - {@link assign} + * - {@link clear} + * - {@link erase} + * - *refresh* typed events: + * - {@link refresh} * + * #### [Inherited] {@link HashMultiMap} + * {@link HashMultiMap HashMultiMap}s are associative containers that store elements formed by the combination of + * a *key value* and a *mapped value*, much like {@link HashMultiMap} containers, but allowing different elements + * to have equivalent *keys*. + * + * In an {@link HashMultiMap}, the *key value* is generally used to uniquely identify the element, while the + * *mapped value* is an object with the content associated to this *key*. Types of *key* and *mapped value* may + * differ. + * + * Internally, the elements in the {@link HashMultiMap} are not sorted in any particular order with respect to + * either their *key* or *mapped values*, but organized into *buckets* depending on their hash values to allow for + * fast access to individual elements directly by their *key values* (with a constant average time complexity on + * average). + * + * Elements with equivalent *keys* are grouped together in the same bucket and in such a way that an iterator can + * iterate through all of them. Iterators in the container are doubly linked iterators. + * + * + * + * + * + *

Container properties

+ *
+ *
Associative
+ *
Elements in associative containers are referenced by their *key* and not by their absolute + * position in the container.
+ * + *
Hashed
+ *
Hashed containers organize their elements using hash tables that allow for fast access to elements + * by their *key*.
+ * + *
Map
+ *
Each element associates a *key* to a *mapped value*: + * *Keys* are meant to identify the elements whose main content is the *mapped value*.
+ * + *
Multiple equivalent keys
+ *
The container can hold multiple elements with equivalent *keys*.
+ *
+ * + * @param Type of the key values. + * Each element in an {@link HashMultiMap} is identified by a key value. + * @param Type of the mapped value. + * Each element in an {@link HashMultiMap} is used to store some data as its mapped value. + * + * @reference http://www.cplusplus.com/reference/unordered_map/unordered_multimap + * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections) * @author Jeongho Nam */ class HashMultiMapCollection extends std.HashMap implements ICollection> { @@ -589,23 +778,64 @@ declare namespace samchon.collection { removeEventListener(type: "refresh", listener: MapCollectionEventListener, thisArg: Object): void; } } -declare namespace samchon.collection { +declare namespace samchon.collections { /** * A {@link HashMultiSet} who can detect element I/O events. * - *
    - *
  • insert typed events:
      - *
    • {@link assign}
      • - *
    • {@link insert}
      • - *
    • {@link push}
      • - *
    • - *
  • erase typed events:
      - *
    • {@link assign}
      • - *
    • {@link clear}
      • - *
    • {@link erase}
      • - *
    • - *
+ * Below is the list of methods who are dispatching {@link CollectionEvent}: + * - *insert* typed events: + * - {@link assign} + * - {@link insert} + * - {@link push} + * - *erase* typed events: + * - {@link assign} + * - {@link clear} + * - {@link erase} + * - *refresh* typed events: + * - {@link refresh} * + * #### [Inherited] {@link HashMultiSet} + * {@link HashMultiSet HashMultiSets} are containers that store elements in no particular order, allowing fast + * retrieval of individual elements based on their value, much like {@link HashMultiSet} containers, but allowing + * different elements to have equivalent values. + * + * In an {@link HashMultiSet}, the value of an element is at the same time its *key*, used to identify it. *Keys* + * are immutable, therefore, the elements in an {@link HashMultiSet} cannot be modified once in the container - + * they can be inserted and removed, though. + * + * Internally, the elements in the {@link HashMultiSet} are not sorted in any particular, but organized into + * *buckets* depending on their hash values to allow for fast access to individual elements directly by their + * *values* (with a constant average time complexity on average). + * + * Elements with equivalent values are grouped together in the same bucket and in such a way that an iterator can + * iterate through all of them. Iterators in the container are doubly linked iterators. + * + * + * + * + * + *

Container properties

+ *
+ *
Associative
+ *
Elements in associative containers are referenced by their *key* and not by their absolute + * position in the container.
+ * + *
Hashed
+ *
Hashed containers organize their elements using hash tables that allow for fast access to elements + * by their *key*.
+ * + *
Set
+ *
The value of an element is also the *key* used to identify it.
+ * + *
Multiple equivalent keys
+ *
The container can hold multiple elements with equivalent *keys*.
+ *
+ * + * @param Type of the elements. + * Each element in an {@link UnorderedMultiSet} is also identified by this value.. + * + * @reference http://www.cplusplus.com/reference/unordered_set/unordered_multiset + * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections) * @author Jeongho Nam */ class HashMultiSetCollection extends std.HashMultiSet implements ICollection { @@ -671,24 +901,65 @@ declare namespace samchon.collection { removeEventListener(type: "refresh", listener: CollectionEventListener, thisArg: Object): void; } } -declare namespace samchon.collection { +declare namespace samchon.collections { /** * A {@link HashSet} who can detect element I/O events. * - *
    - *
  • insert typed events:
      - *
    • {@link assign}
      • - *
    • {@link insert}
      • - *
    • {@link push}
      • - *
    • - *
  • erase typed events:
      - *
    • {@link assign}
      • - *
    • {@link clear}
      • - *
    • {@link erase}
      • - *
    • {@link extract}
      • - *
    • - *
+ * Below is the list of methods who are dispatching {@link CollectionEvent}: + * - *insert* typed events: + * - {@link assign} + * - {@link insert} + * - {@link push} + * - {@link insert_or_assign} + * - *erase* typed events: + * - {@link assign} + * - {@link clear} + * - {@link erase} + * - {@link extract} + * - *refresh* typed events: + * - {@link refresh} * + * #### [Inherited] {@link HashSet} + * {@link HashSet HashSets} are containers that store unique elements in no particular order, and which allow for + * fast retrieval of individual elements based on their value. + * + * In an {@link HashSet}, the value of an element is at the same time its *key*, that identifies it uniquely. + * Keys are immutable, therefore, the elements in an {@link HashSet} cannot be modified once in the container - + * they can be inserted and removed, though. + * + * Internally, the elements in the {@link HashSet} are not sorted in any particular order, but organized into + * buckets depending on their hash values to allow for fast access to individual elements directly by their + * *values* (with a constant average time complexity on average). + * + * {@link HashSet} containers are faster than {@link TreeSet} containers to access individual elements by their + * *key*, although they are generally less efficient for range iteration through a subset of their elements. + * + * + * + * + * + *

Container properties

+ *
+ *
Associative
+ *
Elements in associative containers are referenced by their *key* and not by their absolute + * position in the container.
+ * + *
Hashed
+ *
Hashed containers organize their elements using hash tables that allow for fast access to elements + * by their *key*.
+ * + *
Set
+ *
The value of an element is also the *key* used to identify it.
+ * + *
Unique keys
+ *
No two elements in the container can have equivalent *keys*.
+ *
+ * + * @param Type of the elements. + * Each element in an {@link HashSet} is also uniquely identified by this value. + * + * @reference http://www.cplusplus.com/reference/unordered_set/unordered_set + * @handbook [Collections](https://github.com/samchon/framework/wiki/TypeScript-STL#collections) * @author Jeongho Nam */ class HashSetCollection extends std.HashSet implements ICollection { @@ -754,75 +1025,73 @@ declare namespace samchon.collection { removeEventListener(type: "refresh", listener: CollectionEventListener, thisArg: Object): void; } } -declare namespace samchon.collection { +declare namespace samchon.collections { /** * An interface for {@link IContainer containers} who can detect element I/O events. * - *

Below are list of methods who are dispatching {@link CollectionEvent}:

- * - *