, library.IEventDispatcher {
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: string, listener: EventListener): void;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: string, listener: EventListener, thisArg: Object): void;
+ /**
+ * Registers an event listener object with an EventDispatcher object so that the listener
+ * receives notification of an event. You can register event listeners on all nodes in the display
+ * list for a specific type of event, phase, and priority.
+ *
+ *
After you successfully register an event listener, you cannot change its priority through
+ * additional calls to addEventListener(). To change a listener's priority, you must first call
+ * removeEventListener(). Then you can register the listener again with the new priority level.
+ *
+ * Keep in mind that after the listener is registered, subsequent calls to addEventListener()
+ * with a different type or useCapture value result in the creation of a separate listener
+ * registration. For example, if you first register a listener with useCapture set to true,
+ * it listens only during the capture phase. If you call addEventListener() again using the same
+ * listener object, but with useCapture set to false, you have two separate listeners: one that
+ * listens during the capture phase and another that listens during the target and bubbling phases.
+ *
+ * You cannot register an event listener for only the target phase or the bubbling phase.
+ * Those phases are coupled during registration because bubbling applies only to the ancestors of
+ * the target node.
+ *
+ * If you no longer need an event listener, remove it by calling removeEventListener(), or
+ * memory problems could result. Event listeners are not automatically removed from memory because
+ * the garbage collector does not remove the listener as long as the dispatching object exists
+ * (unless the useWeakReference parameter is set to true).
+ *
+ * Copying an EventDispatcher instance does not copy the event listeners attached to it. (If
+ * your newly created node needs an event listener, you must attach the listener after creating
+ * the node.) However, if you move an EventDispatcher instance, the event listeners attached to
+ * it move along with it.
+ *
+ * If the event listener is being registered on a node while an event is also being processed
+ * on this node, the event listener is not triggered during the current phase but may be triggered
+ * during a later phase in the event flow, such as the bubbling phase.
+ *
+ * If an event listener is removed from a node while an event is being processed on the node,
+ * it is still triggered by the current actions. After it is removed, the event listener is never
+ * invoked again (unless it is registered again for future processing).
+ *
+ * @param event The type of event; {@link CollectionEvent.INSERT} or {@link CollectionEvent.ERASE}.
+ * @param listener The listener function that processes the event.
+ * This function must accept an Event object as its only parameter and must return
+ * nothing.
+ */
+ addEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
+ /**
+ * Registers an event listener object with an EventDispatcher object so that the listener
+ * receives notification of an event. You can register event listeners on all nodes in the display
+ * list for a specific type of event, phase, and priority.
+ *
+ *
After you successfully register an event listener, you cannot change its priority through
+ * additional calls to addEventListener(). To change a listener's priority, you must first call
+ * removeEventListener(). Then you can register the listener again with the new priority level.
+ *
+ * Keep in mind that after the listener is registered, subsequent calls to addEventListener()
+ * with a different type or useCapture value result in the creation of a separate listener
+ * registration. For example, if you first register a listener with useCapture set to true,
+ * it listens only during the capture phase. If you call addEventListener() again using the same
+ * listener object, but with useCapture set to false, you have two separate listeners: one that
+ * listens during the capture phase and another that listens during the target and bubbling phases.
+ *
+ * You cannot register an event listener for only the target phase or the bubbling phase.
+ * Those phases are coupled during registration because bubbling applies only to the ancestors of
+ * the target node.
+ *
+ * If you no longer need an event listener, remove it by calling removeEventListener(), or
+ * memory problems could result. Event listeners are not automatically removed from memory because
+ * the garbage collector does not remove the listener as long as the dispatching object exists
+ * (unless the useWeakReference parameter is set to true).
+ *
+ * Copying an EventDispatcher instance does not copy the event listeners attached to it. (If
+ * your newly created node needs an event listener, you must attach the listener after creating
+ * the node.) However, if you move an EventDispatcher instance, the event listeners attached to
+ * it move along with it.
+ *
+ * If the event listener is being registered on a node while an event is also being processed
+ * on this node, the event listener is not triggered during the current phase but may be triggered
+ * during a later phase in the event flow, such as the bubbling phase.
+ *
+ * If an event listener is removed from a node while an event is being processed on the node,
+ * it is still triggered by the current actions. After it is removed, the event listener is never
+ * invoked again (unless it is registered again for future processing).
+ *
+ * @param event The type of event; {@link CollectionEvent.INSERT} or {@link CollectionEvent.ERASE}.
+ * @param listener The listener function that processes the event.
+ * This function must accept an Event object as its only parameter and must return
+ * nothing.
+ */
+ addEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: string, listener: EventListener): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: string, listener: EventListener, thisArg: Object): void;
+ /**
+ * Removes a listener from the EventDispatcher object. If there is no matching listener registered
+ * with the EventDispatcher object, a call to this method has no effect.
+ *
+ * @param type The type of event; {@link CollectionEvent.INSERT} or {@link CollectionEvent.ERASE}.
+ * @param listener The listener object to remove.
+ */
+ removeEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
+ /**
+ * Removes a listener from the EventDispatcher object. If there is no matching listener registered
+ * with the EventDispatcher object, a call to this method has no effect.
+ *
+ * @param type The type of event; {@link CollectionEvent.INSERT} or {@link CollectionEvent.ERASE}.
+ * @param listener The listener object to remove.
+ */
+ removeEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
+ }
+}
+declare namespace samchon.collection {
+ /**
+ * A {@link List} who can detect element I/O events.
+ *
+ * @author Jeongho Nam
+ */
+ class ListCollection extends std.List implements ICollection {
+ /**
+ * A chain object taking responsibility of dispatching events.
+ */
+ private event_dispatcher_;
+ /**
+ * @inheritdoc
+ */
+ push(...items: T[]): number;
+ /**
+ * @inheritdoc
+ */
+ push_front(val: T): void;
+ /**
+ * @inheritdoc
+ */
+ push_back(val: T): void;
+ /**
+ * @hidden
+ */
+ protected insert_by_repeating_val(position: std.ListIterator, n: number, val: T): std.ListIterator;
+ /**
+ * @hidden
+ */
+ protected insert_by_range>(position: std.ListIterator, begin: InputIterator, end: InputIterator): std.ListIterator;
+ /**
+ * @inheritdoc
+ */
+ pop_front(): void;
+ /**
+ * @inheritdoc
+ */
+ pop_back(): void;
+ /**
+ * @hidden
+ */
+ protected erase_by_range(first: std.ListIterator, last: std.ListIterator): std.ListIterator;
+ /**
+ * @hidden
+ */
+ private notify_insert(first, last);
+ /**
+ * @hidden
+ */
+ private notify_erase(first, last);
+ /**
+ * @inheritdoc
+ */
+ hasEventListener(type: string): boolean;
+ /**
+ * @inheritdoc
+ */
+ dispatchEvent(event: Event): boolean;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: string, listener: EventListener): void;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: string, listener: EventListener, thisArg: Object): void;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: string, listener: EventListener): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: string, listener: EventListener, thisArg: Object): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
+ }
+}
+declare namespace samchon.collection {
+ /**
+ * A {@link TreeMap} who can detect element I/O events.
+ *
+ * @author Jeongho Nam
+ */
+ class TreeMapCollection extends std.HashMap implements ICollection> {
+ /**
+ * A chain object taking responsibility of dispatching events.
+ */
+ private event_dispatcher_;
+ /**
+ * @inheritdoc
+ */
+ protected handle_insert(first: std.MapIterator, last: std.MapIterator): void;
+ /**
+ * @inheritdoc
+ */
+ protected handle_erase(first: std.MapIterator, last: std.MapIterator): void;
+ /**
+ * @inheritdoc
+ */
+ hasEventListener(type: string): boolean;
+ /**
+ * @inheritdoc
+ */
+ dispatchEvent(event: Event): boolean;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: string, listener: EventListener): void;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: string, listener: EventListener, thisArg: Object): void;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: string, listener: EventListener): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: string, listener: EventListener, thisArg: Object): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
+ }
+ /**
+ * A {@link TreeMultiMap} who can detect element I/O events.
+ *
+ * @author Jeongho Nam
+ */
+ class TreeMultiMapCollection extends std.HashMap implements ICollection> {
+ /**
+ * A chain object taking responsibility of dispatching events.
+ */
+ private event_dispatcher_;
+ /**
+ * @inheritdoc
+ */
+ protected handle_insert(first: std.MapIterator, last: std.MapIterator): void;
+ /**
+ * @inheritdoc
+ */
+ protected handle_erase(first: std.MapIterator, last: std.MapIterator): void;
+ /**
+ * @inheritdoc
+ */
+ hasEventListener(type: string): boolean;
+ /**
+ * @inheritdoc
+ */
+ dispatchEvent(event: Event): boolean;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: string, listener: EventListener): void;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: string, listener: EventListener, thisArg: Object): void;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: string, listener: EventListener): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: string, listener: EventListener, thisArg: Object): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
+ }
+}
+declare namespace samchon.collection {
+ /**
+ * A {@link TreeMap} who can detect element I/O events.
+ *
+ * @author Jeongho Nam
+ */
+ class TreeSetCollection extends std.TreeSet implements ICollection {
+ /**
+ * A chain object taking responsibility of dispatching events.
+ */
+ private event_dispatcher_;
+ /**
+ * @inheritdoc
+ */
+ hasEventListener(type: string): boolean;
+ /**
+ * @inheritdoc
+ */
+ dispatchEvent(event: Event): boolean;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: string, listener: EventListener): void;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: string, listener: EventListener, thisArg: Object): void;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: string, listener: EventListener): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: string, listener: EventListener, thisArg: Object): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
+ }
+ /**
+ * A {@link TreeMultiSet} who can detect element I/O events.
+ *
+ * @author Jeongho Nam
+ */
+ class TreeMultiSetCollection extends std.TreeMultiSet implements ICollection {
+ /**
+ * A chain object taking responsibility of dispatching events.
+ */
+ private event_dispatcher_;
+ /**
+ * @inheritdoc
+ */
+ protected handle_insert(first: std.SetIterator, last: std.SetIterator): void;
+ /**
+ * @inheritdoc
+ */
+ protected handle_erase(first: std.SetIterator, last: std.SetIterator): void;
+ /**
+ * @inheritdoc
+ */
+ hasEventListener(type: string): boolean;
+ /**
+ * @inheritdoc
+ */
+ dispatchEvent(event: Event): boolean;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: string, listener: EventListener): void;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: string, listener: EventListener, thisArg: Object): void;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
+ /**
+ * @inheritdoc
+ */
+ addEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: string, listener: EventListener): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: string, listener: EventListener, thisArg: Object): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
+ /**
+ * @inheritdoc
+ */
+ removeEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
+ }
+}
declare namespace samchon.library {
/**
* XML is a class representing a tree structued xml objects.
@@ -151,16 +1150,16 @@ declare namespace samchon.library {
/**
* Get value.
*/
- getValue(): any;
+ getValue(): string;
/**
- * Test wheter a property exists or not.
+ * Test whether a property exists or not.
*/
hasProperty(key: string): boolean;
/**
* Get property by its key.
*/
- getProperty(key: string): any;
- getPropertyMap(): std.HashMap;
+ getProperty(key: string): string;
+ getPropertyMap(): std.HashMap;
/**
* Set tag (identifier) of the XML.
*/
@@ -193,11 +1192,11 @@ declare namespace samchon.library {
*
* @param val A value to set
*/
- setValue(str: any): void;
+ setValue(str: string): void;
/**
* Set a property with its key.
*/
- setProperty(key: string, value: any): void;
+ setProperty(key: string, value: string): void;
/**
* Erase a property by its key.
*
@@ -375,10 +1374,6 @@ declare namespace samchon.library {
* @author Jeongho Nam
*/
class XMLList extends std.Vector {
- /**
- * Default Constructor.
- */
- constructor();
getTag(): string;
/**
* Convert XMLList to string.
@@ -395,47 +1390,27 @@ declare namespace samchon.library {
}
}
declare namespace samchon.collection {
- /**
- * A {@link Vector} who can detect element I/O events.
- *
- * @author Jeongho Nam
- */
- class ArrayCollection extends std.Vector implements ICollection {
- private insert_handler_;
- private erase_handler_;
+ class XMLListCollection extends library.XMLList implements ICollection {
+ /**
+ * A chain object taking responsibility of dispatching events.
+ */
private event_dispatcher_;
/**
* @inheritdoc
*/
- set_insert_handler(listener: CollectionHandler): void;
+ push(...items: U[]): number;
/**
* @inheritdoc
*/
- set_erase_handler(listener: CollectionHandler): void;
- /**
- * @inheritdoc
- */
- get_insert_handler(): CollectionHandler;
- /**
- * @inheritdoc
- */
- get_erase_handler(): CollectionHandler;
- /**
- * @inheritdoc
- */
- push(...items: U[]): number;
- /**
- * @inheritdoc
- */
- push_back(val: T): void;
+ push_back(val: library.XML): void;
/**
* @hidden
*/
- protected insert_by_repeating_val(position: std.VectorIterator, n: number, val: T): std.VectorIterator;
+ protected insert_by_repeating_val(position: std.VectorIterator, n: number, val: library.XML): std.VectorIterator;
/**
* @hidden
*/
- protected insert_by_range>(position: std.VectorIterator, begin: InputIterator, end: InputIterator): std.VectorIterator;
+ protected insert_by_range>(position: std.VectorIterator, begin: InputIterator, end: InputIterator): std.VectorIterator;
/**
* @inheritdoc
*/
@@ -443,7 +1418,7 @@ declare namespace samchon.collection {
/**
* @hidden
*/
- protected erase_by_range(first: std.VectorIterator, last: std.VectorIterator): std.VectorIterator;
+ protected erase_by_range(first: std.VectorIterator, last: std.VectorIterator): std.VectorIterator;
/**
* @hidden
*/
@@ -471,11 +1446,11 @@ declare namespace samchon.collection {
/**
* @inheritdoc
*/
- addEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
+ addEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
/**
* @inheritdoc
*/
- addEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
+ addEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
/**
* @inheritdoc
*/
@@ -487,1020 +1462,34 @@ declare namespace samchon.collection {
/**
* @inheritdoc
*/
- removeEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
+ removeEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
/**
* @inheritdoc
*/
- removeEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
+ removeEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
/**
* @inheritdoc
*/
- unshift(...items: U[]): number;
+ unshift(...items: U[]): number;
/**
* @inheritdoc
*/
- pop(): T;
+ pop(): library.XML;
/**
* @inheritdoc
*/
- splice(start: number): T[];
+ splice(start: number): library.XML[];
/**
* @inheritdoc
*/
- splice(start: number, deleteCount: number, ...items: T[]): T[];
+ splice(start: number, deleteCount: number, ...items: library.XML[]): library.XML[];
}
}
-declare namespace samchon.protocol {
- /**
- * An entity, a standard data class.
- *
- * Entity is a class for standardization of expression method using on network I/O by XML. If
- * Invoke is a standard message protocol of Samchon Framework which must be kept, Entity is a
- * recommended semi-protocol of message for expressing a data class. Following the semi-protocol
- * Entity is not imposed but encouraged.
- *
- * As we could get advantages from standardization of message for network I/O with Invoke,
- * we can get additional advantage from standardizing expression method of data class with Entity.
- * We do not need to know a part of network communication. Thus, with the Entity, we can only
- * concentrate on entity's own logics and relationships between another entities. Entity does not
- * need to how network communications are being done.
- *
- * I say repeatedly. Expression method of Entity is recommended, but not imposed. It's a semi
- * protocol for network I/O but not a essential protocol must be kept. The expression method of
- * Entity, using on network I/O, is expressed by XML string.
- *
- * If your own network system has a critical performance issue on communication data class,
- * it would be better to using binary communication (with ByteArray).
- * Don't worry about the problem! Invoke also provides methods for binary data (ByteArray).
- *
- * @author Jeongho Nam
- */
- abstract class Entity implements IEntity {
- /**
- * Default Constructor.
- */
- constructor();
- construct(xml: library.XML): void;
- key(): any;
- abstract TAG(): string;
- toXML(): library.XML;
- }
+declare namespace samchon.example {
+ function test_file_reference(): void;
}
-declare namespace samchon.library {
- /**
- * An event class.
- *
- *
- * - Comments from - https://developer.mozilla.org/en-US/docs/Web/API/Event/
- *
- *
- * @author Jeongho Nam
- */
- class BasicEvent implements Event {
- NONE: number;
- CAPTURING_PHASE: number;
- AT_TARGET: number;
- BUBBLING_PHASE: number;
- private type_;
- private target_;
- private currentTarget_;
- protected trusted_: boolean;
- protected bubbles_: boolean;
- protected cancelable_: boolean;
- protected defaultPrevented_: boolean;
- protected cancelBubble_: boolean;
- private timeStamp_;
- constructor(type: string, bubbles?: boolean, cancelable?: boolean);
- /**
- * @inheritdoc
- */
- initEvent(type: string, bubbles: boolean, cancelable: boolean): void;
- /**
- * @inheritdoc
- */
- preventDefault(): void;
- /**
- * @inheritdoc
- */
- stopImmediatePropagation(): void;
- /**
- * @inheritdoc
- */
- stopPropagation(): void;
- /**
- * @inheritdoc
- */
- type: string;
- /**
- * @inheritdoc
- */
- target: IEventDispatcher;
- /**
- * @inheritdoc
- */
- currentTarget: IEventDispatcher;
- /**
- * @inheritdoc
- */
- isTrusted: boolean;
- /**
- * @inheritdoc
- */
- bubbles: boolean;
- /**
- * @inheritdoc
- */
- cancelable: boolean;
- /**
- * @inheritdoc
- */
- eventPhase: number;
- /**
- * @inheritdoc
- */
- defaultPrevented: boolean;
- /**
- * @inheritdoc
- */
- srcElement: Element;
- /**
- * @inheritdoc
- */
- cancelBubble: boolean;
- /**
- * @inheritdoc
- */
- timeStamp: number;
- /**
- * Don't know what it is.
- */
- returnValue: boolean;
- }
- class ProgressEvent extends BasicEvent {
- static PROGRESS: string;
- protected numerator_: number;
- protected denominator_: number;
- constructor(type: string, numerator: number, denominator: number);
- numerator: number;
- denominator: number;
- }
-}
-declare namespace samchon.collection {
- interface CollectionEventListener extends EventListener {
- (event: CollectionEvent): void;
- }
- class CollectionEvent extends library.BasicEvent {
- static INSERT: string;
- static ERASE: string;
- private first_;
- private last_;
- constructor(type: string, first: std.Iterator, last: std.Iterator);
- container: ICollection;
- first: std.Iterator;
- last: std.Iterator;
- }
-}
-declare namespace samchon.collection {
- /**
- * A {@link Deque} who can detect element I/O events.
- *
- * @author Jeongho Nam
- */
- class DequeCollection extends std.Deque implements ICollection {
- private insert_handler_;
- private erase_handler_;
- private event_dispatcher_;
- /**
- * @inheritdoc
- */
- set_insert_handler(listener: CollectionHandler): void;
- /**
- * @inheritdoc
- */
- set_erase_handler(listener: CollectionHandler): void;
- /**
- * @inheritdoc
- */
- get_insert_handler(): CollectionHandler;
- /**
- * @inheritdoc
- */
- get_erase_handler(): CollectionHandler;
- /**
- * @inheritdoc
- */
- push(...items: U[]): number;
- /**
- * @inheritdoc
- */
- push_back(val: T): void;
- /**
- * @hidden
- */
- protected insert_by_repeating_val(position: std.DequeIterator, n: number, val: T): std.DequeIterator;
- /**
- * @hidden
- */
- protected insert_by_range>(position: std.DequeIterator, begin: InputIterator, end: InputIterator): std.DequeIterator;
- /**
- * @inheritdoc
- */
- pop_back(): void;
- /**
- * @hidden
- */
- protected erase_by_range(first: std.DequeIterator, last: std.DequeIterator): std.DequeIterator;
- /**
- * @hidden
- */
- private notify_insert(first, last);
- /**
- * @hidden
- */
- private notify_erase(first, last);
- /**
- * @inheritdoc
- */
- hasEventListener(type: string): boolean;
- /**
- * @inheritdoc
- */
- dispatchEvent(event: Event): boolean;
- /**
- * @inheritdoc
- */
- addEventListener(type: string, listener: EventListener): void;
- /**
- * @inheritdoc
- */
- addEventListener(type: string, listener: EventListener, thisArg: Object): void;
- /**
- * @inheritdoc
- */
- addEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
- /**
- * @inheritdoc
- */
- addEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
- /**
- * @inheritdoc
- */
- removeEventListener(type: string, listener: EventListener): void;
- /**
- * @inheritdoc
- */
- removeEventListener(type: string, listener: EventListener, thisArg: Object): void;
- /**
- * @inheritdoc
- */
- removeEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
- /**
- * @inheritdoc
- */
- removeEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
- }
-}
-declare namespace samchon.collection {
- /**
- * A {@link HashMap} who can detect element I/O events.
- *
- * @author Jeongho Nam
- */
- class HashMapCollection extends std.HashMap implements ICollection> {
- private insert_handler_;
- private erase_handler_;
- private event_dispatcher_;
- /**
- * @inheritdoc
- */
- get_insert_handler(): MapCollectionHandler;
- /**
- * @inheritdoc
- */
- get_erase_handler(): MapCollectionHandler;
- /**
- * @inheritdoc
- */
- set_insert_handler(listener: MapCollectionHandler): void;
- /**
- * @inheritdoc
- */
- set_erase_handler(listener: MapCollectionHandler): void;
- /**
- * @inheritdoc
- */
- protected handle_insert(first: std.MapIterator, last: std.MapIterator): void;
- /**
- * @inheritdoc
- */
- protected handle_erase(first: std.MapIterator, last: std.MapIterator): void;
- /**
- * @inheritdoc
- */
- hasEventListener(type: string): boolean;
- /**
- * @inheritdoc
- */
- dispatchEvent(event: Event): boolean;
- /**
- * @inheritdoc
- */
- addEventListener(type: string, listener: EventListener): void;
- /**
- * @inheritdoc
- */
- addEventListener(type: string, listener: EventListener, thisArg: Object): void;
- /**
- * @inheritdoc
- */
- addEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
- /**
- * @inheritdoc
- */
- addEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
- /**
- * @inheritdoc
- */
- removeEventListener(type: string, listener: EventListener): void;
- /**
- * @inheritdoc
- */
- removeEventListener(type: string, listener: EventListener, thisArg: Object): void;
- /**
- * @inheritdoc
- */
- removeEventListener(type: "insert" | "erase", listener: CollectionEventListener): void;
- /**
- * @inheritdoc
- */
- removeEventListener(type: "insert" | "erase", listener: CollectionEventListener, thisArg: Object): void;
- }
- /**
- * A {@link HashMultiMap} who can detect element I/O events.
- *
- * @author Jeongho Nam
- */
- class HashMultiMapCollection extends std.HashMap implements ICollection> {
- private insert_handler_;
- private erase_handler_;
- private event_dispatcher_;
- /**
- * @inheritdoc
- */
- get_insert_handler(): MapCollectionHandler;
- /**
- * @inheritdoc
- */
- get_erase_handler(): MapCollectionHandler;
- /**
- * @inheritdoc
- */
- set_insert_handler(listener: MapCollectionHandler): void;
- /**
- * @inheritdoc
- */
- set_erase_handler(listener: MapCollectionHandler): void;
- /**
- * @inheritdoc
- */
- protected handle_insert(first: std.MapIterator, last: std.MapIterator): void;
- /**
- * @inheritdoc
- */
- protected handle_erase(first: std.MapIterator, last: std.MapIterator