mirror of
https://github.com/zhigang1992/DefinitelyTyped.git
synced 2026-04-24 05:06:02 +08:00
6448 lines
248 KiB
TypeScript
6448 lines
248 KiB
TypeScript
// Type definitions for Samchon Framework v2.0.0-beta.8
|
||
// Project: https://github.com/samchon/framework
|
||
// Definitions by: Jeongho Nam <http://samchon.org>
|
||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||
|
||
/// <reference types="typescript-stl" />
|
||
|
||
declare module "samchon-framework"
|
||
{
|
||
export = samchon;
|
||
}
|
||
|
||
/**
|
||
* <h1> Samchon-Framework </h1>
|
||
*
|
||
* <p> <a href="https://nodei.co/npm/samchon-framework">
|
||
* <img src="https://nodei.co/npm/samchon-framework.png?downloads=true&downloadRank=true&stars=true"> </a> </p>
|
||
*
|
||
* <p> Samchon, a SDN (Software Defined Network) framework. </p>
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> 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). </p>
|
||
*
|
||
* @git https://github.com/samchon/framework
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
declare namespace samchon {
|
||
/**
|
||
* <p> Running on Node. </p>
|
||
*
|
||
* <p> Test whether the JavaScript is running on Node. </p>
|
||
*
|
||
* @references http://stackoverflow.com/questions/17575790/environment-detection-node-js-or-browser
|
||
*/
|
||
function is_node(): boolean;
|
||
}
|
||
declare namespace samchon.collection {
|
||
/**
|
||
* A {@link Vector} who can detect element I/O events.
|
||
*
|
||
* <ul>
|
||
* <li> <i>insert</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link insert} </li>
|
||
* <li> {@link push} </li>
|
||
* <li> {@link push_back} </li>
|
||
* <li> {@link unshift} </li>
|
||
* </ul></li>
|
||
* <li> <i>erase</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link clear} </li>
|
||
* <li> {@link erase} </li>
|
||
* <li> {@link pop_back} </li>
|
||
* <li> {@link shift} </li>
|
||
* <li> {@link pop} </li>
|
||
* <li> {@link splice} </li>
|
||
* </ul></li>
|
||
* <li> <i>erase</i> typed events: <ul>
|
||
* <li> {@link sort} </li>
|
||
* </ul></li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class ArrayCollection<T> extends std.Vector<T> implements ICollection<T> {
|
||
/**
|
||
* A chain object taking responsibility of dispatching events.
|
||
*/
|
||
private event_dispatcher_;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
push<U extends T>(...items: U[]): number;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
push_back(val: T): void;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
protected _Insert_by_repeating_val(position: std.VectorIterator<T>, n: number, val: T): std.VectorIterator<T>;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
protected _Insert_by_range<U extends T, InputIterator extends std.Iterator<U>>(position: std.VectorIterator<T>, begin: InputIterator, end: InputIterator): std.VectorIterator<T>;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
protected _Erase_by_range(first: std.VectorIterator<T>, last: std.VectorIterator<T>): std.VectorIterator<T>;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private notify_insert(first, last);
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private notify_erase(first, last);
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
hasEventListener(type: string): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
dispatchEvent(event: library.BasicEvent): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(it: std.VectorIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(first: std.VectorIterator<T>, last: std.VectorIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener): void;
|
||
addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
|
||
addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
|
||
addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener): void;
|
||
removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
|
||
removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
|
||
removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
unshift<U extends T>(...items: U[]): number;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
pop(): T;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
splice(start: number): T[];
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
splice(start: number, deleteCount: number, ...items: T[]): T[];
|
||
}
|
||
}
|
||
declare namespace samchon.library {
|
||
/**
|
||
* A basic event class of Samchon Framework.
|
||
*
|
||
* @reference https://developer.mozilla.org/en-US/docs/Web/API/Event
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class BasicEvent {
|
||
protected type_: string;
|
||
protected target_: IEventDispatcher;
|
||
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
|
||
*/
|
||
/**
|
||
* @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;
|
||
}
|
||
}
|
||
declare namespace samchon.collection {
|
||
/**
|
||
* Type of function pointer for listener of {@link CollectionEvent CollectionEvents}.
|
||
*/
|
||
type CollectionEventListener<T> = (event: CollectionEvent<T>) => void;
|
||
}
|
||
declare namespace samchon.collection {
|
||
/**
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class CollectionEvent<T> extends library.BasicEvent {
|
||
/**
|
||
* @hidden
|
||
*/
|
||
protected first_: std.Iterator<T>;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
protected last_: std.Iterator<T>;
|
||
private temporary_container_;
|
||
private origin_first_;
|
||
/**
|
||
* Initialization Constructor.
|
||
*
|
||
* @param type Type of collection event.
|
||
* @param first
|
||
* @param last
|
||
*/
|
||
constructor(type: string, first: std.Iterator<T>, last: std.Iterator<T>);
|
||
constructor(type: "insert", first: std.Iterator<T>, last: std.Iterator<T>);
|
||
constructor(type: "erase", first: std.Iterator<T>, last: std.Iterator<T>);
|
||
constructor(type: "refresh", first: std.Iterator<T>, last: std.Iterator<T>);
|
||
/**
|
||
* Get associative target, the container.
|
||
*/
|
||
target: ICollection<T>;
|
||
/**
|
||
* Get range of the first.
|
||
*/
|
||
first: std.Iterator<T>;
|
||
/**
|
||
* Get range of the last.
|
||
*/
|
||
last: std.Iterator<T>;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
preventDefault(): void;
|
||
}
|
||
}
|
||
/**
|
||
* @hidden
|
||
*/
|
||
declare namespace samchon.collection.CollectionEvent {
|
||
const INSERT: "insert";
|
||
const ERASE: "erase";
|
||
const REFRESH: "refresh";
|
||
}
|
||
declare namespace samchon.collection {
|
||
/**
|
||
* A {@link Deque} who can detect element I/O events.
|
||
*
|
||
* <p> Below are list of methods who are dispatching {@link CollectionEvent}: </p>
|
||
*
|
||
* <ul>
|
||
* <li> <i>insert</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link insert} </li>
|
||
* <li> {@link push} </li>
|
||
* <li> {@link push_front} </li>
|
||
* <li> {@link push_back} </li>
|
||
* </ul></li>
|
||
* <li> <i>erase</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link clear} </li>
|
||
* <li> {@link erase} </li>
|
||
* <li> {@link pop_front} </li>
|
||
* <li> {@link pop_back} </li>
|
||
* </ul></li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class DequeCollection<T> extends std.Deque<T> implements ICollection<T> {
|
||
/**
|
||
* A chain object taking responsibility of dispatching events.
|
||
*/
|
||
private event_dispatcher_;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
push<U extends T>(...items: U[]): number;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
push_back(val: T): void;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
protected _Insert_by_repeating_val(position: std.DequeIterator<T>, n: number, val: T): std.DequeIterator<T>;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
protected _Insert_by_range<U extends T, InputIterator extends std.Iterator<U>>(position: std.DequeIterator<T>, begin: InputIterator, end: InputIterator): std.DequeIterator<T>;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
pop_back(): void;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
protected _Erase_by_range(first: std.DequeIterator<T>, last: std.DequeIterator<T>): std.DequeIterator<T>;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private notify_insert(first, last);
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private notify_erase(first, last);
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
hasEventListener(type: string): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
dispatchEvent(event: library.BasicEvent): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(it: std.DequeIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(first: std.DequeIterator<T>, last: std.DequeIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener): void;
|
||
addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
|
||
addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
|
||
addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener): void;
|
||
removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
|
||
removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
|
||
removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
}
|
||
}
|
||
declare namespace samchon.collection {
|
||
/**
|
||
* A {@link HashMap} who can detect element I/O events.
|
||
*
|
||
* <ul>
|
||
* <li> <i>insert</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link insert} </li>
|
||
* <li> {@link push} </li>
|
||
* <li> {@link set} </li>
|
||
* <li> {@link insert_or_assign} </li>
|
||
* </ul></li>
|
||
* <li> <i>erase</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link clear} </li>
|
||
* <li> {@link erase} </li>
|
||
* <li> {@link extract} </li>
|
||
* </ul></li>
|
||
* <li> <i>refresh</i> typed events: <ul>
|
||
* <li> {@link set} </li>
|
||
* <li> {@link insert_or_assign} </li>
|
||
* </ul></li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class HashMapCollection<Key, T> extends std.HashMap<Key, T> implements ICollection<std.Pair<Key, T>> {
|
||
/**
|
||
* A chain object taking responsibility of dispatching events.
|
||
*/
|
||
private event_dispatcher_;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected _Handle_insert(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected _Handle_erase(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
hasEventListener(type: string): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
dispatchEvent(event: library.BasicEvent): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(it: std.MapIterator<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener): void;
|
||
addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
|
||
addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
|
||
addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener): void;
|
||
removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
|
||
removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
|
||
removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
}
|
||
}
|
||
declare namespace samchon.collection {
|
||
/**
|
||
* A {@link HashMultiMap} who can detect element I/O events.
|
||
*
|
||
* <ul>
|
||
* <li> <i>insert</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link insert} </li>
|
||
* <li> {@link push} </li>
|
||
* </ul></li>
|
||
* <li> <i>erase</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link clear} </li>
|
||
* <li> {@link erase} </li>
|
||
* </ul></li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class HashMultiMapCollection<Key, T> extends std.HashMap<Key, T> implements ICollection<std.Pair<Key, T>> {
|
||
/**
|
||
* A chain object taking responsibility of dispatching events.
|
||
*/
|
||
private event_dispatcher_;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected _Handle_insert(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected _Handle_erase(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
hasEventListener(type: string): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
dispatchEvent(event: library.BasicEvent): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(it: std.MapIterator<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener): void;
|
||
addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
|
||
addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
|
||
addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener): void;
|
||
removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
|
||
removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
|
||
removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
}
|
||
}
|
||
declare namespace samchon.collection {
|
||
/**
|
||
* A {@link HashMultiSet} who can detect element I/O events.
|
||
*
|
||
* <ul>
|
||
* <li> <i>insert</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link insert} </li>
|
||
* <li> {@link push} </li>
|
||
* </ul></li>
|
||
* <li> <i>erase</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link clear} </li>
|
||
* <li> {@link erase} </li>
|
||
* </ul></li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class HashMultiSetCollection<T> extends std.HashMultiSet<T> implements ICollection<T> {
|
||
/**
|
||
* A chain object taking responsibility of dispatching events.
|
||
*/
|
||
private event_dispatcher_;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected _Handle_insert(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected _Handle_erase(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
hasEventListener(type: string): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
dispatchEvent(event: library.BasicEvent): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(it: std.SetIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener): void;
|
||
addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
|
||
addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
|
||
addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener): void;
|
||
removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
|
||
removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
|
||
removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
}
|
||
}
|
||
declare namespace samchon.collection {
|
||
/**
|
||
* A {@link HashSet} who can detect element I/O events.
|
||
*
|
||
* <ul>
|
||
* <li> <i>insert</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link insert} </li>
|
||
* <li> {@link push} </li>
|
||
* </ul></li>
|
||
* <li> <i>erase</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link clear} </li>
|
||
* <li> {@link erase} </li>
|
||
* <li> {@link extract} </li>
|
||
* </ul></li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class HashSetCollection<T> extends std.HashSet<T> implements ICollection<T> {
|
||
/**
|
||
* A chain object taking responsibility of dispatching events.
|
||
*/
|
||
private event_dispatcher_;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected _Handle_insert(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected _Handle_erase(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
hasEventListener(type: string): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
dispatchEvent(event: library.BasicEvent): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(it: std.SetIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener): void;
|
||
addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
|
||
addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
|
||
addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener): void;
|
||
removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
|
||
removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
|
||
removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
}
|
||
}
|
||
declare namespace samchon.collection {
|
||
/**
|
||
* An interface for {@link IContainer containers} who can detect element I/O events.
|
||
*
|
||
* <p> Below are list of methods who are dispatching {@link CollectionEvent}: </p>
|
||
*
|
||
* <ul>
|
||
* <li> <i>insert</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link insert} </li>
|
||
* <li> {@link push} </li>
|
||
* </ul></li>
|
||
* <li> <i>erase</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link clear} </li>
|
||
* <li> {@link erase} </li>
|
||
* </ul></li>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
interface ICollection<T> extends std.base.IContainer<T>, library.IEventDispatcher {
|
||
/**
|
||
* <p> Dispatch a {@link CollectionEvent} with <i>refresh</i> typed. </p>
|
||
*
|
||
* <p> {@link ICollection} dispatches {@link CollectionEvent} typed <i>insert</i> or <i>erase</i> whenever
|
||
* elements I/O has occured. However, unlike those elements I/O events, content change in element level can't be
|
||
* detected. There's no way to detect those events automatically by {@link IContainer}. </p>
|
||
*
|
||
* <p> If you want to dispatch those typed events (notifying change on contents in element level), you've to
|
||
* dispatch <i>refresh</i> typed event manually, by yourself. Call {@link refresh refresh()} with specified
|
||
* iterators who're pointing the elements whose content have changed. Then a {@link CollectionEvent} with
|
||
* <i>refresh</i> typed will be dispatched. </p>
|
||
*
|
||
* <p> If you don't specify any iterator, then the range of the <i>refresh<i> event will be all elements in this
|
||
* {@link ICollection collection}; {@link begin begin()} to {@link end end()}. </p>
|
||
*/
|
||
refresh(): void;
|
||
/**
|
||
* <p> Dispatch a {@link CollectionEvent} with <i>refresh</i> typed. </p>
|
||
*
|
||
* <p> {@link ICollection} dispatches {@link CollectionEvent} typed <i>insert</i> or <i>erase</i> whenever
|
||
* elements I/O has occured. However, unlike those elements I/O events, content change in element level can't be
|
||
* detected. There's no way to detect those events automatically by {@link IContainer}. </p>
|
||
*
|
||
* <p> If you want to dispatch those typed events (notifying change on contents in element level), you've to
|
||
* dispatch <i>refresh</i> typed event manually, by yourself. Call {@link refresh refresh()} with specified
|
||
* iterators who're pointing the elements whose content have changed. Then a {@link CollectionEvent} with
|
||
* <i>refresh</i> typed will be dispatched. </p>
|
||
*
|
||
* @param it An iterator targeting the content changed element.
|
||
*/
|
||
refresh(it: std.Iterator<T>): void;
|
||
/**
|
||
* <p> Dispatch a {@link CollectionEvent} with <i>refresh</i> typed. </p>
|
||
*
|
||
* <p> {@link ICollection} dispatches {@link CollectionEvent} typed <i>insert</i> or <i>erase</i> whenever
|
||
* elements I/O has occured. However, unlike those elements I/O events, content change in element level can't be
|
||
* detected. There's no way to detect those events automatically by {@link IContainer}. </p>
|
||
*
|
||
* <p> If you want to dispatch those typed events (notifying change on contents in element level), you've to
|
||
* dispatch <i>refresh</i> typed event manually, by yourself. Call {@link refresh refresh()} with specified
|
||
* iterators who're pointing the elements whose content have changed. Then a {@link CollectionEvent} with
|
||
* <i>refresh</i> typed will be dispatched. </p>
|
||
*
|
||
* @param first An Iterator to the initial position in a sequence of the content changed elmeents.
|
||
* @param last An {@link Iterator} to the final position in a sequence of the content changed elements. The range
|
||
* used is [<i>first</i>, <i>last</i>), which contains all the elements between <i>first</i> and
|
||
* <i>last</i>, including the element pointed by <i>first</i> but not the element pointed by
|
||
* <i>last</i>.
|
||
*/
|
||
refresh(first: std.Iterator<T>, last: std.Iterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener): void;
|
||
addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
|
||
addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
|
||
addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener): void;
|
||
removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
|
||
removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
|
||
removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
}
|
||
/**
|
||
* @hidden
|
||
*/
|
||
namespace ICollection {
|
||
function _Dispatch_CollectionEvent<T>(collection: ICollection<T>, type: string, first: std.Iterator<T>, last: std.Iterator<T>): void;
|
||
function _Dispatch_MapCollectionEvent<Key, T>(collection: ICollection<std.Pair<Key, T>>, type: string, first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
|
||
}
|
||
}
|
||
declare namespace samchon.collection {
|
||
/**
|
||
* A {@link List} who can detect element I/O events.
|
||
*
|
||
* <ul>
|
||
* <li> <i>insert</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link insert} </li>
|
||
* <li> {@link push} </li>
|
||
* <li> {@link push_front} </li>
|
||
* <li> {@link push_back} </li>
|
||
* <li> {@link merge} </li>
|
||
* </ul></li>
|
||
* <li> <i>erase</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link clear} </li>
|
||
* <li> {@link erase} </li>
|
||
* <li> {@link pop_front} </li>
|
||
* <li> {@link pop_back} </li>
|
||
* <li> {@link unique} </li>
|
||
* <li> {@link remove} </li>
|
||
* <li> {@link remove_if} </li>
|
||
* <li> {@link splice} </li>
|
||
* </ul></li>
|
||
* <li> <i>erase</i> typed events: <ul>
|
||
* <li> {@link sort} </li>
|
||
* </ul></li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class ListCollection<T> extends std.List<T> implements ICollection<T> {
|
||
/**
|
||
* A chain object taking responsibility of dispatching events.
|
||
*/
|
||
private event_dispatcher_;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
push<U extends T>(...items: T[]): number;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
push_front(val: T): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
push_back(val: T): void;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
protected _Insert_by_repeating_val(position: std.ListIterator<T>, n: number, val: T): std.ListIterator<T>;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
protected _Insert_by_range<U extends T, InputIterator extends std.Iterator<U>>(position: std.ListIterator<T>, begin: InputIterator, end: InputIterator): std.ListIterator<T>;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
pop_front(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
pop_back(): void;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
protected _Erase_by_range(first: std.ListIterator<T>, last: std.ListIterator<T>): std.ListIterator<T>;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private notify_insert(first, last);
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private notify_erase(first, last);
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
hasEventListener(type: string): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
dispatchEvent(event: library.BasicEvent): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(it: std.ListIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(first: std.ListIterator<T>, last: std.ListIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener): void;
|
||
addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
|
||
addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
|
||
addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener): void;
|
||
removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
|
||
removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
|
||
removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
}
|
||
}
|
||
declare namespace samchon.collection {
|
||
type MapCollectionEventListener<Key, T> = (event: MapCollectionEvent<Key, T>) => void;
|
||
class MapCollectionEvent<Key, T> extends CollectionEvent<std.Pair<Key, T>> {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
first: std.MapIterator<Key, T>;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
last: std.MapIterator<Key, T>;
|
||
}
|
||
}
|
||
declare namespace samchon.collection {
|
||
/**
|
||
* A {@link TreeMap} who can detect element I/O events.
|
||
*
|
||
* <ul>
|
||
* <li> <i>insert</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link insert} </li>
|
||
* <li> {@link push} </li>
|
||
* <li> {@link set} </li>
|
||
* <li> {@link insert_or_assign} </li>
|
||
* </ul></li>
|
||
* <li> <i>erase</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link clear} </li>
|
||
* <li> {@link erase} </li>
|
||
* <li> {@link extract} </li>
|
||
* </ul></li>
|
||
* <li> <i>refresh</i> typed events: <ul>
|
||
* <li> {@link set} </li>
|
||
* <li> {@link insert_or_assign} </li>
|
||
* </ul></li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class TreeMapCollection<Key, T> extends std.TreeMap<Key, T> implements ICollection<std.Pair<Key, T>> {
|
||
/**
|
||
* A chain object taking responsibility of dispatching events.
|
||
*/
|
||
private event_dispatcher_;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected _Handle_insert(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected _Handle_erase(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
hasEventListener(type: string): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
dispatchEvent(event: library.BasicEvent): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(it: std.MapIterator<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener): void;
|
||
addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
|
||
addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
|
||
addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener): void;
|
||
removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
|
||
removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
|
||
removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
}
|
||
}
|
||
declare namespace samchon.collection {
|
||
/**
|
||
* A {@link TreeMultiMap} who can detect element I/O events.
|
||
*
|
||
* <ul>
|
||
* <li> <i>insert</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link insert} </li>
|
||
* <li> {@link push} </li>
|
||
* </ul></li>
|
||
* <li> <i>erase</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link clear} </li>
|
||
* <li> {@link erase} </li>
|
||
* </ul></li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class TreeMultiMapCollection<Key, T> extends std.TreeMultiMap<Key, T> implements ICollection<std.Pair<Key, T>> {
|
||
/**
|
||
* A chain object taking responsibility of dispatching events.
|
||
*/
|
||
private event_dispatcher_;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected _Handle_insert(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected _Handle_erase(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
hasEventListener(type: string): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
dispatchEvent(event: library.BasicEvent): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(it: std.MapIterator<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(first: std.MapIterator<Key, T>, last: std.MapIterator<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener): void;
|
||
addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
|
||
addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
|
||
addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
addEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
addEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
addEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener): void;
|
||
removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>): void;
|
||
removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>): void;
|
||
removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
removeEventListener(type: "insert", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
removeEventListener(type: "erase", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
removeEventListener(type: "refresh", listener: MapCollectionEventListener<Key, T>, thisArg: Object): void;
|
||
}
|
||
}
|
||
declare namespace samchon.collection {
|
||
/**
|
||
* A {@link TreeMultiSet} who can detect element I/O events.
|
||
*
|
||
* <ul>
|
||
* <li> <i>insert</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link insert} </li>
|
||
* <li> {@link push} </li>
|
||
* </ul></li>
|
||
* <li> <i>erase</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link clear} </li>
|
||
* <li> {@link erase} </li>
|
||
* </ul></li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class TreeMultiSetCollection<T> extends std.TreeMultiSet<T> implements ICollection<T> {
|
||
/**
|
||
* A chain object taking responsibility of dispatching events.
|
||
*/
|
||
private event_dispatcher_;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected _Handle_insert(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected _Handle_erase(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
hasEventListener(type: string): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
dispatchEvent(event: library.BasicEvent): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(it: std.SetIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener): void;
|
||
addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
|
||
addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
|
||
addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener): void;
|
||
removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
|
||
removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
|
||
removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
}
|
||
}
|
||
declare namespace samchon.collection {
|
||
/**
|
||
* A {@link TreeMap} who can detect element I/O events.
|
||
*
|
||
* <ul>
|
||
* <li> <i>insert</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link insert} </li>
|
||
* <li> {@link push} </li>
|
||
* </ul></li>
|
||
* <li> <i>erase</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link clear} </li>
|
||
* <li> {@link erase} </li>
|
||
* <li> {@link extract} </li>
|
||
* </ul></li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class TreeSetCollection<T> extends std.TreeSet<T> implements ICollection<T> {
|
||
/**
|
||
* A chain object taking responsibility of dispatching events.
|
||
*/
|
||
private event_dispatcher_;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected _Handle_insert(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected _Handle_erase(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
hasEventListener(type: string): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
dispatchEvent(event: library.BasicEvent): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(it: std.SetIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(first: std.SetIterator<T>, last: std.SetIterator<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener): void;
|
||
addEventListener(type: "insert", listener: CollectionEventListener<T>): void;
|
||
addEventListener(type: "erase", listener: CollectionEventListener<T>): void;
|
||
addEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
addEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
addEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
addEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener): void;
|
||
removeEventListener(type: "insert", listener: CollectionEventListener<T>): void;
|
||
removeEventListener(type: "erase", listener: CollectionEventListener<T>): void;
|
||
removeEventListener(type: "refresh", listener: CollectionEventListener<T>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
removeEventListener(type: "insert", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
removeEventListener(type: "erase", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
removeEventListener(type: "refresh", listener: CollectionEventListener<T>, thisArg: Object): void;
|
||
}
|
||
}
|
||
declare namespace samchon.library {
|
||
/**
|
||
* <p> XML is a class representing a tree structued xml objects. </p>
|
||
* <p> The XML class provides methods and properties for working with XML objects. </p>
|
||
*
|
||
* <p> The XML class (along with the XMLList and Namespace) implements
|
||
* the powerful XML-handling standard defined in ECMAScript for XML (E4X) specification. </p>
|
||
*
|
||
* <p> XML class has a recursive, hierarchical relationship. </p>
|
||
*
|
||
* <p> Relationships between XML and XMLList </p>
|
||
* <ul>
|
||
* <li> XML is <code>std.HashMap<string, XMLList></code> </li>
|
||
* <li> XMLList is <code>std.Deque<XML></code> </li>
|
||
* </ul>
|
||
*
|
||
* <h4> Note </h4>
|
||
* <p> Do not abuse values for expressing member variables. </p>
|
||
*
|
||
* <table>
|
||
* <tr>
|
||
* <th>Standard Usage</th>
|
||
* <th>Non-standard usage abusing value</th>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>
|
||
* <code>
|
||
* <memberList>
|
||
* <member id='jhnam88' name='Jeongho+Nam' birthdate='1988-03-11' />
|
||
* <member id='master' name='Administartor' birthdate='2011-07-28' />
|
||
* </memberList>
|
||
* </code>
|
||
* </td>
|
||
* <td>
|
||
* <code>
|
||
* <memberList>
|
||
* <member>
|
||
* <id>jhnam88</id>
|
||
* <name>Jeongho Nam</name>
|
||
* <birthdate>1988-03-11</birthdate>
|
||
* </member>
|
||
* <member>
|
||
* <id>master</id>
|
||
* <name>Administartor</name>
|
||
* <birthdate>2011-07-28</birthdate>
|
||
* </member>
|
||
* </memberList>
|
||
* </code>
|
||
* </td>
|
||
* </tr>
|
||
* </table>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class XML extends std.HashMap<string, XMLList> {
|
||
/**
|
||
* <p> Tag name of the XML. </p>
|
||
*
|
||
* <ul>
|
||
* <li> \<<b>tag</b> label='property' /\>: tag => \"tag\" </li>
|
||
* <li> \<<b>price</b> high='1500' low='1300' open='1450' close='1320' /\>: tag => \"price\" </li>
|
||
* </ul>
|
||
*/
|
||
private tag_;
|
||
/**
|
||
* <p> Value of the XML. </p>
|
||
*
|
||
* <ul>
|
||
* <li> \<parameter name='age' type='int'\><b>26</b>\</parameter\>: value => 26 </li>
|
||
* <li> \<price high='1500' low='1300' open='1450' close='1320' /\>: value => null </li>
|
||
* </ul>
|
||
*/
|
||
private value_;
|
||
/**
|
||
* <p> Properties belongs to the XML. </p>
|
||
* <p> A Dictionary of properties accessing each property by its key. </p>
|
||
*
|
||
* <ul>
|
||
* <li> \<price <b>high='1500' low='1300' open='1450' close='1320'</b> /\>:
|
||
* propertyMap => {{\"high\": 1500}, {\"low\": 1300}, {\"open\": 1450}, {\"close\", 1320}} </li>
|
||
* <li> \<member <b>id='jhnam88' name='Jeongho+Nam' comment='Hello.+My+name+is+Jeongho+Nam'</b> \>:
|
||
* propertyMap => {{\"id\", \"jhnam88\"}, {\"name\", \"Jeongho Nam <http://samchon.org>\"},
|
||
* {\"comment\", \"Hello. My name is Jeongho Nam <http://samchon.org>\"}} </li>
|
||
* </ul>
|
||
*/
|
||
private property_map_;
|
||
/**
|
||
* <p> Default Constructor. </p>
|
||
*
|
||
* <p> If the string parameter is not omitted, constructs its tag, value and
|
||
* properties by parsing the string. If there's children, then construct the
|
||
* children XML, XMLList objects, too. </p>
|
||
*
|
||
* @param str A string to be parsed
|
||
*/
|
||
constructor(str?: string);
|
||
/**
|
||
* <p> Construct XML objects by parsing a string. </p>
|
||
*/
|
||
private construct(str);
|
||
/**
|
||
* <p> Parse and fetch a tag. </p>
|
||
*/
|
||
private parseTag(str);
|
||
/**
|
||
* <p> Parse and fetch properties. </p>
|
||
*/
|
||
private parseProperty(str);
|
||
/**
|
||
* <p> Parse and fetch a value. </p>
|
||
*/
|
||
private parseValue(str);
|
||
/**
|
||
* <p> Parse and construct children XML objects. </p>
|
||
*/
|
||
private parseChildren(str);
|
||
/**
|
||
* <p> Get tag. </p>
|
||
*/
|
||
getTag(): string;
|
||
/**
|
||
* <p> Get value. </p>
|
||
*/
|
||
getValue(): string;
|
||
/**
|
||
* <p> Test whether a property exists or not. </p>
|
||
*/
|
||
hasProperty(key: string): boolean;
|
||
/**
|
||
* <p> Get property by its key. </p>
|
||
*/
|
||
getProperty(key: string): string;
|
||
getPropertyMap(): std.HashMap<string, string>;
|
||
/**
|
||
* <p> Set tag (identifier) of the XML. </p>
|
||
*/
|
||
setTag(str: string): void;
|
||
/**
|
||
* <p> Set value of the XML. </p>
|
||
*
|
||
* <p> Do not abuse values for expressing member variables. </p>
|
||
* <table>
|
||
* <tr>
|
||
* <th>Standard Usage</th>
|
||
* <th>Non-standard usage abusing value</th>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>
|
||
* \<memberList\>\n
|
||
* \<member id='jhnam88' name='Jeongho+Nam' birthdate='1988-03-11' /\>\n
|
||
* \<member id='master' name='Administartor' birthdate='2011-07-28' /\>\n
|
||
* \</memberList\>
|
||
* </td>
|
||
* <td>
|
||
* \<member\>\n
|
||
* \<id\>jhnam88\</id\>\n
|
||
* \<name\>Jeongho+Nam\</name\>\n
|
||
* \<birthdate\>1988-03-11\</birthdate\>\n
|
||
* \</member\>
|
||
* </td>
|
||
* </tr>
|
||
* </table>
|
||
*
|
||
* @param val A value to set
|
||
*/
|
||
setValue(str: string): void;
|
||
/**
|
||
* <p> Set a property with its key. </p>
|
||
*/
|
||
setProperty(key: string, value: string): void;
|
||
/**
|
||
* <p> Erase a property by its key. </p>
|
||
*
|
||
* @param key The key of the property to erase
|
||
* @throw exception out of range
|
||
*/
|
||
eraseProperty(key: string): void;
|
||
push<L extends string, U extends XMLList>(...args: std.Pair<L, U>[]): number;
|
||
push<L extends string, U extends XMLList>(...args: [L, U][]): number;
|
||
push(...xmls: XML[]): number;
|
||
push(...xmlLists: XMLList[]): number;
|
||
addAllProperties(xml: XML): void;
|
||
clearProperties(): void;
|
||
private calcMinIndex(...args);
|
||
/**
|
||
* <p> Decode a value. </p>
|
||
*
|
||
* <table>
|
||
* <tr>
|
||
* <th>Encoded</th>
|
||
* <th>Decoded</th>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>\&</td>
|
||
* <td>\&</td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>\<</td>
|
||
* <td>\<</td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>\></td>
|
||
* <td>\></td>
|
||
* </tr>
|
||
* </table>
|
||
*
|
||
* @return A decoded string represents a value
|
||
*/
|
||
static decodeValue(str: string): string;
|
||
/**
|
||
* <p> Encode a value. </p>
|
||
*
|
||
* <table>
|
||
* <tr>
|
||
* <th>Original</th>
|
||
* <th>Encoded</th>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>\&</td>
|
||
* <td>\&</td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>\<</td>
|
||
* <td>\<</td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>\></td>
|
||
* <td>\></td>
|
||
* </tr>
|
||
* </table>
|
||
*
|
||
* @return A encoded string represents a value
|
||
*/
|
||
static encodeValue(str: string): string;
|
||
/**
|
||
* <p> Decode a property. </p>
|
||
*
|
||
* <table>
|
||
* <tr>
|
||
* <th>Encoded</th>
|
||
* <th>Decoded</th>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>\&</td>
|
||
* <td>\&</td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>\<</td>
|
||
* <td>\<</td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>\></td>
|
||
* <td>\></td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>"</td>
|
||
* <td>\"</td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>'</td>
|
||
* <td>'</td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>	</td>
|
||
* <td>'</td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>'</td>
|
||
* <td>\\t</td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>
</td>
|
||
* <td>\\n</td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>
</td>
|
||
* <td>\\r</td>
|
||
* </tr>
|
||
* </table>
|
||
*
|
||
* @return A decoded string represents a property
|
||
*/
|
||
static decodeProperty(str: string): string;
|
||
/**
|
||
* <p> Decode a property. </p>
|
||
*
|
||
* <table>
|
||
* <tr>
|
||
* <th>Original</th>
|
||
* <th>Encoded</th>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>\&</td>
|
||
* <td>\&</td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>\<</td>
|
||
* <td>\<</td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>\></td>
|
||
* <td>\></td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>\"</td>
|
||
* <td>"</td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>'</td>
|
||
* <td>'</td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>'</td>
|
||
* <td>	</td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>\\t</td>
|
||
* <td>'</td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>\\n</td>
|
||
* <td>
</td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td>\\r</td>
|
||
* <td>
</td>
|
||
* </tr>
|
||
* </table>
|
||
*
|
||
* @return A encoded string represents a property
|
||
*/
|
||
static encodeProperty(str: string): string;
|
||
/**
|
||
* <p> Convert the XML to a string. </p>
|
||
*/
|
||
toString(level?: number): string;
|
||
/**
|
||
* <p> Convert the XML to HTML string. </p>
|
||
*/
|
||
toHTML(level?: number): string;
|
||
}
|
||
/**
|
||
* <p> List of XML(s) having same tag. </p>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class XMLList extends std.Deque<XML> {
|
||
getTag(): string;
|
||
/**
|
||
* <p> Convert XMLList to string. </p>
|
||
*
|
||
* @param level Level(depth) of the XMLList.
|
||
*/
|
||
toString(level?: number): string;
|
||
/**
|
||
* <p> Convert XMLList to HTML string. </p>
|
||
*
|
||
* @param level Level(depth) of the XMLList.
|
||
*/
|
||
toHTML(level?: number): string;
|
||
}
|
||
}
|
||
declare namespace samchon.collection {
|
||
/**
|
||
* An {@link XMLList} who can detect element I/O events.
|
||
*
|
||
* <p> Below are list of methods who are dispatching {@link CollectionEvent}: </p>
|
||
*
|
||
* <ul>
|
||
* <li> <i>insert</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link insert} </li>
|
||
* <li> {@link push} </li>
|
||
* <li> {@link push_front} </li>
|
||
* <li> {@link push_back} </li>
|
||
* </ul></li>
|
||
* <li> <i>erase</i> typed events: <ul>
|
||
* <li> {@link assign} </li>
|
||
* <li> {@link clear} </li>
|
||
* <li> {@link erase} </li>
|
||
* <li> {@link pop_front} </li>
|
||
* <li> {@link pop_back} </li>
|
||
* </ul></li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class XMLListCollection extends library.XMLList implements ICollection<library.XML> {
|
||
/**
|
||
* A chain object taking responsibility of dispatching events.
|
||
*/
|
||
private event_dispatcher_;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
push<U extends library.XML>(...items: U[]): number;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
push_back(val: library.XML): void;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
protected _Insert_by_repeating_val(position: std.DequeIterator<library.XML>, n: number, val: library.XML): std.DequeIterator<library.XML>;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
protected _Insert_by_range<U extends library.XML, InputIterator extends std.Iterator<U>>(position: std.DequeIterator<library.XML>, begin: InputIterator, end: InputIterator): std.DequeIterator<library.XML>;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
pop_back(): void;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
protected _Erase_by_range(first: std.DequeIterator<library.XML>, last: std.DequeIterator<library.XML>): std.DequeIterator<library.XML>;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private notify_insert(first, last);
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private notify_erase(first, last);
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
hasEventListener(type: string): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
dispatchEvent(event: library.BasicEvent): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(it: std.DequeIterator<library.XML>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
refresh(first: std.DequeIterator<library.XML>, last: std.DequeIterator<library.XML>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener): void;
|
||
addEventListener(type: "insert", listener: CollectionEventListener<library.XML>): void;
|
||
addEventListener(type: "erase", listener: CollectionEventListener<library.XML>): void;
|
||
addEventListener(type: "refresh", listener: CollectionEventListener<library.XML>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
addEventListener(type: "insert", listener: CollectionEventListener<library.XML>, thisArg: Object): void;
|
||
addEventListener(type: "erase", listener: CollectionEventListener<library.XML>, thisArg: Object): void;
|
||
addEventListener(type: "refresh", listener: CollectionEventListener<library.XML>, thisArg: Object): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener): void;
|
||
removeEventListener(type: "insert", listener: CollectionEventListener<library.XML>): void;
|
||
removeEventListener(type: "erase", listener: CollectionEventListener<library.XML>): void;
|
||
removeEventListener(type: "refresh", listener: CollectionEventListener<library.XML>): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
removeEventListener(type: "insert", listener: CollectionEventListener<library.XML>, thisArg: Object): void;
|
||
removeEventListener(type: "erase", listener: CollectionEventListener<library.XML>, thisArg: Object): void;
|
||
removeEventListener(type: "refresh", listener: CollectionEventListener<library.XML>, thisArg: Object): void;
|
||
}
|
||
}
|
||
declare namespace samchon.library {
|
||
/**
|
||
* <p> Case generator. </p>
|
||
*
|
||
* <p> {@link CaseGenerator} is an abstract case generator being used like a matrix. </p>
|
||
* <ul>
|
||
* <li> n<><6E>r(n^r) -> {@link CombinedPermutationGenerator} </li>
|
||
* <li> nPr -> {@link PermutationGenerator} </li>
|
||
* <li> n! -> {@link FactorialGenerator} </li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
abstract class CaseGenerator {
|
||
/**
|
||
* <p> Size, the number of all cases. </p>
|
||
*/
|
||
protected size_: number;
|
||
/**
|
||
* <p> N, size of the candidates. </p>
|
||
*/
|
||
protected n_: number;
|
||
/**
|
||
* <p> R, size of elements of each case. </p>
|
||
*/
|
||
protected r_: number;
|
||
/**
|
||
* <p> Construct from size of N and R. </p>
|
||
*
|
||
* @param n Size of candidates.
|
||
* @param r Size of elements of each case.
|
||
*/
|
||
constructor(n: number, r: number);
|
||
/**
|
||
* <p> Get size of all cases. </p>
|
||
*
|
||
* @return Get a number of the all cases.
|
||
*/
|
||
size(): number;
|
||
/**
|
||
* <p> Get size of the N. </p>
|
||
*/
|
||
n(): number;
|
||
/**
|
||
* <p> Get size of the R. </p>
|
||
*/
|
||
r(): number;
|
||
/**
|
||
* <p> Get index'th case. </p>
|
||
*
|
||
* @param index Index number
|
||
* @return The row of the index'th in combined permuation case
|
||
*/
|
||
abstract at(index: number): number[];
|
||
}
|
||
/**
|
||
* <p> A combined-permutation case generator. </p>
|
||
*
|
||
* <p> <sub>n</sub><3E><><sub>r</sub> </p>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class CombinedPermutationGenerator extends CaseGenerator {
|
||
/**
|
||
* <p> An array using for dividing each element index. </p>
|
||
*/
|
||
private divider_array;
|
||
/**
|
||
* <p> Construct from size of N and R. </p>
|
||
*
|
||
* @param n Size of candidates.
|
||
* @param r Size of elements of each case.
|
||
*/
|
||
constructor(n: number, r: number);
|
||
at(index: number): number[];
|
||
}
|
||
/**
|
||
* <p> A permutation case generator. </p>
|
||
*
|
||
* <p> <sub>n</sub>P<sub>r</sub> </p>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class PermuationGenerator extends CaseGenerator {
|
||
/**
|
||
* <p> Construct from size of N and R. </p>
|
||
*
|
||
* @param n Size of candidates.
|
||
* @param r Size of elements of each case.
|
||
*/
|
||
constructor(n: number, r: number);
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
at(index: number): number[];
|
||
}
|
||
/**
|
||
* <p> Factorial case generator. </p>
|
||
*
|
||
* <p> n! = <sub>n</sub>P<sub>n</sub> </p>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class FactorialGenerator extends PermuationGenerator {
|
||
/**
|
||
* Construct from factorial size N.
|
||
*
|
||
* @param n Factoria size N.
|
||
*/
|
||
constructor(n: number);
|
||
}
|
||
}
|
||
declare namespace samchon.library {
|
||
type BasicEventListener = (event: BasicEvent) => void;
|
||
/**
|
||
* <p> The IEventDispatcher interface defines methods for adding or removing event listeners, checks
|
||
* whether specific types of event listeners are registered, and dispatches events. </p>
|
||
*
|
||
* <p> Event targets are an important part of the Flash<73><68> Player and Adobe AIR event model. The event
|
||
* target serves as the local point for how events flow through the display list hierarchy. When an
|
||
* event such as a mouse click or a key press occurs, an event object is dispatched into the event flow
|
||
* from the root of the display list. The event object makes a round-trip journey to the event target,
|
||
* which is conceptually divided into three phases: the capture phase includes the journey from the
|
||
* root to the last node before the event target's node; the target phase includes only the event
|
||
* target node; and the bubbling phase includes any subsequent nodes encountered on the return trip to
|
||
* the root of the display list. </p>
|
||
*
|
||
* <p> In general, the easiest way for a user-defined class to gain event dispatching capabilities is
|
||
* to extend EventDispatcher. If this is impossible (that is, if the class is already extending another
|
||
* class), you can instead implement the IEventDispatcher interface, create an EventDispatcher member,
|
||
* and write simple hooks to route calls into the aggregated EventDispatcher. </p>
|
||
*
|
||
* @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/events/IEventDispatcher.html
|
||
* @author Migrated by Jeongho Nam <http://samchon.org>
|
||
*/
|
||
interface IEventDispatcher {
|
||
/**
|
||
* <p> Checks whether the EventDispatcher object has any listeners registered for a specific type
|
||
* of event. This allows you to determine where an EventDispatcher object has altered handling of
|
||
* an event type in the event flow hierarchy. To determine whether a specific event type actually
|
||
* triggers an event listener, use willTrigger(). </p>
|
||
*
|
||
* <p> The difference between hasEventListener() and willTrigger() is that hasEventListener()
|
||
* examines only the object to which it belongs, whereas willTrigger() examines the entire event
|
||
* flow for the event specified by the type parameter. </p>
|
||
*
|
||
* @param type The type of event.
|
||
*/
|
||
hasEventListener(type: string): boolean;
|
||
/**
|
||
* <p> Dispatches an event into the event flow. </p>
|
||
* <p> The event target is the EventDispatcher object upon which the dispatchEvent() method is called. </p>
|
||
*
|
||
* @param event The Event object that is dispatched into the event flow. If the event is being
|
||
* redispatched, a clone of the event is created automatically. After an event is
|
||
* dispatched, its target property cannot be changed, so you must create a new copy
|
||
* of the event for redispatching to work.
|
||
*/
|
||
dispatchEvent(event: library.BasicEvent): boolean;
|
||
/**
|
||
* <p> 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.
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> 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). </p>
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> 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). </p>
|
||
*
|
||
* @param event The type of event.
|
||
* @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: string, listener: library.BasicEventListener): void;
|
||
/**
|
||
* <p> 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.
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> 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). </p>
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> 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). </p>
|
||
*
|
||
* @param event The type of event.
|
||
* @param listener The listener function that processes the event.
|
||
* This function must accept an Event object as its only parameter and must return
|
||
* nothing.
|
||
* @param thisArg The object to be used as the <b>this</b> object.
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener, 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.
|
||
* @param listener The listener object to remove.
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener): 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.
|
||
* @param listener The listener object to remove.
|
||
* @param thisArg The object to be used as the <b>this</b> object.
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
}
|
||
/**
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> 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
|
||
* removeListener(). Then you can register the listener again with the new priority level. </p>
|
||
*
|
||
* Keep in mind that after the listener is registered, subsequent calls to <code>addEventListener()</code>
|
||
* 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.
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> If you no longer need an event listener, remove it by calling <code>removeEventListener()</code>,
|
||
* 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). </p>
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> If the event listener is being registered on a node while an event is being processed on
|
||
* this node, the event listener is not triggered during the current phase but can be triggered
|
||
* during a later phase in the event flow, such as the bubbling phase. </p>
|
||
*
|
||
* <p> 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 registered again for future processing). </p>
|
||
*
|
||
* <ul>
|
||
* <li> Made by AS3 - http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/events/EventDispatcher.html
|
||
* </ul>
|
||
*
|
||
* @author Migrated by Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class EventDispatcher implements IEventDispatcher {
|
||
/**
|
||
* The origin object who issuing events.
|
||
*/
|
||
protected event_dispatcher_: IEventDispatcher;
|
||
/**
|
||
* Container of listeners.
|
||
*/
|
||
protected event_listeners_: std.HashMap<string, std.HashSet<std.Pair<library.BasicEventListener, Object>>>;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* Construct from the origin event dispatcher.
|
||
*
|
||
* @param dispatcher The origin object who issuing events.
|
||
*/
|
||
constructor(dispatcher: IEventDispatcher);
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
hasEventListener(type: string): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
dispatchEvent(event: library.BasicEvent): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
addEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
removeEventListener(type: string, listener: library.BasicEventListener, thisArg: Object): void;
|
||
}
|
||
}
|
||
declare namespace samchon.library {
|
||
/**
|
||
* <p> The {@link FileReference} class provides a means to load and save files in browser level. </p>
|
||
*
|
||
* <p> The {@link FileReference} class provides a means to {@link load} and {@link save} files in browser level. A
|
||
* browser-system dialog box prompts the user to select a file to {@link load} or a location for {@link svae}. Each
|
||
* {@link FileReference} object refers to a single file on the user's disk and has properties that contain
|
||
* information about the file's size, type, name, creation date, modification date, and creator type (Macintosh only).
|
||
* </p>
|
||
*
|
||
* <p> FileReference instances are created in the following ways: </p>
|
||
* <ul>
|
||
* <li>
|
||
* When you use the new operator with the {@link FileReference} constructor:
|
||
* <code>var myFileReference = new FileReference();</code>
|
||
* </li>
|
||
* <li>
|
||
* When you call the {@link FileReferenceList.browse} method, which creates an array of {@link FileReference}
|
||
* objects.
|
||
* </li>
|
||
* </ul>
|
||
*
|
||
* <p> During a load operation, all the properties of a {@link FileReference} object are populated by calls to the
|
||
* {@link FileReference.browse} or {@link FileReferenceList.browse} methods. During a save operation, the name
|
||
* property is populated when the select event is dispatched; all other properties are populated when the complete
|
||
* event is dispatched. </p>
|
||
*
|
||
* <p> The {@link browse browse()} method opens an browser-system dialog box that prompts the user to select a file
|
||
* for {@link load}. The {@link FileReference.browse} method lets the user select a single file; the
|
||
* {@link FileReferenceList.browse} method lets the user select multiple files. After a successful call to the
|
||
* {@link browse browse()} method, call the {@link FileReference.load} method to load one file at a time. The
|
||
* {@link FileReference.save} method prompts the user for a location to save the file and initiates downloading from
|
||
* a binary or string data. </p>
|
||
*
|
||
* <p> The {@link FileReference} and {@link FileReferenceList} classes do not let you set the default file location
|
||
* for the dialog box that the {@link browse} or {@link save} methods generate. The default location shown in the
|
||
* dialog box is the most recently browsed folder, if that location can be determined, or the desktop. The classes do
|
||
* not allow you to read from or write to the transferred file. They do not allow the browser that initiated the
|
||
* {@link load} or {@link save} to access the loaded or saved file or the file's location on the user's disk. </p>
|
||
*
|
||
* @references http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/FileReference.html
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class FileReference extends EventDispatcher {
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private file_;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private data_;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* <p> The data from the loaded file after a successful call to the {@link load load()} method. </p>
|
||
*
|
||
* <p> If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
|
||
* an {@link LogicError exception} will be thrown when you try to get the value of this property. </p>
|
||
*
|
||
* <p> All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
|
||
* </p>
|
||
*/
|
||
data: any;
|
||
/**
|
||
* <p> The name of the file on the local disk. </p>
|
||
*
|
||
* <p> If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
|
||
* an {@link LogicError exception} will be thrown when you try to get the value of this property. </p>
|
||
*
|
||
* <p> All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
|
||
* </p>
|
||
*/
|
||
name: string;
|
||
/**
|
||
* <p> The filename extension. </p>
|
||
*
|
||
* <p> A file's extension is the part of the name following (and not including) the final dot ("."). If
|
||
* there is no dot in the filename, the extension is <code>null</code>. </p>
|
||
*
|
||
* <p> If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
|
||
* an {@link LogicError exception} will be thrown when you try to get the value of this property. </p>
|
||
*
|
||
* <p> All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
|
||
* </p>
|
||
*/
|
||
extension: string;
|
||
/**
|
||
* <p> The file type, metadata of the {@link extension}. </p>
|
||
*
|
||
* <p> If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
|
||
* an {@link LogicError exception} will be thrown when you try to get the value of this property. </p>
|
||
*
|
||
* <p> All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
|
||
* </p>
|
||
*/
|
||
type: string;
|
||
/**
|
||
* <p> The size of the file on the local disk in bytes. </p>
|
||
*
|
||
* <p> If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
|
||
* an {@link LogicError exception} will be thrown when you try to get the value of this property. </p>
|
||
*
|
||
* <p> All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
|
||
* </p>
|
||
*/
|
||
size: number;
|
||
/**
|
||
* <p> The date that the file on the local disk was last modified. </p>
|
||
*
|
||
* <p> If the {@link FileReference} object was not populated (by a valid call to {@link FileReference.browse}),
|
||
* an {@link LogicError exception} will be thrown when you try to get the value of this property. </p>
|
||
*
|
||
* <p> All the properties of a {@link FileReference} object are populated by calling the {@link browse browse()}.
|
||
* </p>
|
||
*/
|
||
modificationDate: Date;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
_Set_file(val: File): void;
|
||
/**
|
||
* <p> Displays a file-browsing dialog box that lets the user select a file to upload. The dialog box is native
|
||
* to the user's browser system. The user can select a file on the local computer or from other systems, for
|
||
* example, through a UNC path on Windows. </p>
|
||
*
|
||
* <p> When you call this method and the user successfully selects a file, the properties of this
|
||
* {@link FileReference} object are populated with the properties of that file. Each subsequent time that the
|
||
* {@link FileReference.browse} method is called, the {@link FileReference} object's properties are reset to
|
||
* the file that the user selects in the dialog box. Only one {@link browse browse()} can be performed at a time
|
||
* (because only one dialog box can be invoked at a time). </p>
|
||
*
|
||
* <p> Using the <i>typeFilter parameter</i>, you can determine which files the dialog box displays. </p>
|
||
*
|
||
* @param typeFilter An array of filter strings used to filter the files that are displayed in the dialog box.
|
||
* If you omit this parameter, all files are displayed.
|
||
*/
|
||
browse(...typeFilter: string[]): void;
|
||
/**
|
||
* <p> Starts the load of a local file selected by a user. </p>
|
||
*
|
||
* <p> You must call the {@link FileReference.browse} or {@link FileReferenceList.browse} method before you call
|
||
* the {@link load load()} method. </p>
|
||
*
|
||
* <p> Listeners receive events to indicate the progress, success, or failure of the load. Although you can use
|
||
* the {@link FileReferenceList} object to let users select multiple files to load, you must {@link load} the
|
||
* {@link FileReferenceList files} one by one. To {@link load} the files one by one, iterate through the
|
||
* {@link FileReferenceList.fileList} array of {@link FileReference} objects. </p>
|
||
*
|
||
* <p> If the file finishes loading successfully, its contents are stored in the {@link data} property. </p>
|
||
*/
|
||
load(): void;
|
||
/**
|
||
* <p> Save a file to local filesystem. </p>
|
||
*
|
||
* <p> {@link FileReference.save} implemented the save function by downloading a file from a hidden anchor tag.
|
||
* However, the plan, future's {@link FileReference} will follow such rule: </p>
|
||
*
|
||
* <p> Opens a dialog box that lets the user save a file to the local filesystem. </p>
|
||
*
|
||
* <p> The {@link save save()} method first opens an browser-system dialog box that asks the user to enter a
|
||
* filename and select a location on the local computer to save the file. When the user selects a location and
|
||
* confirms the save operation (for example, by clicking Save), the save process begins. Listeners receive events
|
||
* to indicate the progress, success, or failure of the save operation. To ascertain the status of the dialog box
|
||
* and the save operation after calling {@link save save()}, your code must listen for events such as cancel,
|
||
* open, progress, and complete. </p>
|
||
*
|
||
* <p> When the file is saved successfully, the properties of the {@link FileReference} object are populated with
|
||
* the properties of the local file. The complete event is dispatched if the save is successful. </p>
|
||
*
|
||
* <p> Only one {@link browse browse()} or {@link save()} session can be performed at a time (because only one
|
||
* dialog box can be invoked at a time). </p>
|
||
*
|
||
* @param data The data to be saved. The data can be in one of several formats, and will be treated appropriately.
|
||
* @param fileName File name to be saved.
|
||
*/
|
||
save(data: string, fileName: string): void;
|
||
/**
|
||
* <p> Save a file to local filesystem. </p>
|
||
*
|
||
* <p> {@link FileReference.save} implemented the save function by downloading a file from a hidden anchor tag.
|
||
* However, the plan, future's {@link FileReference} will follow such rule: </p>
|
||
*
|
||
* <p> Opens a dialog box that lets the user save a file to the local filesystem. </p>
|
||
*
|
||
* <p> The {@link save save()} method first opens an browser-system dialog box that asks the user to enter a
|
||
* filename and select a location on the local computer to save the file. When the user selects a location and
|
||
* confirms the save operation (for example, by clicking Save), the save process begins. Listeners receive events
|
||
* to indicate the progress, success, or failure of the save operation. To ascertain the status of the dialog box
|
||
* and the save operation after calling {@link save save()}, your code must listen for events such as cancel,
|
||
* open, progress, and complete. </p>
|
||
*
|
||
* <p> When the file is saved successfully, the properties of the {@link FileReference} object are populated with
|
||
* the properties of the local file. The complete event is dispatched if the save is successful. </p>
|
||
*
|
||
* <p> Only one {@link browse browse()} or {@link save()} session can be performed at a time (because only one
|
||
* dialog box can be invoked at a time). </p>
|
||
*
|
||
* @param data The data to be saved. The data can be in one of several formats, and will be treated appropriately.
|
||
* @param fileName File name to be saved.
|
||
*/
|
||
static save(data: string, fileName: string): void;
|
||
}
|
||
/**
|
||
* <p> The {@link FileReferenceList} class provides a means to let users select one or more files for
|
||
* {@link FileReference.load loading}. A {@link FileReferenceList} object represents a group of one or more local
|
||
* files on the user's disk as an array of {@link FileReference} objects. For detailed information and important
|
||
* considerations about {@link FileReference} objects and the FileReference class, which you use with
|
||
* {@link FileReferenceList}, see the {@link FileReference} class. </p>
|
||
*
|
||
* <p> To work with the {@link FileReferenceList} class: </p>
|
||
* <ul>
|
||
* <li> Instantiate the class: <code>var myFileRef = new FileReferenceList();</code> </li>
|
||
* <li>
|
||
* Call the {@link FileReferenceList.browse} method, which opens a dialog box that lets the user select one or
|
||
* more files for upload: <code>myFileRef.browse();</code>
|
||
* </li>
|
||
* <li>
|
||
* After the {@link browse browse()} method is called successfully, the {@link fileList} property of the
|
||
* {@link FileReferenceList} object is populated with an array of {@link FileReference} objects.
|
||
* </li>
|
||
* <li> Call {@link FileReference.load} on each element in the {@link fileList} array. </li>
|
||
* </ul>
|
||
*
|
||
* <p> The {@link FileReferenceList} class includes a {@link browse browse()} method and a {@link fileList} property
|
||
* for working with multiple files. </p>
|
||
*
|
||
* @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/FileReferenceList.html
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class FileReferenceList extends EventDispatcher {
|
||
/**
|
||
* @hidden
|
||
*/
|
||
file_list: std.Vector<FileReference>;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* <p> An array of {@link FileReference} objects. </p>
|
||
*
|
||
* <p> When the {@link FileReferenceList.browse} method is called and the user has selected one or more files
|
||
* from the dialog box that the {@link browse browse()} method opens, this property is populated with an array of
|
||
* {@link FileReference} objects, each of which represents the files the user selected. </p>
|
||
*
|
||
* <p> The {@link fileList} property is populated anew each time {@link browse browse()} is called on that
|
||
* {@link FileReferenceList} object. </p>
|
||
*/
|
||
fileList: std.Vector<FileReference>;
|
||
/**
|
||
* <p> Displays a file-browsing dialog box that lets the user select one or more local files to upload. The
|
||
* dialog box is native to the user's browser system. </p>
|
||
*
|
||
* <p> When you call this method and the user successfully selects files, the {@link fileList} property of this
|
||
* {@link FileReferenceList} object is populated with an array of {@link FileReference} objects, one for each
|
||
* file that the user selects. Each subsequent time that the {@link FileReferenceList.browse} method is called,
|
||
* the {@link FileReferenceList.fileList} property is reset to the file(s) that the user selects in the dialog
|
||
* box. </p>
|
||
*
|
||
* <p> Using the <i>typeFilter</i> parameter, you can determine which files the dialog box displays. </p>
|
||
*
|
||
* <p> Only one {@link FileReference.browse}, {@link FileReference.load}, or {@link FileReferenceList.browse}
|
||
* session can be performed at a time on a {@link FileReferenceList} object (because only one dialog box can be
|
||
* opened at a time). </p>
|
||
*
|
||
* @param typeFilter An array of filter strings used to filter the files that are displayed in the dialog box.
|
||
* If you omit this parameter, all files are displayed.
|
||
*/
|
||
browse(...typeFilter: string[]): void;
|
||
}
|
||
}
|
||
declare namespace samchon.library {
|
||
/**
|
||
* <p> A genetic algorithm class. </p>
|
||
*
|
||
* @details
|
||
* <p> In the field of artificial intelligence, a genetic algorithm (GA) is a search heuristic that mimics the
|
||
* process of natural selection. This heuristic (also sometimes called a metaheuristic) is routinely used to generate
|
||
* useful solutions to optimization and search problems. </p>
|
||
*
|
||
* <p> Genetic algorithms belong to the larger class of evolutionary algorithms (EA), which generate solutions to
|
||
* optimization problems using techniques inspired by natural evolution, such as inheritance, {@link mutate mutation},
|
||
* {@link selection}, and {@link crossover}. </p>
|
||
*
|
||
* @reference https://en.wikipedia.org/wiki/Genetic_algorithm
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class GeneticAlgorithm {
|
||
/**
|
||
* Whether each element (Gene) is unique in their GeneArray.
|
||
*/
|
||
private unique_;
|
||
/**
|
||
* Rate of mutation.
|
||
*
|
||
* The {@link mutation_rate} determines the percentage of occurence of mutation in GeneArray.
|
||
*
|
||
* <ul>
|
||
* <li> When {@link mutation_rate} is too high, it is hard to ancitipate studying on genetic algorithm. </li>
|
||
* <li>
|
||
* When {@link mutation_rate} is too low and initial set of genes (GeneArray) is far away from optimal, the
|
||
* evolution tends to wandering outside of he optimal.
|
||
* </li>
|
||
* </ul>
|
||
*/
|
||
private mutation_rate_;
|
||
/**
|
||
* Number of tournaments in selection.
|
||
*/
|
||
private tournament_;
|
||
/**
|
||
* Initialization Constructor.
|
||
*
|
||
* @param unique Whether each Gene is unique in their GeneArray.
|
||
* @param mutation_rate Rate of mutation.
|
||
* @param tournament Number of tournaments in selection.
|
||
*/
|
||
constructor(unique?: boolean, mutation_rate?: number, tournament?: number);
|
||
/**
|
||
* <p> Evolove <i>GeneArray</i>. </p>
|
||
*
|
||
* <p> Convenient method accessing to {@link evolvePopulation evolvePopulation()}. </p>
|
||
*
|
||
* @param individual An initial set of genes; sequence listing.
|
||
* @param population Size of population in a generation.
|
||
* @param generation Size of generation in evolution.
|
||
* @param compare A comparison function returns whether left gene is more optimal.
|
||
*
|
||
* @return An evolved <i>GeneArray</i>, optimally.
|
||
*
|
||
* @see {@link GAPopulation.compare}
|
||
*/
|
||
evolveGeneArray<T, GeneArray extends std.base.IArrayContainer<T>>(individual: GeneArray, population: number, generation: number, compare?: (left: T, right: T) => boolean): GeneArray;
|
||
/**
|
||
* Evolve <i>population</i>, a mass of <i>GeneArraies</i>.
|
||
*
|
||
* @param population An initial population.
|
||
* @param compare A comparison function returns whether left gene is more optimal.
|
||
*
|
||
* @return An evolved population.
|
||
*
|
||
* @see {@link GAPopulation.compare}
|
||
*/
|
||
evolvePopulation<T, GeneArray extends std.base.IArrayContainer<T>>(population: GAPopulation<T, GeneArray>, compare?: (left: T, right: T) => boolean): GAPopulation<T, GeneArray>;
|
||
/**
|
||
* <p> Select the best GeneArray in <i>population</i> from tournament. </p>
|
||
*
|
||
* <p> {@link selection Selection} is the stage of a genetic algorithm in which individual genomes are chosen
|
||
* from a population for later breeding (using {@linlk crossover} operator). A generic {@link selection}
|
||
* procedure may be implemented as follows: </p>
|
||
*
|
||
* <ol>
|
||
* <li>
|
||
* The fitness function is evaluated for each individual, providing fitness values, which are then
|
||
* normalized. ization means dividing the fitness value of each individual by the sum of all fitness
|
||
* values, so that the sum of all resulting fitness values equals 1.
|
||
* </li>
|
||
* <li> The population is sorted by descending fitness values. </li>
|
||
* <li>
|
||
* Accumulated normalized fitness values are computed (the accumulated fitness value of an individual is the
|
||
* sum of its own fitness value plus the fitness values of all the previous individuals). The accumulated
|
||
* fitness of the last individual should be 1 (otherwise something went wrong in the normalization step).
|
||
* </li>
|
||
* <li> A random number R between 0 and 1 is chosen. </li>
|
||
* <li> The selected individual is the first one whose accumulated normalized value is greater than R. </li>
|
||
* </ol>
|
||
*
|
||
* @param population The target of tournament.
|
||
* @return The best genes derived by the tournament.
|
||
*
|
||
* @reference https://en.wikipedia.org/wiki/Selection_(genetic_algorithm)
|
||
*/
|
||
private selection<T, GeneArray>(population);
|
||
/**
|
||
* <p> Create a new GeneArray by crossing over two <i>GeneArray</i>(s). </p>
|
||
*
|
||
* <p> {@link crossover} is a genetic operator used to vary the programming of a chromosome or chromosomes from
|
||
* one generation to the next. It is analogous to reproduction and biological crossover, upon which genetic
|
||
* algorithms are based. </p>
|
||
*
|
||
* <p> {@link crossover Cross over} is a process of taking more than one parent solutions and producing a child
|
||
* solution from them. There are methods for selection of the chromosomes. </p>
|
||
*
|
||
* @param parent1 A parent sequence listing
|
||
* @param parent2 A parent sequence listing
|
||
*
|
||
* @reference https://en.wikipedia.org/wiki/Crossover_(genetic_algorithm)
|
||
*/
|
||
private crossover<T, GeneArray>(parent1, parent2);
|
||
/**
|
||
* <p> Cause a mutation on the <i>GeneArray</i>. </p>
|
||
*
|
||
* <p> {@link mutate Mutation} is a genetic operator used to maintain genetic diversity from one generation of a
|
||
* population of genetic algorithm chromosomes to the next. It is analogous to biological mutation. </p>
|
||
*
|
||
* <p> {@link mutate Mutation} alters one or more gene values in a chromosome from its initial state. In
|
||
* {@link mutate mutation}, the solution may change entirely from the previous solution. Hence GA can come to
|
||
* better solution by using {@link mutate mutation}. </p>
|
||
*
|
||
* <p> {@link mutate Mutation} occurs during evolution according to a user-definable mutation probability. This
|
||
* probability should be set low. If it is set too high, the search will turn into a primitive random search. </p>
|
||
*
|
||
* <h4> Note </h4>
|
||
* <p> Muttion is pursuing diversity. Mutation is useful for avoiding the following problem. </p>
|
||
*
|
||
* <p> When initial set of genes(GeneArray) is far away from optimail, without mutation (only with selection and
|
||
* crossover), the genetic algorithm has a tend to wandering outside of the optimal. </p>
|
||
*
|
||
* <p> Genes in the GeneArray will be swapped following percentage of the {@link mutation_rate}. </p>
|
||
*
|
||
* @param individual A container of genes to mutate
|
||
*
|
||
* @reference https://en.wikipedia.org/wiki/Mutation_(genetic_algorithm)
|
||
* @see {@link mutation_rate}
|
||
*/
|
||
private mutate<T, GeneArray>(individual);
|
||
}
|
||
/**
|
||
* <p> A population in a generation. </p>
|
||
*
|
||
* <p> {@link GAPopulation} is a class representing population of candidate genes (sequence listing) having an array
|
||
* of GeneArray as a member. {@link GAPopulation} also manages initial set of genes and handles fitting test direclty
|
||
* by the method {@link fitTest fitTest()}. </p>
|
||
*
|
||
* <p> The success of evolution of genetic algorithm is depend on the {@link GAPopulation}'s initial set and fitting
|
||
* test. (<i>GeneArray</i> and {@link compare}.) </p>
|
||
*
|
||
* <h4> Warning </h4>
|
||
* <p> Be careful for the mistakes of direction or position of the {@link compare}. </p>
|
||
* <p> Most of logical errors failed to access optimal solution are occured from those mistakes. </p>
|
||
*
|
||
* @param <T> Type of gene elements.
|
||
* @param <GeneArray> An array containing genes as elments; sequnce listing.
|
||
*
|
||
* @author Jeongho Nam <http://samcho.org>
|
||
*/
|
||
class GAPopulation<T, GeneArray extends std.base.IArrayContainer<T>> {
|
||
/**
|
||
* Genes representing the population.
|
||
*/
|
||
private children_;
|
||
/**
|
||
* <p> A comparison function returns whether left gene is more optimal, greater. </p>
|
||
*
|
||
* <p> Default value of this {@link compare} is {@link std.greater}. It means to compare two array
|
||
* (GeneArray must be a type of {@link std.base.IArrayContainer}). Thus, you've to keep follwing rule. </p>
|
||
*
|
||
* <ul>
|
||
* <li> GeneArray is implemented from {@link std.base.IArrayContainer}. </li>
|
||
* <ul>
|
||
* <li> {@link std.Vector} </li>
|
||
* <li> {@link std.Deque} </li>
|
||
* </ul>
|
||
* <li> GeneArray has custom <code>public less(obj: T): boolean;</code> function. </li>
|
||
* </ul>
|
||
*
|
||
* <p> If you don't want to follow the rule or want a custom comparison function, you have to realize a
|
||
* comparison function. </p>
|
||
*/
|
||
private compare_;
|
||
/**
|
||
* <p> Private constructor with population. </p>
|
||
*
|
||
* <p> Private constructor of GAPopulation does not create {@link children}. (candidate genes) but only assigns
|
||
* <i>null</i> repeatedly following the <i>population size</i>. </p>
|
||
*
|
||
* <p> This private constructor is designed only for {@link GeneticAlgorithm}. Don't create {@link GAPopulation}
|
||
* with this constructor, by yourself. </p>
|
||
*
|
||
* @param size Size of the population.
|
||
*/
|
||
constructor(size: number);
|
||
/**
|
||
* <p> Construct from a {@link GeneArray} and <i>size of the population</i>. </p>
|
||
*
|
||
* <p> This public constructor creates <i>GeneArray(s)</i> as population (size) having shuffled genes which are
|
||
* came from the initial set of genes (<i>geneArray</i>). It uses {@link std.greater} as default comparison function.
|
||
* </p>
|
||
*
|
||
* @param geneArray An initial sequence listing.
|
||
* @param size The size of population to have as children.
|
||
*/
|
||
constructor(geneArray: GeneArray, size: number);
|
||
/**
|
||
* <p> Constructor from a GeneArray, size of the poluation and custom comparison function. </p>
|
||
*
|
||
* <p> This public constructor creates <i>GeneArray(s)</i> as population (size) having shuffled genes which are
|
||
* came from the initial set of genes (<i>geneArray</i>). The <i>compare</i> is used for comparison function.
|
||
* </p>
|
||
*
|
||
* @param geneArray An initial sequence listing.
|
||
* @param size The size of population to have as children.
|
||
* @param compare A comparison function returns whether left gene is more optimal.
|
||
*/
|
||
constructor(geneArray: GeneArray, size: number, compare: (left: GeneArray, right: GeneArray) => boolean);
|
||
_Get_children(): std.Vector<GeneArray>;
|
||
/**
|
||
* Test fitness of each <i>GeneArray</i> in the {@link population}.
|
||
*
|
||
* @return The best <i>GeneArray</i> in the {@link population}.
|
||
*/
|
||
fitTest(): GeneArray;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private clone(obj);
|
||
}
|
||
}
|
||
declare namespace samchon.library {
|
||
/**
|
||
* <p> A utility class supporting static methods of string. </p>
|
||
*
|
||
* <p> The {@link StringUtil} utility class is an all-static class with methods for working with string objects within
|
||
* Samchon Framework. You do not create instances of {@link StringUtil}; instead you call methods such as the
|
||
* <code>StringUtil.substitute()</code> method. </p>
|
||
*
|
||
* @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/mx/utils/StringUtil.html
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class StringUtil {
|
||
/**
|
||
* <p> Generate a substring. </p>
|
||
*
|
||
* <p> Extracts a substring consisting of the characters from specified start to end.
|
||
* It's same with str.substring( ? = (str.find(start) + start.size()), str.find(end, ?) ) </p>
|
||
*
|
||
* <code>
|
||
let str = between("ABCD[EFGH]IJK", "[", "]");
|
||
console.log(str); // PRINTS "EFGH"
|
||
* </code>
|
||
*
|
||
* <ul>
|
||
* <li> If start is not specified, extracts from begin of the string to end. </li>
|
||
* <li> If end is not specified, extracts from start to end of the string. </li>
|
||
* <li> If start and end are all omitted, returns str, itself. </li>
|
||
* </ul>
|
||
*
|
||
* @param str Target string to be applied between.
|
||
* @param start A string for separating substring at the front.
|
||
* @param end A string for separating substring at the end.
|
||
*
|
||
* @return substring by specified terms.
|
||
*/
|
||
static between(str: string, start?: string, end?: string): string;
|
||
/**
|
||
* <p> Fetch substrings. </p>
|
||
*
|
||
* <p> Splits a string into an array of substrings dividing by specified delimeters of start and end.
|
||
* It's the array of substrings adjusted the between. </p>
|
||
*
|
||
* <ul>
|
||
* <li> If startStr is omitted, it's same with the split by endStr not having last item. </li>
|
||
* <li> If endStr is omitted, it's same with the split by startStr not having first item. </li>
|
||
* <li> If startStr and endStar are all omitted, returns <i>str</i>. </li>
|
||
* </ul>
|
||
*
|
||
* @param str Target string to split by between.
|
||
* @param start A string for separating substring at the front.
|
||
* If omitted, it's same with split(end) not having last item.
|
||
* @param end A string for separating substring at the end.
|
||
* If omitted, it's same with split(start) not having first item.
|
||
* @return An array of substrings.
|
||
*/
|
||
static betweens(str: string, start?: string, end?: string): Array<string>;
|
||
/**
|
||
* An array containing whitespaces.
|
||
*/
|
||
private static SPACE_ARRAY;
|
||
/**
|
||
* Remove all designated characters from the beginning and end of the specified string.
|
||
*
|
||
* @param str The string whose designated characters should be trimmed.
|
||
* @param args Designated character(s).
|
||
*
|
||
* @return Updated string where designated characters was removed from the beginning and end.
|
||
*/
|
||
static trim(str: string, ...args: string[]): string;
|
||
/**
|
||
* Remove all designated characters from the beginning of the specified string.
|
||
*
|
||
* @param str The string should be trimmed.
|
||
* @param delims Designated character(s).
|
||
*
|
||
* @return Updated string where designated characters was removed from the beginning
|
||
*/
|
||
static ltrim(str: string, ...args: string[]): string;
|
||
/**
|
||
* Remove all designated characters from the end of the specified string.
|
||
*
|
||
* @param str The string should be trimmed.
|
||
* @param delims Designated character(s).
|
||
*
|
||
* @return Updated string where designated characters was removed from the end.
|
||
*/
|
||
static rtrim(str: string, ...args: string[]): string;
|
||
/**
|
||
* Substitute <code>{n}</code> tokens within the specified string.
|
||
*
|
||
* @param format The string to make substitutions in. This string can contain special tokens of the form
|
||
* <code>{n}</code>, where <code>n</code> is a zero based index, that will be replaced with the
|
||
* additional parameters found at that index if specified.
|
||
* @param args Additional parameters that can be substituted in the <i>format</i> parameter at each
|
||
* <code>{n}</code> location, where <code>n</code> is an integer (zero based) index value into
|
||
* the array of values specified.
|
||
*
|
||
* @return New string with all of the <code>{n}</code> tokens replaced with the respective arguments specified.
|
||
*/
|
||
static substitute(format: string, ...args: any[]): string;
|
||
/**
|
||
* Returns a string specified word is replaced.
|
||
*
|
||
* @param str Target string to replace
|
||
* @param before Specific word you want to be replaced
|
||
* @param after Specific word you want to replace
|
||
*
|
||
* @return A string specified word is replaced
|
||
*/
|
||
static replaceAll(str: string, before: string, after: string): string;
|
||
/**
|
||
* Returns a string specified words are replaced.
|
||
*
|
||
* @param str Target string to replace
|
||
* @param pairs A specific word's pairs you want to replace and to be replaced
|
||
*
|
||
* @return A string specified words are replaced
|
||
*/
|
||
static replaceAll(str: string, ...pairs: std.Pair<string, string>[]): string;
|
||
/**
|
||
* Replace all HTML spaces to a literal space.
|
||
*
|
||
* @param str Target string to replace.
|
||
*/
|
||
static removeHTMLSpaces(str: string): string;
|
||
/**
|
||
* <p> Repeat a string. </p>
|
||
*
|
||
* <p> Returns a string consisting of a specified string concatenated with itself a specified number of times. </p>
|
||
*
|
||
* @param str The string to be repeated.
|
||
* @param n The repeat count.
|
||
*
|
||
* @return The repeated string.
|
||
*/
|
||
static repeat(str: string, n: number): string;
|
||
/**
|
||
* <p> Number to formatted string with "," sign. </p>
|
||
*
|
||
* <p> Returns a string converted from the number rounded off from specified precision with "," symbols. </p>
|
||
*
|
||
* @param val A number wants to convert to string.
|
||
* @param precision Target precision of round off.
|
||
*
|
||
* @return A string who represents the number with roundoff and "," symbols.
|
||
*/
|
||
static numberFormat(val: number, precision?: number): string;
|
||
static percentFormat(val: number, precision?: number): string;
|
||
}
|
||
}
|
||
declare namespace samchon.library {
|
||
/**
|
||
* <p> URLVariables class is for representing variables of HTTP. </p>
|
||
*
|
||
* <p> URLVariables class allows you to transfer variables between an application and server.
|
||
* When transfering, URLVariables will be converted to a URI string. </p>
|
||
*
|
||
* <ul>
|
||
* <li> URI: Uniform Resource Identifier </li>
|
||
* </ul>
|
||
*
|
||
* @reference http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/net/URLVariables.html
|
||
* @author Migrated by Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class URLVariables extends std.HashMap<string, string> {
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* <p> Construct from a URL-encoded string. </p>
|
||
*
|
||
* <p> The {@link decode decode()} method is automatically called to convert the string to properties of the {@link URLVariables} object. </p>
|
||
*
|
||
* @param str A URL-encoded string containing name/value pairs.
|
||
*/
|
||
constructor(str: string);
|
||
/**
|
||
* Converts the variable string to properties of the specified URLVariables object.
|
||
*
|
||
* @param str A URL-encoded query string containing name/value pairs.
|
||
*/
|
||
decode(str: string): void;
|
||
/**
|
||
* Returns a string containing all enumerable variables, in the MIME content encoding application/x-www-form-urlencoded.
|
||
*/
|
||
toString(): string;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* <p> An interface of entity. </p>
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> 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). </p>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
interface IEntity {
|
||
/**
|
||
* <p> Construct data of the Entity from a XML object. </p>
|
||
*
|
||
* <p> Overrides the construct() method and fetch data of member variables from the XML. </p>
|
||
*
|
||
* <p> By recommended guidance, data representing member variables are contained in properties
|
||
* of the put XML object. </p>
|
||
*
|
||
* @param xml An xml used to contruct data of entity.
|
||
*/
|
||
construct(xml: library.XML): void;
|
||
/**
|
||
* <p> Get a key that can identify the Entity uniquely. </p>
|
||
*
|
||
* <p> If identifier of the Entity is not atomic value, returns a paired or tuple object
|
||
* that can represents the composite identifier. </p>
|
||
*
|
||
* <code>
|
||
* class Point extends Entity
|
||
* {
|
||
* private x: number;
|
||
* private y: number;
|
||
*
|
||
* public key(): std.Pair<number, number>
|
||
* {
|
||
* return std.make_pair(this.x, this.y);
|
||
* }
|
||
* }
|
||
* </code>
|
||
*/
|
||
key(): any;
|
||
/**
|
||
* <p> A tag name when represented by XML. </p>
|
||
*
|
||
* <code> <TAG {...properties} /> </code>
|
||
*/
|
||
TAG(): string;
|
||
/**
|
||
* <p> Get a XML object represents the Entity. </p>
|
||
*
|
||
* <p> A member variable (not object, but atomic value like number, string or date) is categorized
|
||
* as a property within the framework of entity side. Thus, when overriding a toXML() method and
|
||
* archiving member variables to an XML object to return, puts each variable to be a property
|
||
* belongs to only a XML object. </p>
|
||
*
|
||
* <p> Don't archive the member variable of atomic value to XML::value causing enormouse creation
|
||
* of XML objects to number of member variables. An Entity must be represented by only a XML
|
||
* instance (tag). </p>
|
||
*
|
||
* <h4> Standard Usage. </h4>
|
||
* <code>
|
||
* <memberList>
|
||
* <member id='jhnam88' name='Jeongho Nam' birthdate='1988-03-11' />
|
||
* <member id='master' name='Administartor' birthdate='2011-07-28' />
|
||
* </memberList>
|
||
* </code>
|
||
*
|
||
* <h4> Non-standard usage abusing value. </h4>
|
||
* <code>
|
||
* <member>
|
||
* <id>jhnam88</id>
|
||
* <name>Jeongho Nam</name>
|
||
* <birthdate>1988-03-11</birthdate>
|
||
* </member>
|
||
* <member>
|
||
* <id>master</id>
|
||
* <name>Administartor</name>
|
||
* <birthdate>2011-07-28</birthdate>
|
||
* </member>
|
||
* </code>
|
||
*
|
||
* @return An XML object representing the Entity.
|
||
*/
|
||
toXML(): library.XML;
|
||
}
|
||
/**
|
||
* @hidden
|
||
*/
|
||
namespace IEntity {
|
||
function construct(entity: IEntity, xml: library.XML, ...prohibited_names: string[]): void;
|
||
function toXML(entity: IEntity, ...prohibited_names: string[]): library.XML;
|
||
}
|
||
/**
|
||
* <p> An entity, a standard data class. </p>
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> 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. </p>
|
||
*
|
||
* <p> 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). </p>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
abstract class Entity implements IEntity {
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
construct(xml: library.XML): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
key(): any;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract TAG(): string;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
toXML(): library.XML;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* <p> An interface taking full charge of network communication. </p>
|
||
*
|
||
* <p> {@link ICommunicator} is an interface for communicator classes who take full charge of network communication
|
||
* with external system, without reference to whether the external system is a server or a client. </p>
|
||
*
|
||
* <p> Whenever a replied message comes from the external system, the message will be converted to an
|
||
* {@link Invoke} class and will be shifted to the {@link WebCommunicator.listener listener}'s
|
||
* {@link IProtocol.replyData replyData()} method. </p>
|
||
*
|
||
* <code>
|
||
interface ICommmunicator
|
||
{
|
||
private socket: SomeSocketClass;
|
||
|
||
// LISTENER LISTENS INVOKE MESSAGE BY IT'S IProtocol.replyData() METHOD
|
||
protected listener: IProtocol;
|
||
|
||
// YOU CAN DETECT DISCONNECTION BY ENROLLING FUNCTION POINTER TO HERE.
|
||
public onClose: Function;
|
||
|
||
public sendData(invoke: Invoke): void
|
||
{
|
||
this.socket.write(invoke);
|
||
}
|
||
public replyData(invoke: Invoke): void
|
||
{
|
||
// WHENEVER COMMUNICATOR GETS MESSAGE, THEN SHIFT IT TO LISTENER'S replyData() METHOD.
|
||
this.listener.replyData(invoke);
|
||
}
|
||
}
|
||
* </code>
|
||
*
|
||
* <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
|
||
* target="_blank">
|
||
* <img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
|
||
* style="max-width: 100%" />
|
||
* </a> </p>
|
||
*
|
||
*
|
||
* <h2> Basic Components </h2>
|
||
* <h4> What Basic Components are </h4>
|
||
* <p> <b>Basic Components</b> are the smallest unit of network communication in this <i>Samchon Framework</i>. With
|
||
* <b>Basic Components</b>, you can construct any type of network system, even how the network system is enormously
|
||
* scaled and complicated, by just combinating the <b>Basic Components</b>. </p>
|
||
*
|
||
* <p> All the system templates in this framework are also being implemented by utilization of the
|
||
* <b>Basic Compoonents</b>. </p>
|
||
*
|
||
* <ul>
|
||
* <li> {@link service Service} </il>
|
||
* <li> {@link external External System} </il>
|
||
* <li> {@link parallel Parallel System} </il>
|
||
* <li> {@link distributed Distributed System} </il>
|
||
* </ul>
|
||
*
|
||
* <p> Note that, whatever the network system what you've to construct is, just concentrate on role of each system
|
||
* and attach matched <b>Basic Components</b> to the role, within framework of the <b>Object-Oriented Design</b>.
|
||
* Then construction of the network system will be much easier. </p>
|
||
*
|
||
* <ul>
|
||
* <li> A system is a server, then use {@link IServer} or {@link IServerBase}. </li>
|
||
* <li> A server wants to handle a client has connected, then use {@link IClientDriver}. </li>
|
||
* <li> A system is a client connecting to an external server, then use {@link IServerConnector}. </li>
|
||
* <li> </li>
|
||
* </ul>
|
||
*
|
||
* <h4> Example - System Templates </h4>
|
||
* <p> Learning and understanding <i>Basic Components</i> of Samchon Framework, reading source codes and design of
|
||
* <b>System Templates</b>' modules will be very helpful. </p>
|
||
*
|
||
* <table>
|
||
* <tr>
|
||
* <th> Name </th>
|
||
* <th> Source </th>
|
||
* <th> API Documents </th>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> Cloud Service </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/service"
|
||
* target="_blank"> protocol/service </a> </td>
|
||
* <td> {@link protocol.service} </td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> External System </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/external"
|
||
* target="_blank"> protocol/external </a> </td>
|
||
* <td> {@link protocol.external} </td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> Parallel System </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/parallel"
|
||
* target="_blank"> protocol/parallel </a> </td>
|
||
* <td> {@link protocol.parallel} </td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> Distributed System </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/distributed"
|
||
* target="_blank"> protocol/distributed </a> </td>
|
||
* <td> {@link protocol.distributed} </td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> Slave System </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/slave"
|
||
* target="_blank"> protocol/slave </a> </td>
|
||
* <td> {@link protocol.slave} </td>
|
||
* </tr>
|
||
* </table>
|
||
*
|
||
* <h4> Example - Projects </h4>
|
||
* <ul>
|
||
* <li>
|
||
* <a href="https://github.com/samchon/framework/wiki/Examples-Calculator" target="_blank"> Calculator </a>
|
||
* </li>
|
||
* <li>
|
||
* <a href="https://github.com/samchon/framework/wiki/Examples-Chatting" target="_blank"> Chatting </a>
|
||
* </li>
|
||
* <li>
|
||
* <a href="https://github.com/samchon/framework/wiki/Examples-Interaction" target="_blank"> Interaction </a>
|
||
* </li>
|
||
* </ul>
|
||
*
|
||
* @see {@link IClientDriver}, {@link IServerConnector}
|
||
* @handbook <a href="https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#icommunicator"
|
||
* target="_blank"> Basic Components - ICommunicator </a>
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
interface ICommunicator extends IProtocol {
|
||
/**
|
||
* Callback function for connection closed.
|
||
*/
|
||
onClose: Function;
|
||
/**
|
||
* Close connection.
|
||
*/
|
||
close(): void;
|
||
isConnected(): boolean;
|
||
sendData(invoke: protocol.Invoke): void;
|
||
replyData(invoke: protocol.Invoke): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
abstract class CommunicatorBase implements ICommunicator {
|
||
/**
|
||
* @hidden
|
||
*/
|
||
protected listener_: IProtocol;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
onClose: Function;
|
||
protected connected_: boolean;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private binary_invoke_;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private binary_parameters_;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private unhandled_invokes;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* Construct from <i>listener</i>.
|
||
*
|
||
* @param listener An {@link IProtocol} object to listen {@link Invoke} messages.
|
||
*/
|
||
constructor(listener: IProtocol);
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract close(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
isConnected(): boolean;
|
||
protected is_binary_invoke(): boolean;
|
||
abstract sendData(invoke: Invoke): void;
|
||
replyData(invoke: Invoke): void;
|
||
protected handle_string(str: string): void;
|
||
protected handle_binary(binary: Uint8Array): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
abstract class Communicator extends CommunicatorBase {
|
||
/**
|
||
* @hidden
|
||
*/
|
||
protected socket_: socket.socket;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private header_bytes_;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private data_;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private data_index_;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private listening_;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
close(): void;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
protected start_listen(): void;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private handle_error();
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private handle_close();
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
sendData(invoke: Invoke): void;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private listen_piece(piece);
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private listen_header(piece, piece_index);
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private listen_data(piece, piece_index);
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* <p> Base class for web-communicator, {@link WebClientDriver} and {@link WebServerConnector}. </p>
|
||
*
|
||
* <p> This class {@link WebCommunicatorBase} subrogates network communication for web-communicator classes,
|
||
* {@link WebClinetDriver} and {@link WebServerConnector}. The web-communicator and this class
|
||
* {@link WebCommunicatorBase} share same interface {@link IProtocol} and have a <b>chain of responsibily</b>
|
||
* relationship. </p>
|
||
*
|
||
* <p> When an {@link Invoke} message was delivered from the connected remote system, then this class calls
|
||
* web-communicator's {@link WebServerConnector.replyData replyData()} method. Also, when called web-communicator's
|
||
* {@link WebClientDriver.sendData sendData()}, then {@link sendData sendData()} of this class will be caleed. </p>
|
||
*
|
||
* <ul>
|
||
* <li> this.replyData() -> communicator.replyData() </li>
|
||
* <li> communicator.sendData() -> this.sendData() </li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
abstract class WebCommunicator extends CommunicatorBase {
|
||
/**
|
||
* Connection driver, a socket for web-socket.
|
||
*/
|
||
protected connection_: websocket.connection;
|
||
/**
|
||
* Close the connection.
|
||
*/
|
||
close(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
sendData(invoke: Invoke): void;
|
||
/**
|
||
* <p> Handle raw-data received from the remote system. </p>
|
||
*
|
||
* <p> Queries raw-data received from the remote system. When the raw-data represents an formal {@link Invoke}
|
||
* message, then it will be sent to the {@link replyData}. </p>
|
||
*
|
||
* @param message A raw-data received from the remote system.
|
||
*/
|
||
protected handle_message(message: websocket.IMessage): void;
|
||
protected handle_close(): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
abstract class SharedWorkerCommunicator extends CommunicatorBase {
|
||
protected port_: MessagePort;
|
||
close(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
sendData(invoke: Invoke): void;
|
||
protected handle_message(event: MessageEvent): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* <p> An interface for communicator with connected client. </p>
|
||
*
|
||
* <p> {@link IClientDriver} is a type of {@link ICommunicator}, specified for communication with connected client
|
||
* in a server. It takes full charge of network communication with the connected client. </p>
|
||
*
|
||
* <p> {@link IClientDriver} is created in {@link IServer} and delivered via
|
||
* {@link IServer.addClient IServer.addClient()}. Those are derived types from this {@link IClientDriver}, being
|
||
* created by matched {@link IServer} object. </p>
|
||
*
|
||
* <table>
|
||
* <tr>
|
||
* <th> Derived Type </th>
|
||
* <th> Created By </th>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> {@link ClientDrvier} </td>
|
||
* <td> {@link Server} </td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> {@link WebClientDrvier} </td>
|
||
* <td> {@link WebServer} </td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> {@link SharedWorkerClientDrvier} </td>
|
||
* <td> {@link SharedWorkerServer} </td>
|
||
* </tr>
|
||
* </table>
|
||
*
|
||
* <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
|
||
* target="_blank">
|
||
* <img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
|
||
* style="max-width: 100%" />
|
||
* </a> </p>
|
||
*
|
||
* <p> When you've got an {@link IClientDriver} object from the {@link IServer.addClient IServer.addClient()}, then
|
||
* specify {@link CommunicatorBase.listener listener} with {@link IClient.listen IClient.listen()}. Below codes are
|
||
* an example specifying and managing the {@link CommunicatorBase.listener listener} objects. </p>
|
||
*
|
||
* <code>
|
||
/// <reference path="../typings/typescript-stl/typescript-stl.d.ts" />
|
||
/// <reference path="../typings/samchon-framework/samchon-framework.d.ts" />
|
||
|
||
// IMPORTS
|
||
import std = require("typescript-stl");
|
||
import samchon = require("samchon-framework");
|
||
|
||
// SHORTCUTS
|
||
import library = samchon.library;
|
||
import protocol = samchon.protocol;
|
||
|
||
class CalculatorServer extends protocol.Server
|
||
{
|
||
private clients: std.HashSet<CalculatorClient>;
|
||
|
||
// WHEN A CLIENT HAS CONNECTED
|
||
public addClient(driver: IClientDriver): void
|
||
{
|
||
let client: CalculatorClient = new CalculatorClient(this, driver);
|
||
this.clients.insert(client);
|
||
}
|
||
}
|
||
|
||
class CalculatorClient extends protocol.IProtocol
|
||
{
|
||
// PARENT SERVER INSTANCE
|
||
private server: CalculatorServer;
|
||
|
||
// COMMUNICATOR, SENDS AND RECEIVES NETWORK MESSAGE WITH CONNECTED CLIENT
|
||
private driver: protocol.IClientDriver;
|
||
|
||
/////
|
||
// CONSTRUCTORS
|
||
/////
|
||
public constructor(server: CalculatorServer, driver: protocol.IClientDriver)
|
||
{
|
||
this.server = server;
|
||
this.driver = driver;
|
||
|
||
// START LISTENING AND RESPOND CLOSING EVENT
|
||
this.driver.listen(this); // INVOKE MESSAGE WILL COME TO HERE
|
||
this.driver.onClose = this.destructor.bind(this); // DISCONNECTED HANDLER
|
||
}
|
||
public destructor(): void
|
||
{
|
||
// WHEN DISCONNECTED, THEN ERASE THIS OBJECT FROM CalculatorServer.clients.
|
||
this.server["clients"].erase(this);
|
||
}
|
||
|
||
/////
|
||
// INVOKE MESSAGE CHAIN
|
||
/////
|
||
public sendData(invoke: protocol.Invoke): void
|
||
{
|
||
// CALL ICommunicator.sendData(), WHO PHYSICALLY SEND NETWORK MESSAGE
|
||
this.driver.sendData(invoke);
|
||
}
|
||
public replyData(invoke: protocol.Invoke): void
|
||
{
|
||
// FIND MATCHED MEMBER FUNCTION NAMED EQUAL TO THE invoke.getListener()
|
||
invoke.apply(this);
|
||
}
|
||
}
|
||
* </code>
|
||
*
|
||
*
|
||
* <h2> Basic Components </h2>
|
||
* <h4> What Basic Components are </h4>
|
||
* <p> <b>Basic Components</b> are the smallest unit of network communication in this <i>Samchon Framework</i>. With
|
||
* <b>Basic Components</b>, you can construct any type of network system, even how the network system is enormously
|
||
* scaled and complicated, by just combinating the <b>Basic Components</b>. </p>
|
||
*
|
||
* <p> All the system templates in this framework are also being implemented by utilization of the
|
||
* <b>Basic Compoonents</b>. </p>
|
||
*
|
||
* <ul>
|
||
* <li> {@link service Service} </il>
|
||
* <li> {@link external External System} </il>
|
||
* <li> {@link parallel Parallel System} </il>
|
||
* <li> {@link distributed Distributed System} </il>
|
||
* </ul>
|
||
*
|
||
* <p> Note that, whatever the network system what you've to construct is, just concentrate on role of each system
|
||
* and attach matched <b>Basic Components</b> to the role, within framework of the <b>Object-Oriented Design</b>.
|
||
* Then construction of the network system will be much easier. </p>
|
||
*
|
||
* <ul>
|
||
* <li> A system is a server, then use {@link IServer} or {@link IServerBase}. </li>
|
||
* <li> A server wants to handle a client has connected, then use {@link IClientDriver}. </li>
|
||
* <li> A system is a client connecting to an external server, then use {@link IServerConnector}. </li>
|
||
* <li> </li>
|
||
* </ul>
|
||
*
|
||
* <h4> Example - System Templates </h4>
|
||
* <p> Learning and understanding <i>Basic Components</i> of Samchon Framework, reading source codes and design of
|
||
* <b>System Templates</b>' modules will be very helpful. </p>
|
||
*
|
||
* <table>
|
||
* <tr>
|
||
* <th> Name </th>
|
||
* <th> Source </th>
|
||
* <th> API Documents </th>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> Cloud Service </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/service"
|
||
* target="_blank"> protocol/service </a> </td>
|
||
* <td> {@link protocol.service} </td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> External System </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/external"
|
||
* target="_blank"> protocol/external </a> </td>
|
||
* <td> {@link protocol.external} </td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> Parallel System </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/parallel"
|
||
* target="_blank"> protocol/parallel </a> </td>
|
||
* <td> {@link protocol.parallel} </td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> Distributed System </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/distributed"
|
||
* target="_blank"> protocol/distributed </a> </td>
|
||
* <td> {@link protocol.distributed} </td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> Slave System </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/slave"
|
||
* target="_blank"> protocol/slave </a> </td>
|
||
* <td> {@link protocol.slave} </td>
|
||
* </tr>
|
||
* </table>
|
||
*
|
||
* <h4> Example - Projects </h4>
|
||
* <ul>
|
||
* <li>
|
||
* <a href="https://github.com/samchon/framework/wiki/Examples-Calculator" target="_blank"> Calculator </a>
|
||
* </li>
|
||
* <li>
|
||
* <a href="https://github.com/samchon/framework/wiki/Examples-Chatting" target="_blank"> Chatting </a>
|
||
* </li>
|
||
* <li>
|
||
* <a href="https://github.com/samchon/framework/wiki/Examples-Interaction" target="_blank"> Interaction </a>
|
||
* </li>
|
||
* </ul>
|
||
*
|
||
* @see {@link IServer}
|
||
* @handbook <a href="https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iclientdriver"
|
||
* target="_blank"> Basic Components - IClientDriver </a>
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
interface IClientDriver extends ICommunicator {
|
||
/**
|
||
* <p> Listen message from the newly connected client. </p>
|
||
*
|
||
* <p> Starts listening message from the newly connected client. Replied message from the connected client will
|
||
* be converted to {@link Invoke} classes and shifted to the <i>listener</i>'s
|
||
* {@link IProtocol.replyData replyData()} method. </p>
|
||
*
|
||
* @param listener A listener object to listen replied message from newly connected client in
|
||
* {@link IProtocol.replyData replyData()} as an {@link Invoke} message.
|
||
*/
|
||
listen(listener: IProtocol): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
class ClientDriver extends Communicator implements IClientDriver {
|
||
constructor(socket: socket.socket);
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
listen(listener: IProtocol): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
class WebClientDriver extends WebCommunicator implements IClientDriver {
|
||
/**
|
||
* Requested path.
|
||
*/
|
||
private path_;
|
||
/**
|
||
* Session ID, an identifier of the remote client.
|
||
*/
|
||
private session_id_;
|
||
private listening_;
|
||
/**
|
||
* Initialization Constructor.
|
||
*
|
||
* @param connection Connection driver, a socket for web-socket.
|
||
* @param path Requested path.
|
||
* @param session_id Session ID, an identifier of the remote client.
|
||
*/
|
||
constructor(connection: websocket.connection, path: string, session_id: string);
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
listen(listener: IProtocol): void;
|
||
/**
|
||
* Get requested path.
|
||
*/
|
||
getPath(): string;
|
||
/**
|
||
* Get session ID, an identifier of the remote client.
|
||
*/
|
||
getSessionID(): string;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
class SharedWorkerClientDriver extends SharedWorkerCommunicator implements IClientDriver {
|
||
private listening;
|
||
constructor(port: MessagePort);
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
listen(listener: IProtocol): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
abstract class DedicatedWorker implements IProtocol {
|
||
private communicator_;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
abstract replyData(invoke: protocol.Invoke): void;
|
||
sendData(invoke: Invoke): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
class DedicatedWorkerConnector extends CommunicatorBase implements IServerConnector {
|
||
private worker;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
onConnect: Function;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
onClose: Function;
|
||
constructor(listener: IProtocol);
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
connect(jsFile: string): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
close(): void;
|
||
sendData(invoke: Invoke): void;
|
||
replyData(invoke: Invoke): void;
|
||
private handle_message(event);
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* A container of entity, and it's a type of entity, too.
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
interface IEntityGroup<T extends IEntity> extends IEntity, std.base.IContainer<T> {
|
||
/**
|
||
* <p> Construct data of the Entity from an XML object. </p>
|
||
*
|
||
* <p> Constructs the EntityArray's own member variables only from the input XML object. </p>
|
||
*
|
||
* <p> Do not consider about constructing children Entity objects' data in EntityArray::construct().
|
||
* Those children Entity objects' data will constructed by their own construct() method. Even insertion
|
||
* of XML objects representing children are done by abstract method of EntityArray::toXML(). </p>
|
||
*
|
||
* <p> Constructs only data of EntityArray's own. </p>
|
||
*/
|
||
construct(xml: library.XML): void;
|
||
/**
|
||
* <p> Factory method of a child Entity. </p>
|
||
*
|
||
* <p> EntityArray::createChild() is a factory method creating a new child Entity which is belonged
|
||
* to the EntityArray. This method is called by EntityArray::construct(). The children construction
|
||
* methods Entity::construct() will be called by abstract method of the EntityArray::construct(). </p>
|
||
*
|
||
* @return A new child Entity belongs to EntityArray.
|
||
*/
|
||
createChild(xml: library.XML): T;
|
||
/**
|
||
* <p> Get iterator to element. </p>
|
||
*
|
||
* <p> Searches the container for an element with a identifier equivalent to <i>key</i> and returns an
|
||
* iterator to it if found, otherwise it returns an iterator to {@link end end()}. </p>
|
||
*
|
||
* <p> Two keys are considered equivalent if the container's comparison object returns false reflexively
|
||
* (i.e., no matter the order in which the elements are passed as arguments). </p>
|
||
*
|
||
* <p> Another member functions, {@link has has()} and {@link count count()}, can be used to just check
|
||
* whether a particular <i>key</i> exists. </p>
|
||
*
|
||
* @param key Key to be searched for
|
||
* @return An iterator to the element, if an element with specified <i>key</i> is found, or
|
||
* {@link end end()} otherwise.
|
||
*/
|
||
/**
|
||
* <p> Whether have the item or not. </p>
|
||
*
|
||
* <p> Indicates whether a map has an item having the specified identifier. </p>
|
||
*
|
||
* @param key Key value of the element whose mapped value is accessed.
|
||
*
|
||
* @return Whether the map has an item having the specified identifier.
|
||
*/
|
||
has(key: any): boolean;
|
||
/**
|
||
* <p> Count elements with a specific key. </p>
|
||
*
|
||
* <p> Searches the container for elements whose key is <i>key</i> and returns the number of elements found. </p>
|
||
*
|
||
* @param key Key value to be searched for.
|
||
*
|
||
* @return The number of elements in the container with a <i>key</i>.
|
||
*/
|
||
count(key: any): number;
|
||
/**
|
||
* <p> Get an element </p>
|
||
*
|
||
* <p> Returns a reference to the mapped value of the element identified with <i>key</i>. </p>
|
||
*
|
||
* @param key Key value of the element whose mapped value is accessed.
|
||
*
|
||
* @throw exception out of range
|
||
*
|
||
* @return A reference object of the mapped value (_Ty)
|
||
*/
|
||
get(key: any): T;
|
||
/**
|
||
* <p> A tag name of children objects. </p>
|
||
*/
|
||
CHILD_TAG(): string;
|
||
/**
|
||
* <p> Get an XML object represents the EntityArray. </p>
|
||
*
|
||
* <p> Archives the EntityArray's own member variables only to the returned XML object. </p>
|
||
*
|
||
* <p> Do not consider about archiving children Entity objects' data in EntityArray::toXML().
|
||
* Those children Entity objects will converted to XML object by their own toXML() method. The
|
||
* insertion of XML objects representing children are done by abstract method of
|
||
* EntityArray::toXML(). </p>
|
||
*
|
||
* <p> Archives only data of EntityArray's own. </p>
|
||
*/
|
||
toXML(): library.XML;
|
||
}
|
||
/**
|
||
* @hidden
|
||
*/
|
||
namespace IEntityGroup {
|
||
/**
|
||
* @hidden
|
||
*/
|
||
function construct<T extends IEntity>(entityGroup: IEntityGroup<T>, xml: library.XML, ...prohibited_names: string[]): void;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
function toXML<T extends IEntity>(entityGroup: IEntityGroup<T>, ...prohibited_names: string[]): library.XML;
|
||
function has<T extends IEntity>(entityGroup: IEntityGroup<T>, key: any): boolean;
|
||
function count<T extends IEntity>(entityGroup: IEntityGroup<T>, key: any): number;
|
||
function get<T extends IEntity>(entityGroup: IEntityGroup<T>, key: any): T;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract class EntityArray<T extends IEntity> extends std.Vector<T> implements IEntityGroup<T> {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
construct(xml: library.XML): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract createChild(xml: library.XML): T;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
key(): any;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
has(key: any): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
count(key: any): number;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
get(key: any): T;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract TAG(): string;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract CHILD_TAG(): string;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
toXML(): library.XML;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract class EntityList<T extends IEntity> extends std.List<T> implements IEntityGroup<T> {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
construct(xml: library.XML): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract createChild(xml: library.XML): T;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
key(): any;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
has(key: any): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
count(key: any): number;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
get(key: any): T;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract TAG(): string;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract CHILD_TAG(): string;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
toXML(): library.XML;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract class EntityDeque<T extends IEntity> extends std.Deque<T> implements IEntityGroup<T> {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
construct(xml: library.XML): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract createChild(xml: library.XML): T;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
key(): any;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
has(key: any): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
count(key: any): number;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
get(key: any): T;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract TAG(): string;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract CHILD_TAG(): string;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
toXML(): library.XML;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
interface IEntityCollection<T extends IEntity> extends IEntityGroup<T>, collection.ICollection<T> {
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract class EntityArrayCollection<T extends IEntity> extends collection.ArrayCollection<T> implements IEntityCollection<T> {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
construct(xml: library.XML): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract createChild(xml: library.XML): T;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
key(): any;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
has(key: any): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
count(key: any): number;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
get(key: any): T;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract TAG(): string;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract CHILD_TAG(): string;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
toXML(): library.XML;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract class EntityListCollection<T extends IEntity> extends collection.ListCollection<T> implements IEntityCollection<T> {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
construct(xml: library.XML): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract createChild(xml: library.XML): T;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
key(): any;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
has(key: any): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
count(key: any): number;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
get(key: any): T;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract TAG(): string;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract CHILD_TAG(): string;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
toXML(): library.XML;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract class EntityDequeCollection<T extends IEntity> extends collection.DequeCollection<T> implements IEntityCollection<T> {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
construct(xml: library.XML): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract createChild(xml: library.XML): T;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
key(): any;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
has(key: any): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
count(key: any): number;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
get(key: any): T;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract TAG(): string;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract CHILD_TAG(): string;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
toXML(): library.XML;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* <p> An interface for {@link Invoke} message chain. </p>
|
||
*
|
||
* <p> {@link IProtocol} is an interface for {@link Invoke} message, which is standard message of network I/O in
|
||
* <i>Samchon Framework</i>, chain. The {@link IProtocol} interface is used to network drivers and some classes
|
||
* which are in a relationship of <i>Chain of Responsibility Pattern</i> with those network drivers. </p>
|
||
*
|
||
* <p> Implements {@link IProtocol} if the class sends and handles {@link Invoke} message. Looking around source
|
||
* codes of <i>Samchon Framework</i>, especially <i>System Templates</i>, you can find out that all the classes and
|
||
* modules handling {@link Invoke} messages are always implementing this {@link IProtocol} . Yes, {@link IProtocol},
|
||
* this is the main role you've to follow in this <i>Samchon Framework</i>. </p>
|
||
*
|
||
* <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
|
||
* target="_blank">
|
||
* <img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
|
||
* style="max-width: 100%" />
|
||
* </a> </p>
|
||
*
|
||
*
|
||
* <h2> Utilization Case </h2>
|
||
* <p> Below pseudo code and class diagram represents {@link service Service Module}, who can build a cloud server.
|
||
* All the classes in the pseudo code are implementing the {@link IProtocol} because all of them are handling
|
||
* {@link Invoke} message. </p>
|
||
*
|
||
* <ul>
|
||
* <li> Server: Represents a server literally </li>
|
||
* <li> User: Represents an user being identified by its session id. User contains multiple Client objects. </li>
|
||
* <ul>
|
||
* <li> In browser, an user can open multiple windows.
|
||
* <ul>
|
||
* <li> User: A browser (like IE, Chrome and Safari).
|
||
* <li> Client: An internet browser window
|
||
* </ul>
|
||
* </li>
|
||
* </ul>
|
||
* <li> Client: Represents a browser window and it takes role of network communication with it. </li>
|
||
* <li> Service: Represents a service, domain logic. </li>
|
||
* </ul>
|
||
*
|
||
* <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_service.png"
|
||
* target="_blank">
|
||
* <img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_service.png"
|
||
* style="max-width: 100%" />
|
||
* </a> </p>
|
||
*
|
||
* <code>
|
||
/// <reference path="../typings/typescript-stl/typescript-stl.d.ts" />
|
||
/// <reference path="../typings/samchon-framework/samchon-framework.d.ts" />
|
||
|
||
// IMPORTS
|
||
import std = require("typescript-stl");
|
||
import samchon = require("samchon-framework");
|
||
|
||
// SHORTCUTS
|
||
import library = samchon.library;
|
||
import collection = samchon.collection;
|
||
import protocol = samchon.protocol;
|
||
|
||
namespace service
|
||
{
|
||
export class Server extends protocol.WebServer implements IProtocol
|
||
{
|
||
// SERVER HAS MULTIPLE USER OBJECTS
|
||
private session_map: std.HashMap<string, User>;
|
||
|
||
//------------------------
|
||
// MESSAGE CHAIN
|
||
//------------------------
|
||
public sendData(invoke: protocol.Invoke): void
|
||
{
|
||
// SEND INVOKE MESSAGE TO ALL USER OBJECTS
|
||
for (let it = this.session_map.begin(); !it.equal_to(this.session_map.end()); it = it.next())
|
||
it.second.sendData(invoke);
|
||
}
|
||
public replyData(invoke: protocol.Invoke): void
|
||
{
|
||
invoke.apply(this); // HANDLE INVOKE MESSAGE BY ITSELF
|
||
}
|
||
}
|
||
|
||
export class User extends
|
||
collection.HashMapCollection<number, Client> // USER HAS MULTIPLE CLIENT OBJECTS
|
||
implements IProtocol
|
||
{
|
||
private server: Server; // USER REFRES SERVER
|
||
|
||
//------------------------
|
||
// MESSAGE CHAIN
|
||
//------------------------
|
||
public sendData(invoke: protocol.Invoke): void
|
||
{
|
||
// SEND INVOKE MESSAGE TO ALL CLIENT OBJECTS
|
||
for (let it = this.begin(); !it.equal_to(this.end()); it = it.next())
|
||
it.second.sendData(invoke);
|
||
}
|
||
public replyData(invoke: protocol.Invoke): void
|
||
{
|
||
invoke.apply(this); // HANDLE INOVKE MESSAGE BY ITSELF
|
||
this.server.replyData(invoke); // OR VIA SERVER
|
||
}
|
||
}
|
||
|
||
export class Client implements IProtocol
|
||
{
|
||
private user: User; // CLIENT REFERS USER
|
||
private service: Service; // CLIENT HAS A SERVICE OBJECT
|
||
|
||
private driver: WebClientDriver;
|
||
|
||
//------------------------
|
||
// MESSAGE CHAIN
|
||
//------------------------
|
||
public sendData(invoke: protocol.Invoke): void
|
||
{
|
||
// SEND INVOKE MESSAGE VIA driver: WebClientDriver
|
||
this.driver.sendData(invoke);
|
||
}
|
||
public replyData(invoke: protocol.Invoke): void
|
||
{
|
||
invoke.apply(this); // HANDLE INOVKE MEESAGE BY ITSELF
|
||
this.user.replyData(invoke); // OR VIA USER
|
||
|
||
if (this.service != null) // OR VIA SERVICE
|
||
this.service.replyData(invoke);
|
||
}
|
||
}
|
||
|
||
export class Service implements IProtocol
|
||
{
|
||
private client: Client; // SERVICE REFRES CLIENT
|
||
|
||
//------------------------
|
||
// MESSAGE CHAIN
|
||
//------------------------
|
||
public sendData(invoke: protocol.Invoke): void
|
||
{
|
||
// SEND INVOKE MESSAGE VIA CLIENT
|
||
return this.client.sendData(invoke);
|
||
}
|
||
public replyData(invoke: protocol.Invoke): void
|
||
{
|
||
invoke.apply(this); // HANDLE INVOKE MESSAGE BY ITSELF
|
||
}
|
||
}
|
||
}
|
||
* </code>
|
||
*
|
||
*
|
||
* <h2> Basic Components </h2>
|
||
* <h4> What Basic Components are </h4>
|
||
* <p> <b>Basic Components</b> are the smallest unit of network communication in this <i>Samchon Framework</i>. With
|
||
* <b>Basic Components</b>, you can construct any type of network system, even how the network system is enormously
|
||
* scaled and complicated, by just combinating the <b>Basic Components</b>. </p>
|
||
*
|
||
* <p> All the system templates in this framework are also being implemented by utilization of the
|
||
* <b>Basic Compoonents</b>. </p>
|
||
*
|
||
* <ul>
|
||
* <li> {@link service Service} </il>
|
||
* <li> {@link external External System} </il>
|
||
* <li> {@link parallel Parallel System} </il>
|
||
* <li> {@link distributed Distributed System} </il>
|
||
* </ul>
|
||
*
|
||
* <p> Note that, whatever the network system what you've to construct is, just concentrate on role of each system
|
||
* and attach matched <b>Basic Components</b> to the role, within framework of the <b>Object-Oriented Design</b>.
|
||
* Then construction of the network system will be much easier. </p>
|
||
*
|
||
* <ul>
|
||
* <li> A system is a server, then use {@link IServer} or {@link IServerBase}. </li>
|
||
* <li> A server wants to handle a client has connected, then use {@link IClientDriver}. </li>
|
||
* <li> A system is a client connecting to an external server, then use {@link IServerConnector}. </li>
|
||
* <li> </li>
|
||
* </ul>
|
||
*
|
||
* <h4> Example - System Templates </h4>
|
||
* <p> Learning and understanding <i>Basic Components</i> of Samchon Framework, reading source codes and design of
|
||
* <b>System Templates</b>' modules will be very helpful. </p>
|
||
*
|
||
* <table>
|
||
* <tr>
|
||
* <th> Name </th>
|
||
* <th> Source </th>
|
||
* <th> API Documents </th>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> Cloud Service </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/service"
|
||
* target="_blank"> protocol/service </a> </td>
|
||
* <td> {@link protocol.service} </td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> External System </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/external"
|
||
* target="_blank"> protocol/external </a> </td>
|
||
* <td> {@link protocol.external} </td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> Parallel System </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/parallel"
|
||
* target="_blank"> protocol/parallel </a> </td>
|
||
* <td> {@link protocol.parallel} </td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> Distributed System </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/distributed"
|
||
* target="_blank"> protocol/distributed </a> </td>
|
||
* <td> {@link protocol.distributed} </td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> Slave System </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/slave"
|
||
* target="_blank"> protocol/slave </a> </td>
|
||
* <td> {@link protocol.slave} </td>
|
||
* </tr>
|
||
* </table>
|
||
*
|
||
* <h4> Example - Projects </h4>
|
||
* <ul>
|
||
* <li>
|
||
* <a href="https://github.com/samchon/framework/wiki/Examples-Calculator" target="_blank"> Calculator </a>
|
||
* </li>
|
||
* <li>
|
||
* <a href="https://github.com/samchon/framework/wiki/Examples-Chatting" target="_blank"> Chatting </a>
|
||
* </li>
|
||
* <li>
|
||
* <a href="https://github.com/samchon/framework/wiki/Examples-Interaction" target="_blank"> Interaction </a>
|
||
* </li>
|
||
* </ul>
|
||
*
|
||
* @see {@link Invoke}
|
||
* @handbook <a href="https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iprotocol"
|
||
* target="_blank"> Basic Components - IProtocol </a>
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
interface IProtocol {
|
||
/**
|
||
* <p> Sending message. </p>
|
||
* <p> Sends message to related system or shifts the responsibility to chain. </p>
|
||
*
|
||
* @param invoke Invoke message to send
|
||
*/
|
||
replyData(invoke: Invoke): void;
|
||
/**
|
||
* <p> Handling replied message. </p>
|
||
* <p> Handles replied message or shifts the responsibility to chain. </p>
|
||
*
|
||
* @param invoke An {@link Invoke} message has received.
|
||
*/
|
||
sendData(invoke: Invoke): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* <p> Standard message of network I/O. </p>
|
||
*
|
||
* <p> {@link Invoke} is a class used in network I/O in protocol package of Samchon Framework. </p>
|
||
*
|
||
* <p> The Invoke message has an XML structure like the result screen of provided example in below.
|
||
* We can enjoy lots of benefits by the normalized and standardized message structure used in
|
||
* network I/O. </p>
|
||
*
|
||
* <p> The greatest advantage is that we can make any type of network system, even how the system
|
||
* is enourmously complicated. As network communication message is standardized, we only need to
|
||
* concentrate on logical relationships between network systems. We can handle each network system
|
||
* like a object (class) in OOD. And those relationships can be easily designed by using design
|
||
* pattern. </p>
|
||
*
|
||
* <p> In Samchon Framework, you can make any type of network system with basic componenets
|
||
* (IProtocol, IServer and ICommunicator) by implemens or inherits them, like designing
|
||
* classes of S/W architecture. </p>
|
||
*
|
||
* @see IProtocol
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class Invoke extends EntityArray<InvokeParameter> {
|
||
/**
|
||
* <p> Listener, represent function's name. </p>
|
||
*/
|
||
private listener;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
constructor(listener: string);
|
||
/**
|
||
* Copy Constructor.
|
||
*
|
||
* @param invoke
|
||
*/
|
||
constructor(invoke: Invoke);
|
||
/**
|
||
* Construct from listener and parametric values.
|
||
*
|
||
* @param listener
|
||
* @param parameters
|
||
*/
|
||
constructor(listener: string, ...parameters: Array<number | string | library.XML>);
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
createChild(xml: library.XML): InvokeParameter;
|
||
/**
|
||
* Get listener.
|
||
*/
|
||
getListener(): string;
|
||
/**
|
||
* <p> Get arguments for Function.apply(). </p>
|
||
*
|
||
* @return An array containing values of the contained parameters.
|
||
*/
|
||
getArguments(): Array<any>;
|
||
/**
|
||
* <p> Apply to a matched function. </p>
|
||
*/
|
||
apply(obj: IProtocol): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
TAG(): string;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
CHILD_TAG(): string;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* A parameter belongs to an Invoke.
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class InvokeParameter extends Entity {
|
||
/**
|
||
* <p> Name of the parameter. </p>
|
||
*
|
||
* @details Optional property, can be omitted.
|
||
*/
|
||
protected name: string;
|
||
/**
|
||
* <p> Type of the parameter. </p>
|
||
*/
|
||
protected type: string;
|
||
/**
|
||
* <p> Value of the parameter. </p>
|
||
*/
|
||
protected value: string | number | library.XML | Uint8Array;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
constructor(val: number);
|
||
constructor(val: string);
|
||
constructor(val: library.XML);
|
||
constructor(val: Uint8Array);
|
||
/**
|
||
* Construct from variable name and number value.
|
||
*
|
||
* @param name
|
||
* @param val
|
||
*/
|
||
constructor(name: string, val: number);
|
||
constructor(name: string, val: string);
|
||
constructor(name: string, val: library.XML);
|
||
constructor(name: string, val: Uint8Array);
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
construct(xml: library.XML): void;
|
||
setValue(value: number): void;
|
||
setValue(value: string): void;
|
||
setValue(value: library.XML): void;
|
||
setValue(value: Uint8Array): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
key(): any;
|
||
/**
|
||
* Get name.
|
||
*/
|
||
getName(): string;
|
||
/**
|
||
* Get type.
|
||
*/
|
||
getType(): string;
|
||
/**
|
||
* Get value.
|
||
*/
|
||
getValue(): any;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
TAG(): string;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
toXML(): library.XML;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
class InvokeHistory extends Entity {
|
||
/**
|
||
*
|
||
*/
|
||
private uid;
|
||
/**
|
||
* @see {@link Invoke.listener}
|
||
*/
|
||
private listener;
|
||
/**
|
||
*
|
||
*/
|
||
private start_time_;
|
||
/**
|
||
*
|
||
*/
|
||
private end_time_;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
constructor(invoke: Invoke);
|
||
construct(xml: library.XML): void;
|
||
complete(): void;
|
||
key(): number;
|
||
getUID(): number;
|
||
getListener(): string;
|
||
getStartTime(): Date;
|
||
getEndTime(): Date;
|
||
computeElapsedTime(): number;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
TAG(): string;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
toXML(): library.XML;
|
||
toInvoke(): Invoke;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* <p> An interface for a physical server. </p>
|
||
*
|
||
* <p> {@link IServer} provides methods for opening a server. Extends one of them who are derived from this
|
||
* {@link IServer} and open the server with method {@link open IServer.open()}. Override
|
||
* {@link addClient IServer.addClient()} who accepts a newly connected client with {@link IClientDriver}.
|
||
* If you're embarrased because your class already extended another one, then use {@link IServerBase}. </p>
|
||
*
|
||
* <ul>
|
||
* <li> {@link Server} </li>
|
||
* <li> {@link WebServer} </li>
|
||
* <li> {@link SharedWorkerServer} </li>
|
||
* </ul>
|
||
*
|
||
* <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
|
||
* target="_blank">
|
||
* <img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_basic_components.png"
|
||
* style="max-width: 100%" />
|
||
* </a> </p>
|
||
*
|
||
* <h2> Basic Components </h2>
|
||
* <h4> What Basic Components are </h4>
|
||
* <p> <b>Basic Components</b> are the smallest unit of network communication in this <i>Samchon Framework</i>. With
|
||
* <b>Basic Components</b>, you can construct any type of network system, even how the network system is enormously
|
||
* scaled and complicated, by just combinating the <b>Basic Components</b>. </p>
|
||
*
|
||
* <p> All the system templates in this framework are also being implemented by utilization of the
|
||
* <b>Basic Compoonents</b>. </p>
|
||
*
|
||
* <ul>
|
||
* <li> {@link service Service} </il>
|
||
* <li> {@link external External System} </il>
|
||
* <li> {@link parallel Parallel System} </il>
|
||
* <li> {@link distributed Distributed System} </il>
|
||
* </ul>
|
||
*
|
||
* <p> Note that, whatever the network system what you've to construct is, just concentrate on role of each system
|
||
* and attach matched <b>Basic Components</b> to the role, within framework of the <b>Object-Oriented Design</b>.
|
||
* Then construction of the network system will be much easier. </p>
|
||
*
|
||
* <ul>
|
||
* <li> A system is a server, then use {@link IServer} or {@link IServerBase}. </li>
|
||
* <li> A server wants to handle a client has connected, then use {@link IClientDriver}. </li>
|
||
* <li> A system is a client connecting to an external server, then use {@link IServerConnector}. </li>
|
||
* <li> </li>
|
||
* </ul>
|
||
*
|
||
* <h4> Example - System Templates </h4>
|
||
* <p> Learning and understanding <i>Basic Components</i> of Samchon Framework, reading source codes and design of
|
||
* <b>System Templates</b>' modules will be very helpful. </p>
|
||
*
|
||
* <table>
|
||
* <tr>
|
||
* <th> Name </th>
|
||
* <th> Source </th>
|
||
* <th> API Documents </th>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> Cloud Service </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/service"
|
||
* target="_blank"> protocol/service </a> </td>
|
||
* <td> {@link protocol.service} </td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> External System </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/external"
|
||
* target="_blank"> protocol/external </a> </td>
|
||
* <td> {@link protocol.external} </td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> Parallel System </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/parallel"
|
||
* target="_blank"> protocol/parallel </a> </td>
|
||
* <td> {@link protocol.parallel} </td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> Distributed System </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/distributed"
|
||
* target="_blank"> protocol/distributed </a> </td>
|
||
* <td> {@link protocol.distributed} </td>
|
||
* </tr>
|
||
* <tr>
|
||
* <td> Slave System </td>
|
||
* <td> <a href="https://github.com/samchon/framework/tree/master/ts/src/samchon/protocol/slave"
|
||
* target="_blank"> protocol/slave </a> </td>
|
||
* <td> {@link protocol.slave} </td>
|
||
* </tr>
|
||
* </table>
|
||
*
|
||
* <h4> Example - Projects </h4>
|
||
* <ul>
|
||
* <li>
|
||
* <a href="https://github.com/samchon/framework/wiki/Examples-Calculator" target="_blank"> Calculator </a>
|
||
* </li>
|
||
* <li>
|
||
* <a href="https://github.com/samchon/framework/wiki/Examples-Chatting" target="_blank"> Chatting </a>
|
||
* </li>
|
||
* <li>
|
||
* <a href="https://github.com/samchon/framework/wiki/Examples-Interaction" target="_blank"> Interaction </a>
|
||
* </li>
|
||
* </ul>
|
||
*
|
||
* @see {@link IClientDriver}
|
||
* @handbook <a href="https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserver"
|
||
* target="_blank"> Basic Components - IServer </a>
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
interface IServer {
|
||
open(port: number): void;
|
||
close(): void;
|
||
addClient(clientDriver: IClientDriver): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
abstract class Server implements IServer {
|
||
private server;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract addClient(driver: ClientDriver): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
open(port: number): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
close(): void;
|
||
private handle_connect(socket);
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
abstract class WebServer implements IServer {
|
||
/**
|
||
* A server handler.
|
||
*/
|
||
private http_server_;
|
||
/**
|
||
* Sequence number for issuing session id.
|
||
*/
|
||
private sequence_;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private my_port_;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
open(port: number): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
close(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract addClient(driver: WebClientDriver): void;
|
||
/**
|
||
* <p> Handle request from a client system. </p>
|
||
*
|
||
* <p> This method {@link handle_request} will be called when a client is connected. It will call an abstract
|
||
* method method {@link addClient addClient()} who handles an accepted client. If the newly connected client
|
||
* doesn't have its own session id, then a new session id will be issued. </p>
|
||
*
|
||
* @param request Requested header.
|
||
*/
|
||
private handle_request(request);
|
||
/**
|
||
* <p> Get session id from a newly connected. </p>
|
||
*
|
||
* <p> Queries ordinary session id from cookies of a newly connected client. If the client has not, a new
|
||
* session id will be issued. </p>
|
||
*
|
||
* @param cookies Cookies from the remote client.
|
||
*/
|
||
private get_session_id(cookies);
|
||
/**
|
||
* Issue a new session id.
|
||
*/
|
||
private issue_session_id();
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
abstract class SharedWorkerServer implements IServer {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
abstract addClient(driver: SharedWorkerClientDriver): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
open(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
close(): void;
|
||
private handle_connect(event);
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* <p> An interface for substitute server classes. </p>
|
||
*
|
||
* <p> {@link IServerBase} is an interface for substitue server classes who subrogate server's role. </p>
|
||
*
|
||
* <p> The easiest way to defining a server class is to extending one of them, who are derived from the
|
||
* {@link IServer}. </p>
|
||
*
|
||
* <ul>
|
||
* <li> {@link Server} </li>
|
||
* <li> {@link WebServer} </li>
|
||
* <li> {@link SharedWorkerServer} </li>
|
||
* </ul>
|
||
*
|
||
* <p> However, it is impossible (that is, if the class is already extending another class), you can instead implement
|
||
* the {@link IServer} interface, create an {@link IServerBase} member, and write simple hooks to route calls into the
|
||
* aggregated {@link IServerBase}. </p>
|
||
*
|
||
* <p> {@link ExternalClientArray} can be a good example using this {@link IServerBase}. </p>
|
||
* <ul>
|
||
* <li> https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/external/ExternalClientArray.ts </li>
|
||
* </ul>
|
||
*
|
||
* <code>
|
||
class MyServer extends Something implements IServer
|
||
{
|
||
private server_base: IServerBase = new WebServerBase(this);
|
||
|
||
public addClient(driver: IClientDriver): void
|
||
{
|
||
// WHAT TO DO WHEN A CLIENT HAS CONNECTED
|
||
}
|
||
|
||
public open(port: number): void
|
||
{
|
||
this.server_base.open();
|
||
}
|
||
public close(): void
|
||
{
|
||
this.server_base.close();
|
||
}
|
||
}
|
||
* </code>
|
||
*
|
||
* @see {@link IServer}
|
||
* @handbook <a href="https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverbase"
|
||
* target="_blank"> Basic Components - IServerBase </a>
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
interface IServerBase extends IServer {
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* <p> A substitute {@link Server}. </p>
|
||
*
|
||
* <p> {@link ServerBase} is a substitute class who subrogates {@link Server}'s responsibility. </p>
|
||
*
|
||
* <p> The easiest way to defning a server class following normal protocol of Samchon Framework is to extending
|
||
* {@link Server}. However, it is impossible (that is, if the class is already extending another class), you can
|
||
* instead implement the {@link IServer} interface, create a {@link ServerBase} member, and write simple hooks
|
||
* to route calls into the aggregated {@link ServerBase}. </p>
|
||
*
|
||
* <p> {@link ExternalClientArray} can be a good example using this {@link IServerBase}. </p>
|
||
* <ul>
|
||
* <li> https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/external/ExternalClientArray.ts </li>
|
||
* </ul>
|
||
*
|
||
* <code>
|
||
class MyServer extends Something implements IServer
|
||
{
|
||
private server_base: ServerBase = new ServerBase(this);
|
||
|
||
public addClient(driver: ClientDriver): void
|
||
{
|
||
// WHAT TO DO WHEN A CLIENT HAS CONNECTED
|
||
}
|
||
|
||
public open(port: number): void
|
||
{
|
||
this.server_base.open();
|
||
}
|
||
public close(): void
|
||
{
|
||
this.server_base.close();
|
||
}
|
||
}
|
||
* </code>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class ServerBase extends Server implements IServerBase {
|
||
private target_;
|
||
constructor(target: IServer);
|
||
addClient(driver: IClientDriver): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* <p> A substitute {@link WebServer}. </p>
|
||
*
|
||
* <p> {@link WebServerBase} is a substitute class who subrogates {@link WebServer}'s responsibility. </p>
|
||
*
|
||
* <p> The easiest way to defning a server class following normal protocol of Samchon Framework is to extending
|
||
* {@link WebServer}. However, it is impossible (that is, if the class is already extending another class), you can
|
||
* instead implement the {@link IServer} interface, create a {@link WebServerBase} member, and write simple hooks to
|
||
* route calls into the aggregated {@link WebServerBase}. </p>
|
||
*
|
||
* <p> {@link ExternalClientArray} can be a good example using this {@link IServerBase}. </p>
|
||
* <ul>
|
||
* <li> https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/external/ExternalClientArray.ts </li>
|
||
* </ul>
|
||
*
|
||
* <code>
|
||
class MyServer extends Something implements IServer
|
||
{
|
||
private server_base: WebServerBase = new WebServerBase(this);
|
||
|
||
public addClient(driver: WebClientDriver): void
|
||
{
|
||
// WHAT TO DO WHEN A CLIENT HAS CONNECTED
|
||
}
|
||
|
||
public open(port: number): void
|
||
{
|
||
this.server_base.open();
|
||
}
|
||
public close(): void
|
||
{
|
||
this.server_base.close();
|
||
}
|
||
}
|
||
* </code>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class WebServerBase extends WebServer implements IServerBase {
|
||
private target_;
|
||
constructor(target: IServer);
|
||
addClient(driver: IClientDriver): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* <p> A substitute {@link SharedWorkerServer}. </p>
|
||
*
|
||
* <p> {@link SharedWorkerServerBase} is a substitute class who subrogates {@link SharedWorkerServer}'s
|
||
* responsibility. </p>
|
||
*
|
||
* <p> The easiest way to defning a server class following normal protocol of Samchon Framework is to extending
|
||
* {@link SharedWorkerServer}. However, it is impossible (that is, if the class is already extending another class),
|
||
* you can instead implement the {@link IServer} interface, create a {@link SharedWorkerServerBase} member, and write
|
||
* simple hooks to route calls into the aggregated {@link SharedWorkerServerBase}. </p>
|
||
*
|
||
* <p> {@link ExternalClientArray} can be a good example using this {@link IServerBase}. </p>
|
||
* <ul>
|
||
* <li> https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/external/ExternalClientArray.ts </li>
|
||
* </ul>
|
||
*
|
||
* <code>
|
||
class MyServer extends Something implements IServer
|
||
{
|
||
private server_base: SharedWorkerServerBase = new SharedWorkerServerBase(this);
|
||
|
||
public addClient(driver: SharedWorkerClientDriver): void
|
||
{
|
||
// WHAT TO DO WHEN A CLIENT HAS CONNECTED
|
||
}
|
||
|
||
public open(port: number): void
|
||
{
|
||
this.server_base.open();
|
||
}
|
||
public close(): void
|
||
{
|
||
this.server_base.close();
|
||
}
|
||
}
|
||
* </code>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class SharedWorkerServerBase extends SharedWorkerServer implements IServerBase {
|
||
private target_;
|
||
constructor(target: IServer);
|
||
addClient(driver: IClientDriver): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* <p> An interface for server connector. </p>
|
||
*
|
||
* <p> {@link IServerConnector} is an interface for server connector classes who ca connect to an external server
|
||
* as a client. </p>
|
||
*
|
||
* <p> Of course, {@link IServerConnector} is extended from the {@link ICommunicator}, thus, it also takes full
|
||
* charge of network communication and delivers replied message to {@link WebCommunicator.listener listener}'s
|
||
* {@link IProtocol.replyData replyData()} method. </p>
|
||
*
|
||
* @handbook <a href="https://github.com/samchon/framework/wiki/TypeScript-Protocol-Basic_Components#iserverconnector"
|
||
* target="_blank"> Basic Components - IServerConnector </a>
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
interface IServerConnector extends ICommunicator {
|
||
/**
|
||
* Callback function for connection completed.
|
||
*/
|
||
onConnect: Function;
|
||
/**
|
||
* <p> Connect to a server. </p>
|
||
*
|
||
* <p> Connects to a server with specified <i>host</i> address and <i>port</i> number. After the connection has
|
||
* succeeded, callback function {@link onConnect} is called. Listening data from the connected server also begins.
|
||
* Replied messages from the connected server will be converted to {@link Invoke} classes and will be shifted to
|
||
* the {@link WebCommunicator.listener listener}'s {@link IProtocol.replyData replyData()} method. </p>
|
||
*
|
||
* <p> If the connection fails immediately, either an event is dispatched or an exception is thrown: an error
|
||
* event is dispatched if a host was specified, and an exception is thrown if no host was specified. Otherwise,
|
||
* the status of the connection is reported by an event. If the socket is already connected, the existing
|
||
* connection is closed first. </p>
|
||
*
|
||
* @param ip The name or IP address of the host to connect to.
|
||
* If no host is specified, the host that is contacted is the host where the calling file resides.
|
||
* If you do not specify a host, use an event listener to determine whether the connection was
|
||
* successful.
|
||
* @param port The port number to connect to.
|
||
*/
|
||
connect(ip: string, port: number): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
class ServerConnector extends Communicator implements IServerConnector {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
onConnect: Function;
|
||
constructor(listener: IProtocol);
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
connect(ip: string, port: number): void;
|
||
private handle_connect(...arg);
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* <p> A server connector for web-socket protocol. </p>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
class WebServerConnector extends WebCommunicator implements IServerConnector {
|
||
/**
|
||
* <p> A socket for network I/O. </p>
|
||
*
|
||
* <p> Note that, {@link socket} is only used in web-browser environment. </p>
|
||
*/
|
||
private browser_socket_;
|
||
/**
|
||
* <p> A driver for server connection. </p>
|
||
*
|
||
* <p> Note that, {@link node_client} is only used in NodeJS environment. </p>
|
||
*/
|
||
private node_client_;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
onConnect: Function;
|
||
constructor(listener: IProtocol);
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
connect(ip: string, port: number, path?: string): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
close(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
sendData(invoke: Invoke): void;
|
||
private handle_browser_connect(event);
|
||
private handle_browser_message(event);
|
||
private handle_node_connect(connection);
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
class SharedWorkerServerConnector extends SharedWorkerCommunicator implements IServerConnector {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
onConnect: Function;
|
||
constructor(listener: IProtocol);
|
||
connect(jsFile: string): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol {
|
||
/**
|
||
* @hidden
|
||
*/
|
||
namespace socket {
|
||
type socket = any;
|
||
type server = any;
|
||
type http_server = any;
|
||
}
|
||
/**
|
||
* @hidden
|
||
*/
|
||
namespace websocket {
|
||
type connection = any;
|
||
type request = any;
|
||
type IMessage = any;
|
||
type ICookie = any;
|
||
type client = any;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.distributed {
|
||
class DSInvokeHistory extends InvokeHistory {
|
||
private system_;
|
||
private role_;
|
||
/**
|
||
* Construct from a DistributedSystem.
|
||
*
|
||
* @param system
|
||
*/
|
||
constructor(system: DistributedSystem);
|
||
/**
|
||
* Initilizer Constructor.
|
||
*
|
||
* @param system
|
||
* @param role
|
||
* @param invoke
|
||
*/
|
||
constructor(system: DistributedSystem, role: DistributedSystemRole, invoke: Invoke);
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
construct(xml: library.XML): void;
|
||
getSystem(): DistributedSystem;
|
||
getRole(): DistributedSystemRole;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
toXML(): library.XML;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.external {
|
||
/**
|
||
* <p> A role of an external system. </p>
|
||
*
|
||
* <p> The {@link ExternalSystemRole} class represents a role, <i>what to do</i> in an {@link ExternalSystem}.
|
||
* Extends this class and writes some methods related to the role. </p>
|
||
*
|
||
* <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
|
||
* target="_blank">
|
||
* <img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
|
||
* style="max-width: 100%" />
|
||
* </a> </p>
|
||
*
|
||
* <h4> Proxy Pattern </h4>
|
||
* <p> The {@link ExternalSystemRole} class can be an <i>logical proxy</i>. In framework within user, which
|
||
* {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
|
||
* important. Only interested in user's perspective is <i>which can be done</i>. </p>
|
||
*
|
||
* <p> By using the <i>logical proxy</i>, user dont't need to know which {@link ExternalSystemRole role} is belonged
|
||
* to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
|
||
* Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}. </p>
|
||
*
|
||
* <ul>
|
||
* <li>
|
||
* {@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
|
||
* from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
|
||
* </li>
|
||
* <li>
|
||
* When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
|
||
* {@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
|
||
* external system.
|
||
* </li>
|
||
* <li> Those strategy is called <i>Proxy Pattern</i>. </li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
abstract class ExternalSystemRole extends Entity implements IProtocol {
|
||
/**
|
||
* An {@link ExternalSystem external system} containing this {@link ExternalSystemRole role}.
|
||
*/
|
||
private system;
|
||
/**
|
||
* <p> A name, represents and identifies this {@link ExternalSystemRole role}. </p>
|
||
*
|
||
* <p> This {@link name} is an identifier represents this {@link ExternalSystemRole role}. This {@link name} is
|
||
* used in {@link ExternalSystemArray.getRole} and {@link ExternalSystem.get}, as a key elements. Thus, this
|
||
* {@link name} should be unique in an {@link ExternalSystemArray}.
|
||
*/
|
||
protected name: string;
|
||
/**
|
||
* Constructor from a system.
|
||
*
|
||
* @param system An external system containing this role.
|
||
*/
|
||
constructor(system: ExternalSystem);
|
||
/**
|
||
* Identifier of {@link ExternalSystemRole} is its {@link name}.
|
||
*/
|
||
key(): string;
|
||
/**
|
||
* Get external system, this role is belonged to.
|
||
*/
|
||
getSystem(): ExternalSystem;
|
||
/**
|
||
* Get name, who represents and identifies this role.
|
||
*/
|
||
getName(): string;
|
||
/**
|
||
* Send an {@link Invoke} message to the external system via {@link system}.
|
||
*
|
||
* @param invoke An {@link Invoke} message to send to the external system.
|
||
*/
|
||
sendData(invoke: Invoke): void;
|
||
/**
|
||
* <p> Handle replied {@link Invoke message} from the {@link system external system} belonged to. </p>
|
||
*
|
||
* <p> This {@link replyData replyData()} will call a member method named following {@link Invoke.listener}.
|
||
* in the <i>invoke</i>. </p>
|
||
*
|
||
* @param invoke An {@link Invoke} message received from the {@link system external system}.
|
||
*/
|
||
replyData(invoke: Invoke): void;
|
||
/**
|
||
* Tag name of the {@link ExternalSytemRole} in {@link XML}.
|
||
*
|
||
* @return <i>role</i>.
|
||
*/
|
||
TAG(): string;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.distributed {
|
||
abstract class DistributedSystemRole extends external.ExternalSystemRole {
|
||
private system_array_;
|
||
private progress_list_;
|
||
private history_list_;
|
||
protected performance: number;
|
||
constructor(systemArray: DistributedSystemArray);
|
||
getSystemArray(): DistributedSystemArray;
|
||
getPerformance(): number;
|
||
sendData(invoke: protocol.Invoke): void;
|
||
_Report_history(history: DSInvokeHistory): void;
|
||
}
|
||
}
|
||
/**
|
||
* [[include: https://raw.githubusercontent.com/samchon/framework/master/handbook/TypeScript-Protocol-External_System.md]]
|
||
*/
|
||
declare namespace samchon.protocol.external {
|
||
/**
|
||
* <p> An array and manager of {@link ExternalSystem external systems}. </p>
|
||
*
|
||
* <p> {@link ExternalSystemArray} is an abstract class contains and manages external system drivers,
|
||
* {@link ExternalSystem} objects. You can specify this {@link ExternalSystemArray} to be a server accepting
|
||
* {@link ExternalSystem external clients} or a client connecting to {@link IExternalServer external servers}. Even
|
||
* both of them is also possible. </p>
|
||
*
|
||
* <ul>
|
||
* <li> A server accepting external clients: {@link IExternalClientArray} </li>
|
||
* <li> A client connecting to external servers: {@link IExternalServerArray} </li>
|
||
* <li>
|
||
* Accepts external clients & Connects to external servers at the same time:
|
||
* {@link IExternalServerClientArray}
|
||
* </li>
|
||
* </ul>
|
||
*
|
||
* <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
|
||
* target="_blank">
|
||
* <img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
|
||
* style="max-width: 100%" />
|
||
* </a> </p>
|
||
*
|
||
* <h4> Proxy Pattern </h4>
|
||
* <p> The {@link ExternalSystemArray} class can use <i>Proxy Pattern</i>. In framework within user, which
|
||
* {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
|
||
* important. Only interested in user's perspective is <i>which can be done</i>. </p>
|
||
*
|
||
* <p> By using the <i>logical proxy</i>, user dont't need to know which {@link ExternalSystemRole role} is belonged
|
||
* to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
|
||
* Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}. </p>
|
||
*
|
||
* <ul>
|
||
* <li>
|
||
* {@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
|
||
* from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
|
||
* </li>
|
||
* <li>
|
||
* When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
|
||
* {@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
|
||
* external system.
|
||
* </li>
|
||
* <li> Those strategy is called <i>Proxy Pattern</i>. </li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
abstract class ExternalSystemArray extends EntityDequeCollection<ExternalSystem> implements IProtocol {
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private handle_system_erase(event);
|
||
/**
|
||
* Test whether this system array has the role.
|
||
*
|
||
* @param name Name, identifier of target {@link ExternalSystemRole role}.
|
||
*
|
||
* @return Whether the role has or not.
|
||
*/
|
||
hasRole(name: string): boolean;
|
||
/**
|
||
* Get a role.
|
||
*
|
||
* @param name Name, identifier of target {@link ExternalSystemRole role}.
|
||
*
|
||
* @return The specified role.
|
||
*/
|
||
getRole(name: string): ExternalSystemRole;
|
||
/**
|
||
* <p> Send an {@link Invoke} message. </p>
|
||
*
|
||
* @param invoke An {@link Invoke} message to send.
|
||
*/
|
||
sendData(invoke: Invoke): void;
|
||
/**
|
||
* <p> Handle an {@Invoke} message have received. </p>
|
||
*
|
||
* @param invoke An {@link Invoke} message have received.
|
||
*/
|
||
replyData(invoke: Invoke): void;
|
||
/**
|
||
* Tag name of the {@link ExternalSytemArray} in {@link XML}.
|
||
*
|
||
* @return <i>systemArray</i>.
|
||
*/
|
||
TAG(): string;
|
||
/**
|
||
* Tag name of {@link ExternalSystem children elements} belonged to the {@link ExternalSytemArray} in {@link XML}.
|
||
*
|
||
* @return <i>system</i>.
|
||
*/
|
||
CHILD_TAG(): string;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.parallel {
|
||
/**
|
||
* <p> A manager containing {@link ParallelSystem} objects. </p>
|
||
*
|
||
*
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
abstract class ParallelSystemArray extends external.ExternalSystemArray {
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private history_sequence_;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
at(index: number): ParallelSystem;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
_Fetch_history_sequence(): number;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
_Set_history_sequence(val: number): void;
|
||
/**
|
||
*
|
||
* @param invoke An invoke message requesting parallel process.
|
||
* @param size Number of pieces.
|
||
*/
|
||
sendSegmentData(invoke: Invoke, size: number): void;
|
||
/**
|
||
*
|
||
*
|
||
* @param invoke An invoke message requesting parallel process.
|
||
* @param first Initial piece's index in a section.
|
||
* @param last Final piece's index in a section. The ranged used is [<i>first</i>, <i>last</i>), which contains
|
||
* all the pieces' indices between <i>first</i> and <i>last</i>, including the piece pointed by index
|
||
* <i>first</i>, but not the piece pointed by the index <i>last</i>.
|
||
*/
|
||
sendPieceData(invoke: Invoke, first: number, last: number): void;
|
||
/**
|
||
*
|
||
* @param history
|
||
*
|
||
* @return Whether the processes with same uid are all fininsed.
|
||
*/
|
||
_Complete_history(history: InvokeHistory): boolean;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private normalize_performance();
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.distributed {
|
||
abstract class DistributedSystemArray extends parallel.ParallelSystemArray {
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private role_map_;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
construct(xml: library.XML): void;
|
||
abstract createRole(xml: library.XML): DistributedSystemRole;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
at(index: number): DistributedSystem;
|
||
getRoleMap(): std.HashMap<string, DistributedSystemRole>;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
hasRole(name: string): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
getRole(name: string): DistributedSystemRole;
|
||
insertRole(role: DistributedSystemRole): void;
|
||
eraseRole(name: string): void;
|
||
toXML(): library.XML;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.distributed {
|
||
abstract class DistributedClientArray extends DistributedSystemArray implements external.IExternalClientArray {
|
||
/**
|
||
* A subrogator of {@link IServer server}'s role instead of this {@link ExternalClientArray}.
|
||
*/
|
||
private server_base_;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* <p> Factory method creating {@link IServerBase} object. </p>
|
||
*
|
||
* <p> This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
|
||
* {@link ExternalClientArray}. If the protocol is determined, then {@link ExternalSystem external clients} who
|
||
* may connect to {@link ExternalClientArray this server} must follow the specified protocol. </p>
|
||
*
|
||
* <p> Creates and returns one of them: </p>
|
||
* <ul>
|
||
* <li> {@link ServerBase} </li>
|
||
* <li> {@link WebServerBase} </li>
|
||
* <li> {@link SharedWorkerServerBase} </li>
|
||
* </ul>
|
||
*
|
||
* @return A new {@link IServerBase} object.
|
||
*/
|
||
protected abstract createServerBase(): IServerBase;
|
||
addClient(driver: IClientDriver): void;
|
||
createChild(xml: library.XML): DistributedSystem;
|
||
protected abstract createExternalClient(driver: IClientDriver): DistributedSystem;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
open(port: number): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
close(): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.distributed {
|
||
abstract class DistributedSystemArrayMediator extends DistributedSystemArray {
|
||
private mediator_;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
protected abstract createMediator(): parallel.MediatorSystem;
|
||
protected startMediator(): void;
|
||
getMediator(): parallel.MediatorSystem;
|
||
_Complete_history(history: parallel.PRInvokeHistory): boolean;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.distributed {
|
||
abstract class DistributedClientArrayMediator extends DistributedSystemArrayMediator implements external.IExternalClientArray {
|
||
/**
|
||
* A subrogator of {@link IServer server}'s role instead of this {@link ExternalClientArray}.
|
||
*/
|
||
private server_base_;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* <p> Factory method creating {@link IServerBase} object. </p>
|
||
*
|
||
* <p> This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
|
||
* {@link ExternalClientArray}. If the protocol is determined, then {@link ExternalSystem external clients} who
|
||
* may connect to {@link ExternalClientArray this server} must follow the specified protocol. </p>
|
||
*
|
||
* <p> Creates and returns one of them: </p>
|
||
* <ul>
|
||
* <li> {@link ServerBase} </li>
|
||
* <li> {@link WebServerBase} </li>
|
||
* <li> {@link SharedWorkerServerBase} </li>
|
||
* </ul>
|
||
*
|
||
* @return A new {@link IServerBase} object.
|
||
*/
|
||
protected abstract createServerBase(): IServerBase;
|
||
addClient(driver: IClientDriver): void;
|
||
createChild(xml: library.XML): DistributedSystem;
|
||
protected abstract createExternalClient(driver: IClientDriver): DistributedSystem;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
open(port: number): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
close(): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.external {
|
||
/**
|
||
* <p> An external system driver. </p>
|
||
*
|
||
* <p> The {@link ExternalSystem} class represents an external system, connected and interact with this system.
|
||
* {@link ExternalSystem} takes full charge of network communication with external system have connected.
|
||
* Replied {@link Invoke messages} from the external system is shifted to and processed in, children elements of this
|
||
* class, {@link ExternalSystemRole} objects. </p>
|
||
*
|
||
* <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
|
||
* target="_blank">
|
||
* <img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
|
||
* style="max-width: 100%" />
|
||
* </a> </p>
|
||
*
|
||
* <h4> Bridge & Proxy Pattern </h4>
|
||
* <p> The {@link ExternalSystem} class can be a <i>bridge</i> for <i>logical proxy</i>. In framework within user,
|
||
* which {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
|
||
* important. Only interested in user's perspective is <i>which can be done</i>. </p>
|
||
*
|
||
* <p> By using the <i>logical proxy</i>, user dont't need to know which {@link ExternalSystemRole role} is belonged
|
||
* to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
|
||
* Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}. </p>
|
||
*
|
||
* <ul>
|
||
* <li>
|
||
* {@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
|
||
* from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
|
||
* </li>
|
||
* <li>
|
||
* When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
|
||
* {@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
|
||
* external system.
|
||
* </li>
|
||
* <li> Those strategy is called <i>Bridge Pattern</i> and <i>Proxy Pattern</i>. </li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
abstract class ExternalSystem extends EntityDequeCollection<ExternalSystemRole> implements IProtocol {
|
||
/**
|
||
* The name represents external system have connected.
|
||
*/
|
||
protected name: string;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private system_array_;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private communicator_;
|
||
constructor(systemArray: ExternalSystemArray);
|
||
constructor(systemArray: ExternalSystemArray, communicator: IClientDriver);
|
||
/**
|
||
* Default Destructor.
|
||
*/
|
||
destructor(): void;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private handle_close();
|
||
getSystemArray(): ExternalSystemArray;
|
||
/**
|
||
* Identifier of {@link ExternalSystem} is its {@link name}.
|
||
*/
|
||
key(): string;
|
||
/**
|
||
* Get {@link name}.
|
||
*/
|
||
getName(): string;
|
||
protected communicator: protocol.ICommunicator;
|
||
close(): void;
|
||
/**
|
||
* Send {@link Invoke} message to external system.
|
||
*
|
||
* @param invoke An {@link Invoke} message to send.
|
||
*/
|
||
sendData(invoke: Invoke): void;
|
||
/**
|
||
* Handle an {@Invoke} message has received.
|
||
*
|
||
* @param invoke An {@link Invoke} message have received.
|
||
*/
|
||
replyData(invoke: Invoke): void;
|
||
/**
|
||
* Tag name of the {@link ExternalSytem} in {@link XML}.
|
||
*
|
||
* @return <i>system</i>.
|
||
*/
|
||
TAG(): string;
|
||
/**
|
||
* Tag name of {@link ExternalSystemRole children elements} belonged to the {@link ExternalSytem} in {@link XML}.
|
||
*
|
||
* @return <i>role</i>.
|
||
*/
|
||
CHILD_TAG(): string;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.parallel {
|
||
/**
|
||
* <p> An external parallel system driver. </p>
|
||
*
|
||
*
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
abstract class ParallelSystem extends external.ExternalSystem {
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private progress_list_;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private history_list_;
|
||
/**
|
||
* <p> Performance index. </p>
|
||
*
|
||
* <p> A performance index that indicates how much fast the connected parallel system is. </p>
|
||
*
|
||
* <p> If this {@link ParallelSystem parallel system} hasn't any {@link Invoke} message had handled, then the
|
||
* {@link performance performance index} will be 1, which means default and average value between all
|
||
* {@link ParallelSystem} instances (belonged to a same {@link ParallelSystemArray} object). </p>
|
||
*
|
||
* <p> You can specify this {@link performance} by yourself, but notice that, if the
|
||
* {@link performance performance index} is higher then other {@link ParallelSystem} objects, then this
|
||
* {@link ParallelSystem parallel system} will ordered to handle more processes than other
|
||
* {@link ParallelSystem} objects. Otherwise, the {@link performance performance index) is lower than others,
|
||
* of course, less processes will be delivered. </p>
|
||
*
|
||
* <p> This {@link performance index} is always re-calculated whenever {@link ParallelSystemArray} calls one of
|
||
* them below. </p>
|
||
*
|
||
* <ul>
|
||
* <li> {@link ParallelSystemArray.sendSegmentData ParallelSystemArray.sendSegmentData()} </li>
|
||
* <li> {@link ParallelSystemArray.sendPieceData ParallelSystemArray.sendPieceData()} </li>
|
||
* </ul>
|
||
*
|
||
* <p> If this class is a type of {@link DistributedSystem} derived class from the {@link ParallelSystem},
|
||
* then {@link DistributedSystemRole.sendData DistributedSystemRole.sendData()} also cause the re-calculation.
|
||
* </p>
|
||
*/
|
||
protected performance: number;
|
||
constructor(systemArray: ParallelSystemArray);
|
||
constructor(systemArray: ParallelSystemArray, communicator: IClientDriver);
|
||
destructor(): void;
|
||
/**
|
||
* Get manager of this object, {@link systemArray}.
|
||
*
|
||
* @return A manager containing this {@link ParallelSystem} object.
|
||
*/
|
||
getSystemArray(): ParallelSystemArray;
|
||
/**
|
||
* Get {@link performant performance index}.
|
||
*
|
||
* A performance index that indicates how much fast the connected parallel system is.
|
||
*/
|
||
getPerformance(): number;
|
||
_Get_progress_list(): std.HashMap<number, std.Pair<Invoke, InvokeHistory>>;
|
||
_Get_history_list(): std.HashMap<number, InvokeHistory>;
|
||
_Set_performance(val: number): void;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
_Send_piece_data(invoke: Invoke, first: number, last: number): void;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private _replyData(invoke);
|
||
/**
|
||
*
|
||
*
|
||
* @param xml
|
||
*
|
||
* @see {@link ParallelSystemArray.notify_complete}
|
||
*/
|
||
protected _Report_history(xml: library.XML): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.distributed {
|
||
abstract class DistributedSystem extends parallel.ParallelSystem {
|
||
destructor(): void;
|
||
createChild(xml: library.XML): external.ExternalSystemRole;
|
||
/**
|
||
* Get manager of this object.
|
||
*
|
||
* @return A manager containing this {@link DistributedSystem} objects.
|
||
*/
|
||
getSystemArray(): DistributedSystemArray;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
has(key: string): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
get(key: string): DistributedSystemRole;
|
||
replyData(invoke: protocol.Invoke): void;
|
||
protected _Report_history(xml: library.XML): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.distributed {
|
||
interface IDistributedServer extends DistributedSystem, external.IExternalServer {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
getSystemArray(): DistributedSystemArray;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
has(key: string): boolean;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
get(key: string): DistributedSystemRole;
|
||
}
|
||
abstract class DistributedServer extends DistributedSystem implements external.IExternalServer {
|
||
protected ip: string;
|
||
protected port: number;
|
||
constructor(systemArray: DistributedSystemArray);
|
||
protected abstract createServerConnector(): IServerConnector;
|
||
connect(): void;
|
||
getIP(): string;
|
||
getPort(): number;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.distributed {
|
||
abstract class DistributedServerArray extends DistributedSystemArray implements external.IExternalServerArray {
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
connect(): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.distributed {
|
||
abstract class DistributedServerArrayMediator extends DistributedSystemArrayMediator implements external.IExternalServerArray {
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
connect(): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.distributed {
|
||
abstract class DistributedServerClientArray extends DistributedClientArray implements external.IExternalServerClientArray {
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
createChild(xml: library.XML): DistributedSystem;
|
||
protected abstract createExternalServer(xml: library.XML): IDistributedServer;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
connect(): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.distributed {
|
||
abstract class DistributedServerClientArrayMediator extends DistributedClientArrayMediator implements external.IExternalServerClientArray {
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
createChild(xml: library.XML): DistributedSystem;
|
||
protected abstract createExternalServer(xml: library.XML): IDistributedServer;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
connect(): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.external {
|
||
/**
|
||
* <p> An interface for an {@link ExternalSystemArray} accepts {@link ExternalSystem external clients} as a
|
||
* {@link IServer server}. </p>
|
||
*
|
||
* <p> The easiest way to defining an {@link ExternalSystemArray} who opens server and accepts
|
||
* {@link ExternalSystem external clients} is to extending one of below, who are derived from this interface
|
||
* {@link IExternalClientArray}. However, if you can't specify an {@link ExternalSystemArray} to be whether server or
|
||
* client, then make a class (let's name it as <b>BaseSystemArray</b>) extending {@link ExternalSystemArray} and make
|
||
* a new class (now, I name it <b>BaseClientArray</b>) extending <b>BaseSystemArray</b> and implementing this
|
||
* interface {@link IExternalClientArray}. Define the <b>BaseClientArray</b> following those codes on below:
|
||
*
|
||
* <ul>
|
||
* <li> {@link ExternalClientArray}:
|
||
* <a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/external/ExternalClientArray.ts"
|
||
* target="_blank"> View source code on GitHub </a>
|
||
* </li>
|
||
* <li> {@link ParallelClientArray}:
|
||
* <a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/master/ParallelClientArray.ts"
|
||
* target="_blank"> View source code on GitHub </a>
|
||
* </li>
|
||
* <li> {@link DistributedClientArray}:
|
||
* <a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/master/DistributedClientArray.ts"
|
||
* target="_blank"> View source code on GitHub </a>
|
||
* </li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
interface IExternalClientArray extends ExternalSystemArray, IServer {
|
||
}
|
||
/**
|
||
* <p> An {@link ExternalSystemArray} acceepts {@link ExternalSystem external clients} as a {@link IServer server}. </p>
|
||
*
|
||
* <p> {@link ExternalServerArray} is an abstract class contains, manages and accepts external server drivers,
|
||
* {@link IExternalServer} objects, as a {@link IServer server}. </p>
|
||
*
|
||
* <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
|
||
* target="_blank">
|
||
* <img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
|
||
* style="max-width: 100%" />
|
||
* </a> </p>
|
||
*
|
||
* <h4> Proxy Pattern </h4>
|
||
* <p> The {@link ExternalSystemArray} class can use <i>Proxy Pattern</i>. In framework within user, which
|
||
* {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
|
||
* important. Only interested in user's perspective is <i>which can be done</i>. </p>
|
||
*
|
||
* <p> By using the <i>logical proxy</i>, user dont't need to know which {@link ExternalSystemRole role} is belonged
|
||
* to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
|
||
* Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}. </p>
|
||
*
|
||
* <ul>
|
||
* <li>
|
||
* {@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
|
||
* from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
|
||
* </li>
|
||
* <li>
|
||
* When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
|
||
* {@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
|
||
* external system.
|
||
* </li>
|
||
* <li> Those strategy is called <i>Proxy Pattern</i>. </li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
abstract class ExternalClientArray extends ExternalSystemArray implements IExternalClientArray {
|
||
/**
|
||
* A subrogator of {@link IServer server}'s role instead of this {@link ExternalClientArray}.
|
||
*/
|
||
private server_base_;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* <p> Factory method creating {@link IServerBase} object. </p>
|
||
*
|
||
* <p> This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
|
||
* {@link ExternalClientArray}. If the protocol is determined, then {@link ExternalSystem external clients} who
|
||
* may connect to {@link ExternalClientArray this server} must follow the specified protocol. </p>
|
||
*
|
||
* <p> Creates and returns one of them: </p>
|
||
* <ul>
|
||
* <li> {@link ServerBase} </li>
|
||
* <li> {@link WebServerBase} </li>
|
||
* <li> {@link SharedWorkerServerBase} </li>
|
||
* </ul>
|
||
*
|
||
* @return A new {@link IServerBase} object.
|
||
*/
|
||
protected abstract createServerBase(): IServerBase;
|
||
addClient(driver: IClientDriver): void;
|
||
/**
|
||
* This method is deprecated. Don't use and override this.
|
||
*
|
||
* @return null.
|
||
*/
|
||
createChild(xml: library.XML): ExternalSystem;
|
||
/**
|
||
* Factory method creating {@link ExternalSystem} object.
|
||
*
|
||
* @param driver A communicator with connected client.
|
||
* @return A newly created {@link ExternalSystem} object.
|
||
*/
|
||
protected abstract createExternalClient(driver: IClientDriver): ExternalSystem;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
open(port: number): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
close(): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.external {
|
||
/**
|
||
* <p> An interface for an external server driver. </p>
|
||
*
|
||
* <p> The easiest way to defining an external server driver is to extending one of below, who are derived from this
|
||
* interface {@link IExternalServer}. However, if you've to interact with an external system who can be both server
|
||
* and client, then make a class (let's name it as <b>BaseSystem</b>) extending {@link ExternalSystem} and make a
|
||
* new class (now, I name it <b>BaseServer</b>) extending <b>BaseSystem</b> and implementing this interface
|
||
* {@link IExternalServer}. Define the <b>BaseServer</b> following those codes on below:
|
||
*
|
||
* <ul>
|
||
* <li> {@link ExternalServer}:
|
||
* <a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/external/ExternalServer.ts"
|
||
* target="_blank"> View source code on GitHub </a>
|
||
* </li>
|
||
* <li> {@link ParallelServer}:
|
||
* <a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/master/DistributedServer.ts"
|
||
* target="_blank"> View source code on GitHub </a>
|
||
* </li>
|
||
* <li> {@link DistributedServer}:
|
||
* <a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/master/ParallelServer.ts"
|
||
* target="_blank"> View source code on GitHub </a>
|
||
* </li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
interface IExternalServer extends ExternalSystem {
|
||
connect(): void;
|
||
}
|
||
/**
|
||
* <p> An external server driver. </p>
|
||
*
|
||
* <p> The {@link ExternalServer} class represents an external server, connected and interact with this system.
|
||
* {@link ExternalServer} takes full charge of network communication with external server have connected.
|
||
* Replied {@link Invoke messages} from the external system is shifted to and processed in, children elements of this
|
||
* class, {@link ExternalSystemRole} objects. </p>
|
||
*
|
||
* <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
|
||
* target="_blank">
|
||
* <img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
|
||
* style="max-width: 100%" />
|
||
* </a> </p>
|
||
*
|
||
* <h4> Bridge & Proxy Pattern </h4>
|
||
* <p> The {@link ExternalSystem} class can be a <i>bridge</i> for <i>logical proxy</i>. In framework within user,
|
||
* which {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
|
||
* important. Only interested in user's perspective is <i>which can be done</i>. </p>
|
||
*
|
||
* <p> By using the <i>logical proxy</i>, user dont't need to know which {@link ExternalSystemRole role} is belonged
|
||
* to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
|
||
* Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}. </p>
|
||
*
|
||
* <ul>
|
||
* <li>
|
||
* {@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
|
||
* from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
|
||
* </li>
|
||
* <li>
|
||
* When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
|
||
* {@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
|
||
* external system.
|
||
* </li>
|
||
* <li> Those strategy is called <i>Bridge Pattern</i> and <i>Proxy Pattern</i>. </li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
abstract class ExternalServer extends ExternalSystem implements IExternalServer {
|
||
/**
|
||
* IP address of target external system to connect.
|
||
*/
|
||
protected ip: string;
|
||
/**
|
||
* Port number of target external system to connect.
|
||
*/
|
||
protected port: number;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor(systemArray: ExternalSystemArray);
|
||
/**
|
||
* Factory method creating server connector.
|
||
*/
|
||
protected abstract createServerConnector(): IServerConnector;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
connect(): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
getIP(): string;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
getPort(): number;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.external {
|
||
/**
|
||
* <p> An interface for an {@link ExternalSystemArray} connects to {@link IExternalServer external servers} as a
|
||
* <b>client</b>. </p>
|
||
*
|
||
* <p> The easiest way to defining an {@link ExternalSystemArray} who connects to
|
||
* {@link IExternalServer external servers} is to extending one of below, who are derived from this interface
|
||
* {@link IExternalServerArray}. However, if you can't specify an {@link ExternalSystemArray} to be whether server or
|
||
* client, then make a class (let's name it as <b>BaseSystemArray</b>) extending {@link ExternalSystemArray} and make
|
||
* a new class (now, I name it <b>BaseServerArray</b>) extending <b>BaseSystemArray</b> and implementing this
|
||
* interface {@link IExternalServerArray}. Define the <b>BaseServerArray</b> following those codes on below:
|
||
*
|
||
* <ul>
|
||
* <li> {@link ExternalServerArray}:
|
||
* <a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/external/ExternalServerArray.ts"
|
||
* target="_blank"> View source code on GitHub </a>
|
||
* </li>
|
||
* <li> {@link ParallelServerArray}:
|
||
* <a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/master/ParallelServerArray.ts"
|
||
* target="_blank"> View source code on GitHub </a>
|
||
* </li>
|
||
* <li> {@link DistributedServerArray}:
|
||
* <a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/master/DistributedServerArray.ts"
|
||
* target="_blank"> View source code on GitHub </a>
|
||
* </li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
interface IExternalServerArray extends ExternalSystemArray {
|
||
/**
|
||
* <p> Connect to {@link IExternalServer external servers}. </p>
|
||
*
|
||
* <p> This method calls children elements' method {@link IExternalServer.connect} gradually. </p>
|
||
*/
|
||
connect(): void;
|
||
}
|
||
/**
|
||
* <p> An {@link ExternalSystemArray} connecting to {@link IExternalServer external servers} as a <b>client</b>. </p>
|
||
*
|
||
* <p> {@link ExternalServerArray} is an abstract class contains, manages and connects to external server drivers,
|
||
* {@link IExternalServer} objects, as a <b>client</b>. </p>
|
||
*
|
||
* <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
|
||
* target="_blank">
|
||
* <img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
|
||
* style="max-width: 100%" />
|
||
* </a> </p>
|
||
*
|
||
* <h4> Proxy Pattern </h4>
|
||
* <p> The {@link ExternalSystemArray} class can use <i>Proxy Pattern</i>. In framework within user, which
|
||
* {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
|
||
* important. Only interested in user's perspective is <i>which can be done</i>. </p>
|
||
*
|
||
* <p> By using the <i>logical proxy</i>, user dont't need to know which {@link ExternalSystemRole role} is belonged
|
||
* to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
|
||
* Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}. </p>
|
||
*
|
||
* <ul>
|
||
* <li>
|
||
* {@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
|
||
* from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
|
||
* </li>
|
||
* <li>
|
||
* When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
|
||
* {@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
|
||
* external system.
|
||
* </li>
|
||
* <li> Those strategy is called <i>Proxy Pattern</i>. </li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
abstract class ExternalServerArray extends ExternalSystemArray {
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
connect(): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.external {
|
||
/**
|
||
* <p> An interface for an {@link ExternalSystemArray} accepts {@link ExternalSystem external clients} as a
|
||
* {@link IServer server} and connects to {@link IExternalServer} as <b>client</b>, at the same time. </p>
|
||
*
|
||
* <p> The easiest way to defining an {@link IExternalServerClientArray} who opens server, accepts
|
||
* {@link ExternalSystem external clients} and connects to {@link IExternalServer external servers} is to extending
|
||
* one of below, who are derived from this interface {@link IExternalServerClientArray}. However, if you can't
|
||
* specify an {@link ExternalSystemArray} to be whether server or client or even can both them, then make a class
|
||
* (let's name it as <b>BaseSystemArray</b>) extending {@link ExternalSystemArray} and make a new class (now, I name
|
||
* it <b>BaseServerClientArray</b>) extending <b>BaseSystemArray</b> and implementing this interface
|
||
* {@link IExternalServerClientArray}. Define the <b>BaseServerClientArray</b> following those codes on below:
|
||
*
|
||
* <ul>
|
||
* <li> {@link ExternalServerClientArray}:
|
||
* <a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/external/ExternalServerClientArray.ts"
|
||
* target="_blank"> View source code on GitHub </a>
|
||
* </li>
|
||
* <li> {@link ParallelServerClientArray}:
|
||
* <a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/master/ParallelServerClientArray.ts"
|
||
* target="_blank"> View source code on GitHub </a>
|
||
* </li>
|
||
* <li> {@link DistributedServerClientArray}:
|
||
* <a href="https://github.com/samchon/framework/blob/master/ts/src/samchon/protocol/master/DistributedServerClientArray.ts"
|
||
* target="_blank"> View source code on GitHub </a>
|
||
* </li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
interface IExternalServerClientArray extends IExternalServerArray, IExternalClientArray {
|
||
}
|
||
/**
|
||
* <p> An {@link ExternalSystemArray} connecting to {@link IExternalServer external servers} as a <b>client</b> and
|
||
* accepts {@link ExternalSystem external clients} as a {@link IServer server}. </p>
|
||
*
|
||
* <p> {@link ExternalServerArray} is an abstract class contains, manages and connects to external server drivers,
|
||
* {@link IExternalServer} objects and accepts external client drivers {@link ExternalSyste} obejcts as a
|
||
* <b>client</b> and a {@link IServer server} at the same time. </p>
|
||
*
|
||
* <p> <a href="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
|
||
* target="_blank">
|
||
* <img src="http://samchon.github.io/framework/images/design/ts_class_diagram/protocol_external_system.png"
|
||
* style="max-width: 100%" />
|
||
* </a> </p>
|
||
*
|
||
* <h4> Proxy Pattern </h4>
|
||
* <p> The {@link ExternalSystemArray} class can use <i>Proxy Pattern</i>. In framework within user, which
|
||
* {@link ExternalSystem external system} is connected with {@link ExternalSystemArray this system}, it's not
|
||
* important. Only interested in user's perspective is <i>which can be done</i>. </p>
|
||
*
|
||
* <p> By using the <i>logical proxy</i>, user dont't need to know which {@link ExternalSystemRole role} is belonged
|
||
* to which {@link ExternalSystem system}. Just access to a role directly from {@link ExternalSystemArray.getRole}.
|
||
* Sends and receives {@link Invoke} message via the {@link ExternalSystemRole role}. </p>
|
||
*
|
||
* <ul>
|
||
* <li>
|
||
* {@link ExternalSystemRole} can be accessed from {@link ExternalSystemArray} directly, without inteferring
|
||
* from {@link ExternalSystem}, with {@link ExternalSystemArray.getRole}.
|
||
* </li>
|
||
* <li>
|
||
* When you want to send an {@link Invoke} message to the belonged {@link ExternalSystem system}, just call
|
||
* {@link ExternalSystemRole.sendData ExternalSystemRole.sendData()}. Then, the message will be sent to the
|
||
* external system.
|
||
* </li>
|
||
* <li> Those strategy is called <i>Proxy Pattern</i>. </li>
|
||
* </ul>
|
||
*
|
||
* @author Jeongho Nam <http://samchon.org>
|
||
*/
|
||
abstract class ExternalServerClientArray extends ExternalClientArray implements IExternalServerClientArray {
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* <p> Factory method of a child Entity. </p>
|
||
*
|
||
* <p> This method is migrated to {@link createExternalServer createExternalServer()}. Override the
|
||
* {@link createExternalServer createExternalServer()}. </p>
|
||
*
|
||
* @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
|
||
*
|
||
* @return A new child Entity via {@link createExternalServer createExternalServer()}.
|
||
*/
|
||
createChild(xml: library.XML): ExternalSystem;
|
||
/**
|
||
* Factory method creating an {@link IExternalServer} object.
|
||
*
|
||
* @param xml An {@link XML} object represents child element, so that can identify the type of child to create.
|
||
*
|
||
* @return A newly created {@link IExternalServer} object.
|
||
*/
|
||
protected abstract createExternalServer(xml: library.XML): IExternalServer;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
connect(): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.slave {
|
||
abstract class SlaveSystem implements protocol.IProtocol {
|
||
protected communicator_: ICommunicator;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
sendData(invoke: Invoke): void;
|
||
protected _replyData(invoke: Invoke): void;
|
||
replyData(invoke: Invoke): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.parallel {
|
||
abstract class MediatorSystem extends slave.SlaveSystem {
|
||
private mediator_;
|
||
private progress_list_;
|
||
constructor(systemArray: ParallelSystemArrayMediator | distributed.DistributedSystemArrayMediator);
|
||
abstract start(): void;
|
||
getMediator(): ParallelSystemArrayMediator | distributed.DistributedSystemArrayMediator;
|
||
_Complete_history(uid: number): void;
|
||
protected _replyData(invoke: Invoke): void;
|
||
replyData(invoke: protocol.Invoke): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.parallel {
|
||
class MediatorServer extends MediatorSystem implements slave.ISlaveServer {
|
||
private server_base_;
|
||
private port;
|
||
constructor(systemArray: ParallelSystemArrayMediator, port: number);
|
||
protected createServerBase(): IServerBase;
|
||
addClient(driver: IClientDriver): void;
|
||
start(): void;
|
||
open(port: number): void;
|
||
close(): void;
|
||
}
|
||
class MediatorWebServer extends MediatorServer {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected createServerBase(): IServerBase;
|
||
}
|
||
class MediatorSharedWorkerServer extends MediatorServer {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected createServerBase(): IServerBase;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.parallel {
|
||
class MediatorClient extends MediatorSystem implements slave.ISlaveClient {
|
||
protected ip: string;
|
||
protected port: number;
|
||
constructor(systemArray: ParallelSystemArrayMediator, ip: string, port: number);
|
||
protected createServerConnector(): IServerConnector;
|
||
getIP(): string;
|
||
getPort(): number;
|
||
start(): void;
|
||
connect(): void;
|
||
}
|
||
class MediatorWebClient extends MediatorClient {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected createServerConnector(): IServerConnector;
|
||
}
|
||
class MediatorSharedWorkerClient extends MediatorClient {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected createServerConnector(): IServerConnector;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.parallel {
|
||
class PRInvokeHistory extends InvokeHistory {
|
||
/**
|
||
* Index number of initial piece.
|
||
*/
|
||
private first;
|
||
/**
|
||
* Index number of final piece.
|
||
*/
|
||
private last;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* Construct from an Invoke message.
|
||
*
|
||
* @param invoke
|
||
*/
|
||
constructor(invoke: Invoke);
|
||
getFirst(): number;
|
||
getLast(): number;
|
||
_Set_first(val: number): void;
|
||
_Set_last(val: number): void;
|
||
/**
|
||
* Compute number of allocated pieces.
|
||
*/
|
||
computeSize(): number;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.parallel {
|
||
abstract class ParallelClientArray extends ParallelSystemArray implements external.IExternalClientArray {
|
||
/**
|
||
* A subrogator of {@link IServer server}'s role instead of this {@link ExternalClientArray}.
|
||
*/
|
||
private server_base_;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* <p> Factory method creating {@link IServerBase} object. </p>
|
||
*
|
||
* <p> This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
|
||
* {@link ExternalClientArray}. If the protocol is determined, then {@link ExternalSystem external clients} who
|
||
* may connect to {@link ExternalClientArray this server} must follow the specified protocol. </p>
|
||
*
|
||
* <p> Creates and returns one of them: </p>
|
||
* <ul>
|
||
* <li> {@link ServerBase} </li>
|
||
* <li> {@link WebServerBase} </li>
|
||
* <li> {@link SharedWorkerServerBase} </li>
|
||
* </ul>
|
||
*
|
||
* @return A new {@link IServerBase} object.
|
||
*/
|
||
protected abstract createServerBase(): IServerBase;
|
||
addClient(driver: IClientDriver): void;
|
||
createChild(xml: library.XML): ParallelSystem;
|
||
protected abstract createExternalClient(driver: IClientDriver): ParallelSystem;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
open(port: number): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
close(): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.parallel {
|
||
abstract class ParallelSystemArrayMediator extends ParallelSystemArray {
|
||
private mediator_;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
protected abstract createMediator(): MediatorSystem;
|
||
protected start_mediator(): void;
|
||
getMediator(): MediatorSystem;
|
||
_Complete_history(history: PRInvokeHistory): boolean;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.parallel {
|
||
abstract class ParallelClientArrayMediator extends ParallelSystemArrayMediator implements external.IExternalClientArray {
|
||
/**
|
||
* A subrogator of {@link IServer server}'s role instead of this {@link ExternalClientArray}.
|
||
*/
|
||
private server_base_;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* <p> Factory method creating {@link IServerBase} object. </p>
|
||
*
|
||
* <p> This method {@link createServerBase createServerBase()} determines which protocol is used in this server,
|
||
* {@link ExternalClientArray}. If the protocol is determined, then {@link ExternalSystem external clients} who
|
||
* may connect to {@link ExternalClientArray this server} must follow the specified protocol. </p>
|
||
*
|
||
* <p> Creates and returns one of them: </p>
|
||
* <ul>
|
||
* <li> {@link ServerBase} </li>
|
||
* <li> {@link WebServerBase} </li>
|
||
* <li> {@link SharedWorkerServerBase} </li>
|
||
* </ul>
|
||
*
|
||
* @return A new {@link IServerBase} object.
|
||
*/
|
||
protected abstract createServerBase(): IServerBase;
|
||
addClient(driver: IClientDriver): void;
|
||
createChild(xml: library.XML): ParallelSystem;
|
||
protected abstract createExternalClient(driver: IClientDriver): ParallelSystem;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
open(port: number): void;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
close(): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.parallel {
|
||
interface IParallelServer extends external.IExternalServer, ParallelSystem {
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
getSystemArray(): ParallelSystemArray;
|
||
}
|
||
abstract class ParallelServer extends ParallelSystem implements external.IExternalServer {
|
||
protected ip: string;
|
||
protected port: number;
|
||
constructor(systemArray: ParallelSystemArray);
|
||
protected abstract createServerConnector(): IServerConnector;
|
||
connect(): void;
|
||
getIP(): string;
|
||
getPort(): number;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.parallel {
|
||
abstract class ParallelServerArray extends ParallelSystemArray implements external.IExternalServerArray {
|
||
constructor();
|
||
connect(): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.parallel {
|
||
abstract class ParallelServerArrayMediator extends ParallelSystemArrayMediator implements external.IExternalServerArray {
|
||
constructor();
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
connect(): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.parallel {
|
||
abstract class ParallelServerClientArray extends ParallelClientArray implements external.IExternalServerClientArray {
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
createChild(xml: library.XML): ParallelSystem;
|
||
protected abstract createExternalServer(xml: library.XML): IParallelServer;
|
||
connect(): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.parallel {
|
||
abstract class ParallelServerClientArrayMediator extends ParallelClientArrayMediator implements external.IExternalServerClientArray {
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
createChild(xml: library.XML): ParallelSystem;
|
||
protected abstract createExternalServer(xml: library.XML): IParallelServer;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
connect(): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.service {
|
||
abstract class Client implements protocol.IProtocol {
|
||
private user_;
|
||
private service_;
|
||
private communicator_;
|
||
private no_;
|
||
/**
|
||
* Construct from an User and WebClientDriver.
|
||
*/
|
||
constructor(user: User, driver: WebClientDriver);
|
||
protected abstract createService(path: string): Service;
|
||
close(): void;
|
||
getUser(): User;
|
||
getService(): Service;
|
||
getNo(): number;
|
||
_Set_no(val: number): void;
|
||
sendData(invoke: protocol.Invoke): void;
|
||
replyData(invoke: protocol.Invoke): void;
|
||
protected changeService(path: string): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.service {
|
||
abstract class Server extends protocol.WebServer implements IProtocol {
|
||
private session_map_;
|
||
private account_map_;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* Factory method creating {@link User} object.
|
||
*
|
||
* @return A newly created {@link User} object.
|
||
*/
|
||
protected abstract createUser(): User;
|
||
has(account: string): boolean;
|
||
get(account: string): User;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
_Get_account_map(): std.HashMap<string, User>;
|
||
sendData(invoke: protocol.Invoke): void;
|
||
replyData(invoke: protocol.Invoke): void;
|
||
addClient(driver: WebClientDriver): void;
|
||
_Erase_user(user: User): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.service {
|
||
abstract class Service implements protocol.IProtocol {
|
||
private client_;
|
||
private path_;
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor(client: Client, path: string);
|
||
destructor(): void;
|
||
/**
|
||
* Get client.
|
||
*/
|
||
getClient(): Client;
|
||
/**
|
||
* Get path.
|
||
*/
|
||
getPath(): string;
|
||
sendData(invoke: protocol.Invoke): void;
|
||
replyData(invoke: protocol.Invoke): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.service {
|
||
abstract class User extends collection.HashMapCollection<number, Client> implements protocol.IProtocol {
|
||
private server_;
|
||
private session_id_;
|
||
private sequence_;
|
||
private account_id_;
|
||
private authority_;
|
||
/**
|
||
* Construct from a Server.
|
||
*/
|
||
constructor(server: Server);
|
||
protected abstract createClient(driver: WebClientDriver): Client;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
_Create_child(driver: WebClientDriver): Client;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
private handle_erase_client(event);
|
||
getServer(): Server;
|
||
getAccountID(): string;
|
||
getAuthority(): number;
|
||
setAccount(id: string, authority: number): void;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
_Get_session_id(): string;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
_Fetch_sequence(): number;
|
||
/**
|
||
* @hidden
|
||
*/
|
||
_Set_session_id(val: string): void;
|
||
sendData(invoke: protocol.Invoke): void;
|
||
replyData(invoke: protocol.Invoke): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.slave {
|
||
interface ISlaveClient extends SlaveSystem {
|
||
connect(ip: string, port: number): void;
|
||
}
|
||
abstract class SlaveClient extends SlaveSystem implements ISlaveClient {
|
||
/**
|
||
* Default Constructor.
|
||
*/
|
||
constructor();
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
protected abstract createServerConnector(): IServerConnector;
|
||
/**
|
||
* @inheritdoc
|
||
*/
|
||
connect(ip: string, port: number): void;
|
||
}
|
||
}
|
||
declare namespace samchon.protocol.slave {
|
||
interface ISlaveServer extends SlaveSystem, IServer {
|
||
}
|
||
abstract class SlaveServer extends SlaveSystem implements ISlaveServer {
|
||
private server_base_;
|
||
constructor();
|
||
protected abstract createServerBase(): IServerBase;
|
||
open(port: number): void;
|
||
close(): void;
|
||
addClient(driver: IClientDriver): void;
|
||
}
|
||
}
|
||
declare namespace samchon.test {
|
||
function test_collection(): void;
|
||
}
|