@refinitiv-ui/efx-grid 0.0.0-dev.12023565035.1

package/lib/core/es6/data/DataTable.js

@@ -0,0 +1,2206 @@
+import Ext from "../../../tr-grid-util/es6/Ext.js";
+import DataCache from "./DataCache.js";
+import Util from "../grid/util/util.js";
+import Segment from "./Segment.js"; // eslint-disable-line
+import SegmentCollection from "./SegmentCollection.js";
+
+/** Trigger when data within the table has been changed
+* @event DataTable#dataChanged
+* @property {boolean} globalChange Indicates a big change. User should expect all data has been change
+* @property {string} type Type of changes. Possible values are "inserted", "removed", "updated", and undefined
+* @property {string} rid Row Id
+* @property {Object.<string, *>} rowData Column values of the changed row in JSON object format
+*/
+
+/** Trigger before DataTable#dataChanged. Perform any data update during the event will NOT cause more dataChanged events
+* @event DataTable#dataComposed
+*/
+
+/** @constructor
+* @extends {DataCache}
+*/
+let DataTable = function() {
+	DataTable.base(this, 'constructor');
+
+	this._removeRows = this._removeRows.bind(this);
+	this._bySegmentSeparator = this._bySegmentSeparator.bind(this);
+	this._onClassifyingTimer = this._onClassifyingTimer.bind(this);
+	this._onSubSegmentChanged = this._onSubSegmentChanged.bind(this);
+
+	this._prevData = {};
+	this._rids = [];
+
+	this._compMap = {};
+
+	this._addEvent("subSegmentChanged");
+};
+Ext.inherits(DataTable, DataCache);
+
+/** @private
+* @type {Object.<string, Object.<string, *>>}
+*/
+DataTable.prototype._prevData = null; // Mainly used for blinking
+/** @private
+* @type {!Array.<string>}
+*/
+DataTable.prototype._rids;
+/** @private
+* @type {boolean}
+*/
+DataTable.prototype._frozen = false;
+/** @private
+* @type {number}
+*/
+DataTable.prototype._runningId = 0;
+
+/** Comparer map that will be shared across all child DataViews
+* @private
+* @type {Object.<string, DataTable.SortLogic>}
+*/
+DataTable.prototype._compMap = null;
+
+/** @private
+* @type {SegmentCollection}
+*/
+DataTable.prototype._segments = null;
+/** @private
+* @type {boolean}
+*/
+DataTable.prototype._autoSegmentFilling = false;
+/** @private
+* @type {Object}
+*/
+DataTable.prototype._removedRows = null;
+/** @private
+* @type {Function}
+*/
+DataTable.prototype._userSegmentComparer = null;
+/** @private
+* @type {number}
+*/
+DataTable.prototype._segmentSortOrder = 0;
+/** @private
+* @type {*}
+*/
+DataTable.prototype._segmentSortContext = null;
+/** @private
+* @type {Object.<string, Object>}
+*/
+DataTable.prototype._clsSource = null;
+/** @private
+* @type {number}
+*/
+DataTable.prototype._classifyingTimer = 0;
+/** @private
+* @type {boolean}
+*/
+DataTable.prototype._segmentDefaultCollapsing = false;
+
+/** @typedef {Function} DataTable~SortLogic
+* @description SortLogic function is used for comparison between two values during sorting. <br>
+* The function should return:<br>
+* negative value to put val1 before val2, <br>
+* positive value to put val2 before val1. <br>
+* zero or falsy value to keep val1 and val2 unchanged.
+* @property {*} val1 Value from a row
+* @property {*} val2 Value from another row
+* @property {number=} order 1 indicates ascending order, and -1 indicates descending order
+* @property {*=} contextObject Any given user context
+* @example
+* let customComparer = function(a, b, order) {
+*   if(a + 10 < b) { return -order; }
+*   if(b + 10 < a) { return order; }
+*   return 0; // a and b are less than 10 difference apart
+* };
+*/
+DataTable.SortLogic;
+
+
+/** @override
+*/
+DataTable.prototype.dispose = function() {
+	this.unlistenAll();
+	this.clearAllData(true);
+
+	if(this._classifyingTimer) {
+		clearTimeout(this._classifyingTimer);
+		this._classifyingTimer = 0;
+	}
+
+	this._compMap = null; // Release user function that may be bound
+	this._clsSource = null;
+	DataTable._removeIndexArray();
+	if(this._segments) {
+		this._segments.dispose();
+		this._segments = null;
+	}
+};
+
+/** {@link DataCache#getColumnData}
+* @override
+*/
+DataTable.prototype.getColumnData = function(cid) {
+	let rows = new Array(this._rids.length);
+	for(let i = this._rids.length; --i >= 0;) {
+		rows[i] = this._rows[this._rids[i]][cid];
+	}
+	return rows;
+};
+/** @public
+* @param {number} rowIndex
+* @return {string}
+*/
+DataTable.prototype.getRowId = function(rowIndex) {
+	return this._rids[rowIndex] || "";
+};
+/** {@link DataCache#getAllRowIds}
+* @override
+* @param {boolean=} opt_shallowCopy Default value is false. Set to true for speed
+*/
+DataTable.prototype.getAllRowIds = function(opt_shallowCopy) {
+	if(opt_shallowCopy) {
+		return this._rids;
+	}
+	return this._rids.slice(0); // Fastest way to clone an array
+};
+/** @public
+* @param {string} rid
+* @return {number}
+*/
+DataTable.prototype.getRowIndex = function(rid) {
+	return this._rids.indexOf(rid);
+};
+/** @public
+* @return {number}
+*/
+DataTable.prototype.getRowCount = function() {
+	return this._rids.length;
+};
+/** @public
+* @param {number} rowIndex
+* @param {string} cid
+* @return {Object.<string, *>}
+*/
+DataTable.prototype.getDataAt = function(rowIndex, cid) {
+	return this.getData(this._rids[rowIndex], cid);
+};
+/** @public
+* @param {number} rowIndex
+* @return {Object.<string, *>}
+*/
+DataTable.prototype.getRowDataAt = function(rowIndex) {
+	return this.getRowData(this._rids[rowIndex]);
+};
+/** Get previously set data. This is good for blinking changed data
+* @public
+* @param {string} rid
+* @param {string} cid
+* @return {Object.<string, *>}
+*/
+DataTable.prototype.getPreviousData = function(rid, cid) {
+	let row = this._prevData[rid] || null;
+	if(row) {
+		return row[cid];
+	}
+	return null;
+};
+
+
+/** Set data to individual cell
+* @override
+* @param {string} rid Row Id
+* @param {string} cid Column Id
+* @param {*} value
+* @return {boolean} Return true if there is any change, and false otherwise
+* @fires DataTable#dataChanged
+*/
+DataTable.prototype.setData = function(rid, cid, value) { // Data changed event may be dispatched
+	if(!this._needFiring()) {
+		return this._setData(rid, cid, value);
+	}
+	let values = {};
+	values[cid] = value;
+	return this.setRowData(rid, values);
+};
+/** @private
+* @param {string} rid Row Id
+* @returns {boolean}
+*/
+DataTable.prototype._removeRidFromSegments = function(rid) {
+	if(this._segments) {
+		let segment = this._segments.getSegment(rid);
+		if(segment) {
+			if(this._segments.removeSegment(rid)) {
+				// TODO: Handle sub segment removal
+				if(!this._segments.getSegmentCount()) {
+					this._segments.dispose();
+					this._segments = null;
+				}
+				return true;
+			}
+		} else {
+			let segmentParentId = this._segments.getParentRowId(rid);
+			if(segmentParentId) {
+				this._segments.removeSegmentChild(segmentParentId, rid);
+			}
+		}
+	}
+	return false;
+};
+/** Set data in row manner
+* @override
+* @public
+* @param {string} rid Row Id
+* @param {Object.<string, *>=} values Object where the key is column Id and value is the data to be set
+* @param {Object=} eventArg Additional arguments to be attached to the event fired
+* @return {boolean} Return true if there is any change, and false otherwise
+* @fires DataTable#dataChanged
+* @example
+* let dt = new DataTable();
+* dt.setRowData("row 1", {"column 1": "a", "column 2": 1, "column 3": null});
+* dt.log(); // See console for the results
+*/
+DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data changed event may be dispatched
+	if(!rid) {
+		return false;
+	}
+
+	let row = this.getRowData(rid);
+	let dirty = false;
+	let type = "updated";
+	let segmentChanged = false;
+
+	if(values) {
+		if(!row) {
+			type = "inserted";
+			row = values;
+			this._rows[rid] = row; // WARNING: Dangerous use of external reference. User may modify data without using DataTable's API
+			this._prevData[rid] = {};
+			if(eventArg) {
+				let nextRid = /** @type{string} */(eventArg["nextRid"]); // Used for insertion only
+				let rowIndex = (nextRid) ? this.getRowIndex(nextRid) : -1;
+				if(rowIndex < 0) {
+					rowIndex = /** @type{number} */(eventArg["fallback"]);
+				}
+				if(rowIndex == null || rowIndex < 0 || rowIndex >= this._rids.length) {
+					this._rids.push(rid);
+				} else {
+					this._rids.splice(rowIndex, 0, rid);
+					if(this._segments) { // for no sorting case
+						this._segments.invalidateSegmentOrder();
+					}
+					segmentChanged = !this._isLastSegment(rowIndex); // This is slow. Check if this is required
+				}
+			} else {
+				this._rids.push(rid);
+			}
+		} else {
+			let prevData = this._prevData[rid];
+			for (let cid in values) {
+				prevData[cid] = row[cid];
+				row[cid] = values[cid];
+			}
+		}
+		dirty = true;
+	} else {
+		if(row) {
+			type = "removed";
+			// WARNING: Even if row is removed we still keep previous data
+			// delete this._prevData[rid];
+			this._prevData[rid] = this._rows[rid]; // Move reference from the removed row to history
+			delete this._rows[rid];
+			segmentChanged = this._removeRidFromSegments(rid);
+			DataTable._removeArrayItem(this._rids, rid);
+			dirty = true;
+		}
+	}
+
+	if(dirty && this._needFiring()) {
+		if(this._autoFillSegments()) {
+			this.dispatchGlobalChange();
+		} else {
+			let e = eventArg || {};
+			e["rid"] = rid;
+			e["changes"] = values; // WARNING: External user data is passed along
+			e["rowData"] = row;
+			e["type"] = type;
+			if(segmentChanged) {
+				e["segmentChanged"] = true;
+			}
+			this._dispatchDataChange(e);
+		}
+		this.requestClassifying(); // TODO: Check if needFiring method should have an effect on this request
+	}
+	return dirty;
+};
+/** Set data in a column manner. This is faster than repeatedly calling {@link DataTable#setData}
+* @public
+* @param {string} cid
+* @param {Array.<*>} valueList
+* @param {Array.<string>=} opt_ridList Specify row id to be set corresponding to the data item
+* @example
+* let dt = new DataTable();
+* dt.setColumnData("column 1", ["1st row data", "2nd row data", "3rd row data"]);
+* dt.log(); // See console for the results
+*/
+DataTable.prototype.setColumnData = function(cid, valueList, opt_ridList) { // Data changed event may be dispatched
+	let rLen = (valueList) ? valueList.length : 0;
+	if(rLen < 0) { return; }
+
+	let prevFrozen = this._frozen;
+	this.freeze();
+	let rids = this._generateRids(rLen, opt_ridList);
+
+	for(let r = 0; r < rLen; ++r) {
+		this._setData(rids[r], cid, valueList[r]);
+	}
+
+	this.freeze(prevFrozen);
+};
+/** Add, update, and remove data in batch by using JSON object. This is faster than repeatedly calling {@link DataTable#setRowData}. <br>
+Any existing row, that is not matched by the same row id provided in the argument, remains the same. <br>
+Any existing row with the same row id from the provided argument will be updated. <br>
+Row id with null value will cause a removal of the row with the same id.
+* @public
+* @param {Object.<string, Object.<string, *>>} obj Object is 2 level nested object where 1st level key is row Id and 2nd level key is column Id
+* @see {@link DataTable#addRows}
+* @see {@link DataTable#setDataFrom2DArray}
+* @example
+* let data = {
+*   "rowId 1": {"column 1": "a", "column 2": 1, "column 3": 2},
+*   "rowId 2": {"column 1": "b", "column 2": 3, "column 3": 4},
+*   "rowId 4": {"column 1": "d", "group_criteria": 1} // Rows don't need to be in uniform structure
+* };
+* let dt = new DataTable();
+* dt.setDataFromObjectMap(data);
+* dt.log(); // See console for the results
+* dt.setDataFromObjectMap({"rowId 1": null}); // Remove the row with "rowId 1"
+* dt.setDataFromObjectMap({"rowId 2": {"column 1": "newValue"} }); // Update existing row
+*/
+DataTable.prototype.setDataFromObjectMap = function(obj) {
+	if(!obj) {
+		return;
+	}
+	if(Array.isArray(obj)) {
+		this.addRows(/** @type{Array.<Object>} */(obj));
+		return;
+	}
+
+	let prevFrozen = this._frozen;
+	this.freeze();
+
+	for(let rid in obj) {
+		this.setRowData(rid, obj[rid]);
+	}
+
+	this.freeze(prevFrozen);
+};
+/** Set data in batch from 2 dimensional array. This is faster than repeatedly calling {@link DataTable#setRowData}
+* @public
+* @param {Array.<Array.<*>>} ary Row based array
+* @param {Array.<string>=} opt_cidList
+* @param {Array.<string>=} opt_ridList
+* @see {@link DataTable#addRows}
+* @see {@link DataTable#setDataFromObjectMap}
+* @example
+* let data = [
+*   ["a", 1, 2],
+*   ["b", 3, 4],
+*   ["c", 5, 6]
+* ];
+* let dt = new DataTable();
+* dt.setDataFrom2DArray(data, ["column 1", "column 2", "column 3"]);
+* dt.log(); // See console for the results
+*/
+DataTable.prototype.setDataFrom2DArray = function(ary, opt_cidList, opt_ridList) {
+	let rLen = (ary) ? ary.length : 0;
+	if(rLen < 0) { return; }
+
+	let prevFrozen = this._frozen;
+	this.freeze();
+
+	let c = 0;
+	let rids = this._generateRids(rLen, opt_ridList);
+
+	for(let r = 0; r < rLen; ++r) {
+		let row = ary[r];
+		let rid = rids[r];
+		if(opt_cidList) {
+			for(c = row.length; --c >= 0;) {
+				this._setData(rid, opt_cidList[c], row[c]);
+			}
+		} else {
+			for(c = row.length; --c >= 0;) {
+				this._setData(rid, "" + c, row[c]); // Auto-generate column id
+			}
+		}
+	}
+
+	this.freeze(prevFrozen);
+};
+
+/** Set data to individual cell by specified row index instead of row Id
+* @public
+* @param {number} rowIndex Invalid row index will not produce any effect
+* @param {string} cid
+* @param {*} value
+* @return {boolean} Return true if there is any change, and false otherwise
+* @fires DataTable#dataChanged
+*/
+DataTable.prototype.setDataAt = function(rowIndex, cid, value) { // Data changed event may be dispatched
+	let rid = this.getRowId(rowIndex);
+	return (rid) ? this.setData(rid, cid, value) : false;
+};
+/** @public
+* @param {number} rowIndex Invalid row index will not produce any effect
+* @param {Object.<string, *>=} values Object where the key is column Id and value is the data to be set
+* @param {Object=} opt_eventArg
+* @return {boolean} Return true if there is any change, and false otherwise
+* @fires DataTable#dataChanged
+*/
+DataTable.prototype.setRowDataAt = function(rowIndex, values, opt_eventArg) { // Data changed event may be dispatched
+	let rid = this.getRowId(rowIndex);
+	return (rid) ? this.setRowData(rid, values, opt_eventArg) : false;
+};
+/** Add new row of data to the end of the Data Table
+* @public
+* @param {Object.<string, *>=} values field-value pair object
+* @param {string|null=} rid If the given row Id already exists, data is updated and no new row is added. Leave blank or null to let DataTable generate unique row Id
+* @return {string} Return Row id that has been inserted or changed
+* @fires DataTable#dataChanged
+* @example
+* let dt = new DataTable();
+* dt.addRow({"column 1": "a", "column 2": 1, "column 3": null});
+* dt.addRow({"column 1": "b", "column 2": 5, "column 3": {"someKey": 10}});
+* dt.log(); // See console for the results
+*/
+DataTable.prototype.addRow = function(values, rid) {
+	if(!values) { values = {}; }
+	rid = this._generateUniqueRid(values, rid);
+
+	this.setRowData(rid, values);
+	return rid;
+};
+/** Add multiple rows all at once. This is used to improve the performance. dataChagned with globalChange flag will be fired, if multiple rows are added.
+* @public
+* @param {Array.<Object>} rows Array of field-value pair object.
+* @param {Array.<string>=} rids If the given row Id already exists, data is updated and no new row is added. Leave blank or null to let DataTable generate unique row Id
+* @fires DataTable#dataChanged
+* @see {@link DataTable#setDataFrom2DArray}
+* @see {@link DataTable#setDataFromObjectMap}
+* @example
+* let dt = new DataTable();
+* dt.addRows([
+*   {"field1": "a", "field2": 1, "field3": null},
+*   {"field1": "b", "field2": 5, "field3": {"someKey": 10}},
+*   {"field1": "c", "field2": 7, "field3": [1, 2, 3]},
+*   {"field1": "c", "field4": "some value"} // Rows don't need to be in uniform structure
+* ]); // 4 rows are added
+* dt.log(); // See console for the results
+*/
+DataTable.prototype.addRows = function(rows, rids) {
+	if(!Array.isArray(rows)) {
+		return;
+	}
+	let len = rows.length;
+	if(!len) {
+		return;
+	} else if(len === 1) {
+		this.addRow(rows[0], rids ? rids[0] : null);
+		return;
+	}
+	if(!rids) {
+		rids = [];
+	}
+	let prevFrozen = this._frozen;
+	this.freeze();
+	for(let i = 0; i < len; ++i) {
+		this.addRow(rows[i], rids[i]);
+	}
+	this.freeze(prevFrozen);
+};
+
+/** Insert a new row as the first row
+* @public
+* @param {Object.<string, *>=} opt_values
+* @param {string|null=} opt_rid If the given row Id already exists, data is updated and no new row is added. Leave blank or null to let DataTable generate unique row Id
+* @return {string} Return Row id that has been inserted or changed
+* @fires DataTable#dataChanged
+* @see {@link DataTable#insertRow}
+*/
+DataTable.prototype.unshiftRow = function(opt_values, opt_rid) {
+	return this.insertRow(0, opt_values, opt_rid);
+};
+/** @public
+* @param {(string|number|null)=} rowRef
+* @param {Object.<string, *>=} values Key/value pair object map
+* @param {string|null=} rid If the given row Id already exists, data is updated and no new row is added. Leave blank or null to let DataTable generate unique row Id
+* @return {string} Return Row id that has been inserted or changed
+* @fires DataTable#dataChanged
+* @see {@link DataTable#unshiftRow}
+* @see {@link DataTable#removeRow}
+*/
+DataTable.prototype.insertRow = function(rowRef, values, rid) {
+	let arg = null;
+	if(typeof rowRef === "number") {
+		arg = {};
+		arg["nextRid"] = this._rids[rowRef];
+		arg["fallback"] = rowRef; // Fallback index in case of no nextRid found
+	} else if(rowRef) {
+		arg = {};
+		arg["nextRid"] = /** @type{string} */(rowRef);
+	}
+
+	if(!values) { values = {}; }
+	rid = this._generateUniqueRid(values, rid);
+
+	this.setRowData(rid, values, arg);
+	return rid;
+};
+/** @public
+ * @param {string|number} rowRef
+ * @param {Object=} opt_values
+ * @param {string=} opt_rid
+ * @return {string}
+ * @fires DataTable#dataChanged
+ */
+DataTable.prototype.insertAfter = function(rowRef, opt_values, opt_rid) {
+	let rowIndex = (typeof rowRef === "string") ? this.getRowIndex(rowRef) : /** @type{number}*/ (rowRef);
+
+	if(!(rowIndex >= 0) || rowIndex >= this._rids.length - 1) {
+		return this.addRow(opt_values, opt_rid);
+	}
+	return this.insertRow(rowIndex + 1, opt_values, opt_rid);
+};
+
+/** @public
+* @param {number|string} rowRef Reference to the row to be removed
+* @see {@link DataTable#removeRows}
+*/
+DataTable.prototype.removeRow = function(rowRef) { // Data changed event may be dispatched
+	if(typeof rowRef === "number") {
+		this.setRowData(this.getRowId(rowRef), null);
+	} else {
+		this.setRowData(/** @type{string} */(rowRef), null);
+	}
+};
+/** @public
+* @param {Array.<number|string>} refs Reference to the rows to be removed
+* @see {@link DataTable#removeAllRows}
+*/
+DataTable.prototype.removeRows = function(refs) {
+	let rid;
+	if(refs.length === 1) {
+		rid = refs[0];
+		if (typeof rid === "number") {
+			this.removeRow(rid);
+		} else {
+			this.setRowData(rid, null);
+		}
+		return;
+	}
+
+	let i;
+	let dirty = false;
+	this._removedRows = {};
+	for (i = refs.length; --i >= 0;) {
+		rid = refs[i];
+		if (typeof rid === "number") {
+			rid = this.getRowId(rid);
+		}
+
+		let row = this.getRowData(rid);
+		if(row) {
+			this._prevData[rid] = this._rows[rid];
+			this._removedRows[rid] = 1;
+			delete this._rows[rid];
+			this._removeRidFromSegments(rid);
+			dirty = true;
+		}
+	}
+	if(dirty) {
+		this._rids = this._rids.filter(this._removeRows);
+		this._removedRows = null;
+		this.dispatchGlobalChange();
+	} else {
+		this._removedRows = null;
+	}
+};
+/** @private
+* @param {string} rid
+* @return {boolean}
+*/
+DataTable.prototype._removeRows = function(rid) {
+	return !this._removedRows[rid];
+};
+
+/** @private
+* @param {Array} ary
+* @param {*} item
+* @return {boolean}
+*/
+DataTable._removeArrayItem = function(ary, item) {
+	let at = ary.indexOf(item);
+	if(at >= 0) {
+		if(at >= ary.length) {
+			ary.pop(); // Array.pop is 100 times faster than Array.splice
+		} else {
+			ary.splice(at, 1);
+		}
+		return true;
+	}
+	return false;
+};
+/** Remove all existing rows
+* @override
+*/
+DataTable.prototype.clearAllData = function(suppressEvent) {
+	DataTable.base(this, "clearAllData", true);
+	this._prevData = {};
+
+	if(this._segments) {
+		this._segments.dispose();
+		this._segments = null;
+	}
+
+	if(this._rids.length) {
+		this._rids.length = 0;
+
+		this.dispatchGlobalChange(suppressEvent);
+	}
+};
+/** Alias to {@link DataTable#clearAllData}
+* @public
+* @function
+* @param {boolean=} suppressEvent
+* @fires DataTable#dataChanged
+*/
+DataTable.prototype.removeAllRows = DataTable.prototype.clearAllData;
+/** @private
+* @function
+* @param {number} a
+* @param {number} b
+* @return {number}
+*/
+DataTable._ascendingOrder = function(a, b) { return a - b; };
+/** @public
+* @param {Array.<number>|number} fromIndex
+* @param {number} toIndex
+* @param {boolean=} suppressEvent
+* @return {Array.<string>|string} Return row id(s). Return null if nothing has changed
+*/
+DataTable.prototype.moveRow = function(fromIndex, toIndex, suppressEvent) {
+	let output = null;
+	let rid = "";
+	if(!(toIndex >= 0 && toIndex < this._rids.length)) {
+		toIndex = this._rids.length;
+	}
+
+	if (Array.isArray(fromIndex)) {
+		let fromIndices = fromIndex;
+		fromIndices.sort(DataTable._ascendingOrder);
+		let movedRids = [];
+		for (let i = fromIndices.length; --i >= 0;) {
+			let idx = fromIndices[i];
+			rid = this._rids[idx];
+			if(rid) {
+				movedRids.unshift(rid);
+				this._rids.splice(idx, 1); // WARNING: splice method is slow
+				if (idx < toIndex) {
+					--toIndex;
+				}
+			}
+		}
+		if(movedRids.length) {
+			this._rids.splice.apply(this._rids, [toIndex, 0].concat(movedRids));
+			output = movedRids;
+		}
+	} else {
+		if (fromIndex < 0) {
+			fromIndex = 0;
+		}
+
+		if(fromIndex !== toIndex && (fromIndex + 1) !== toIndex) {
+			rid = this._rids.splice(fromIndex, 1)[0];
+			if (rid) {
+				if (fromIndex < toIndex) {
+					--toIndex;
+				}
+				this._rids.splice(toIndex, 0, rid);
+				output = rid;
+			}
+		}
+	}
+
+	if(output) {
+		if(this._segments) {
+			this._segments.invalidateSegmentOrder();
+			this._sort(null); // Reorder segment members
+		}
+		this._dispatchPositionChange(suppressEvent);
+	}
+	return output;
+};
+/** @public
+* @ignore
+* @param {Array.<string>} fromRids
+* @param {string} toRid If rid is empty string, insert the rid to the last index
+* @param {boolean=} suppressEvent
+* @return {Array.<string>|string} rid
+*/
+DataTable.prototype._moveRow = function(fromRids, toRid, suppressEvent) {
+	let len = fromRids.length;
+	if(!len) {
+		return null;
+	}
+
+	let fromIndices = new Array(len);
+	for(let i = 0; i < len; ++i) {
+		fromIndices[i] = this.getRowIndex(fromRids[i]);
+	}
+
+	let toIndex = (toRid) ? this.getRowIndex(toRid) : this._rids.length;
+	if(len > 1) {
+		return this.moveRow(fromIndices, toIndex, suppressEvent);
+	}
+	return this.moveRow(fromIndices[0], toIndex, suppressEvent);
+};
+
+/** Move rows in chunk by specifying chunk size in the third parameter.
+* @public
+* @param {number|string} startIndex
+* @param {number|string} toIndex
+* @param {number=} opt_count
+* @param {boolean=} suppressEvent
+* @return {Array.<string>} rids Return null if nothing has changed
+* @see {@link DataTable#moveRow}
+*/
+DataTable.prototype.moveRows = function(startIndex, toIndex, opt_count, suppressEvent) {
+	if(typeof startIndex === "string") {
+		startIndex = this.getRowIndex(startIndex);
+	}
+	if(typeof toIndex === "string") {
+		toIndex = this.getRowIndex(toIndex);
+	}
+	if(startIndex < 0) { startIndex = 0; }
+	if(toIndex < 0) { toIndex = this._rids.length; }
+	if(!opt_count) { opt_count = 1; }
+
+	let endIndex = startIndex + opt_count - 1;
+	let targetIndex = toIndex;
+	if (toIndex >= startIndex) {
+		if (toIndex <= endIndex) {
+			targetIndex = startIndex;
+		} else {
+			targetIndex = toIndex - opt_count;
+		}
+	}
+
+	if ((opt_count > 0) && (endIndex <= this._rids.length)) {
+		if (targetIndex > this._rids.length) {
+			targetIndex = this._rids.length;
+		}
+
+		let rows = this._rids.splice(startIndex, opt_count);
+		let args = [targetIndex, 0].concat(rows);
+		Array.prototype.splice.apply(this._rids, args);
+
+		if(this._segments) {
+			this._sort(null); // Reorder segment members
+		}
+		this._dispatchPositionChange(suppressEvent);
+		return rows;
+	}
+
+	return null;
+};
+
+/** This method is deprecated in favor of more sophisticate {@link DataTable#moveRow}
+* @public
+* @param {number} fromIndex
+* @param {number} toIndex
+*/
+DataTable.prototype.swapRow = function(fromIndex, toIndex) { // No event is fired. No effect on other views
+	let len = this._rids.length;
+	if(fromIndex < 0 || fromIndex >= len) { return; }
+	if(toIndex < 0 || toIndex >= len) { return; }
+
+	let rid = this._rids[fromIndex];
+	this._rids[fromIndex] = this._rids[toIndex];
+	this._rids[toIndex] = rid;
+};
+
+/**
+* @protected
+* @override
+* @ignore
+* @param {string} fromRid
+* @param {string} toRid
+* @return {boolean}
+*/
+DataTable.prototype._replaceRowId = function(fromRid, toRid) {
+	let rids = this._rids;
+	let idx = rids.indexOf(fromRid);
+	if(idx >= 0) {
+		rids[idx] = toRid;
+		this._rows[toRid] = this._rows[fromRid];
+		delete this._rows[fromRid];
+		this._prevData[toRid] = this._prevData[fromRid];
+		delete this._prevData[fromRid];
+		return true;
+	}
+	return false;
+};
+/**
+* @public
+* @override
+* @ignore
+* @param {Object} ridPair
+*/
+DataTable.prototype.replaceRowIds = function(ridPair) {
+	if(typeof ridPair === "object") {
+		let dirty = false;
+		for(let oldRid in ridPair) {
+			dirty |= this._replaceRowId(oldRid, ridPair[oldRid]);
+		}
+		if(dirty) {
+			this.dispatchGlobalChange();
+		}
+	}
+};
+
+/** @public
+* @function
+* @param {string} rid
+*/
+DataTable.prototype.clearRowData = DataTable.prototype.removeRow;
+/** {@link DataCache#clearColumnData}
+* @override
+*/
+DataTable.prototype.clearColumnData = function(colId, suppressEvent) {
+	let cids = (typeof colId === "string") ? [/** @type {string} */(colId)] : /** @type {Array.<string>} */(colId);
+	for(let i = cids.length; --i >= 0;) {
+		let cid = cids[i];
+		if(cid) {
+			for(let rid in this._rows) {
+				delete this._rows[rid][cid];
+				delete this._prevData[rid][cid];
+			}
+		}
+	}
+
+	this.dispatchGlobalChange(suppressEvent);
+};
+
+/** Get parent data source. Note that DataTable cannot be child of other data source. So the returned value will always be null.
+* @public
+* @return {null}
+*/
+DataTable.prototype.getDataSource = function() {
+	return null; // No other source
+};
+/** @public
+* @param {*} source
+*/
+DataTable.prototype.setDataSource = function(source) {};
+
+/**
+* @public
+* @ignore
+* @return {Object.<string, DataTable.SortLogic>}
+*/
+DataTable.prototype.getSortingLogics = function() {
+	return this._compMap;
+};
+/** @public
+* @param {string|Array.<string>} cid Column id
+* @param {(string|number|Array.<string|number>)=} sortOrders "a"|"d"|"n"
+* @param {DataTable.SortLogic=} customComparer
+* @param {*=} contextObj Context object that will be provided as the forth parameter of the given comparer method
+* @return {boolean} Return true if there is any change, otherwise false
+* @fires DataTable#dataChanged
+*/
+DataTable.prototype.sortOnce = function(cid, sortOrders, customComparer, contextObj) {
+	let sortingDefs = DataTable._buildSortContext(
+		[],
+		cid,
+		sortOrders,
+		customComparer || this._compMap,
+		contextObj // User context
+	);
+
+	if(this._sort(sortingDefs)) {
+		this._dispatchPositionChange();
+		return true;
+	}
+	return false;
+};
+/** @public
+* @param {DataTable.SortLogic} func
+* @example
+* customLogic = function(a, b, sortOrder) {
+*   return (a - b) * sortOrder; // for numeric comparison
+* };
+* let dt = new DataTable();
+* dt.setSortingLogic(customLogic);
+* dt.sortOnce("Column id", "ascending");
+*/
+DataTable.prototype.setSortingLogic = function(func) {
+	this._compMap["_default"] = func;
+};
+/** Specified sorting logic for the column with the given column id. This will override logic set by {@link DataTable#setSortingLogic}, when the column is sorted
+* @public
+* @param {string} cid
+* @param {DataTable.SortLogic} func Use null to remove current sorting logic
+*/
+DataTable.prototype.setColumnSortingLogic = function(cid, func) {
+	if(cid) {
+		this._compMap[cid] = func;
+	}
+};
+/** Get sorting logic for the specified field. Default logic is returned, if no logic is specified for the column
+* @public
+* @param {string=} cid
+* @return {DataTable.SortLogic}
+*/
+DataTable.prototype.getColumnSortingLogic = function(cid) {
+	if(cid) {
+		let logic = this._compMap[cid];
+		if(logic) {
+			return logic;
+		}
+	}
+
+	return this._compMap["_default"] || null;
+};
+
+/** Freeze data table so that no event is fired for data processing until executing {@link DataTable#unfreeze} method
+* @public
+* @param {boolean=} bool
+* @return {boolean} Previous freeze state before the execution
+* @fires DataTable#dataChanged
+* @example
+* let prevState = dt.freeze();
+* for(let i = 0; i < 100; ++i) {
+*   dt.insertRow(); // no event is fired
+* }
+* dt.freeze(prevState); // Restore previous freeze states
+*/
+DataTable.prototype.freeze = function(bool) {
+	bool = bool !== false;
+	let prevState = this._frozen;
+	if(prevState !== bool) {
+		this._frozen = bool;
+		if(!bool && this._segments) { // for no sorting case
+			this._segments.invalidateSegmentOrder();
+		}
+		this._autoFillSegments();
+		this.dispatchGlobalChange();
+	}
+	return prevState;
+};
+/** @public
+* @param {boolean=} bool
+* @return {boolean} Previous freeze state before the execution
+*/
+DataTable.prototype.unfreeze = function(bool) {
+	return this.freeze(bool === false);
+};
+/** @public
+* @return {boolean} Current freeze state
+*/
+DataTable.prototype.isFrozen = function() {
+	return this._frozen;
+};
+
+/** @private
+*/
+DataTable.prototype._initSegmentCollection = function() {
+	if (!this._segments) {
+		this._segments = new SegmentCollection();
+		this._segments.setDefaultCollapsing(this._segmentDefaultCollapsing);
+		this._segments.addEventListener("subSegmentChanged", this._onSubSegmentChanged);
+	}
+};
+/** Add or remove all segments from the given row ids
+* @public
+* @param {Array.<string>} rids
+* @param {boolean=} enabled
+* @return {boolean} Return true if there is any change
+*/
+DataTable.prototype.setSegmentSeparators = function(rids, enabled) {
+	if (!rids) {
+		return false;
+	}
+	let adding = (enabled !== false);
+	let segmentAdded = 0;
+	let segmentRemoved = 0;
+
+	let len = rids.length;
+	for (let i = 0; i < len; i++) {
+		let rid = rids[i];
+		if(adding) {
+			this._initSegmentCollection();
+			if(this._autoSegmentFilling) {
+				let parentId = this._segments.getParentRowId(rid);
+				if(parentId) {
+					this._segments.removeSegmentChild(parentId, rid);
+				}
+			}
+			segmentAdded |= this._segments.addSegment(rid);
+		} else if (this._segments) { // Removing
+			let segment = this._segments.getSegment(rid);
+			if(segment) {
+				if(this._segments.removeSegment(rid)) {
+					segmentRemoved = 1;
+					if(!this._segments.getSegmentCount()) {
+						this._segments = null;
+					}
+				}
+			}
+		}
+	}
+	let changed = segmentAdded || segmentRemoved;
+	if(changed && this._needFiring()) {
+		this.dispatchGlobalChange();
+	}
+	return changed ? true : false;
+};
+
+/**
+* @public
+* @param {string} rid
+* @param {*=} options=null Segment options. If the value is false, segment separator will be stripped off from the given rid
+* @return {boolean} Return true if there is any change
+*/
+DataTable.prototype.setSegmentSeparator = function(rid, options) {
+	let change = false;
+	let memberCount = 0;
+	if(rid && typeof rid === "string") {
+		if(options !== false) {
+			this._initSegmentCollection();
+			if(this._autoSegmentFilling) {
+				let parentId = this._segments.getParentRowId(rid);
+				if(parentId) {
+					this._segments.removeSegmentChild(parentId, rid);
+				}
+			}
+			let children = (options && options["children"]) ? options["children"] : null;
+			if(this._segments.addSegment(rid, children)) {
+				change = true;
+			}
+		} else if(this._segments) { // Remove the separator
+			let segment = this._segments.getSegment(rid);
+			if(segment) {
+				memberCount = segment.getChildCount();
+				if(this._segments.removeSegment(rid)) {
+					change = true;
+					if(!this._segments.getSegmentCount()) {
+						this._segments = null;
+					}
+				}
+			}
+		}
+	}
+	if(change && this._needFiring()) {
+		if(this._autoFillSegments() || memberCount) {
+			this.dispatchGlobalChange();
+		} else {
+			let rowData = this._rows[rid] || null;
+			if(rowData) {
+				this._dispatchDataChange({
+					"rid": rid,
+					"changes": {},
+					"rowData": rowData,
+					"type": "updated",
+					"segmentChanged": true
+				});
+			}
+		}
+	}
+
+	return change;
+};
+/** @public
+* @return {boolean} Return true if there is any change
+*/
+DataTable.prototype.unsetAllSegmentSeparators = function() {
+	if(this._segments) {
+		this._segments.dispose();
+		this._segments = null;
+		this.dispatchGlobalChange();
+		return true;
+	}
+	return false;
+};
+/**
+* @public
+* @return {boolean}
+*/
+DataTable.prototype.hasSegmentation = function() {
+	return this._segments ? true : false;
+};
+/**
+* @public
+* @return {boolean}
+*/
+DataTable.prototype.hasSegmentClassification = function() {
+	return this._segments ? this._segments.hasClassification() : false;
+};
+/**
+* @public
+* @param {string} rid
+* @return {boolean}
+*/
+DataTable.prototype.isSegmentSeparator = function(rid) {
+	if(this._segments) {
+		return this._segments.containsSegment(rid);
+	}
+	return false;
+};
+/** Get Segment object
+* @public
+* @param {string} rid Row id
+* @return {Segment} Returns null if a segment cannot be found
+*/
+DataTable.prototype.getSegment = function(rid) {
+	if(this._segments) {
+		return this._segments.getSegment(rid);
+	}
+	return null;
+};
+/**
+* @public
+* @param {string} rid Row id of a segment child
+* @return {Segment} Returns null if a segment cannot be found
+*/
+DataTable.prototype.getSegmentParent = function(rid) {
+	if(this._segments) {
+		return this._segments.getSegmentParent(rid);
+	}
+	return null;
+};
+/** Segment level starts from 1
+* @public
+* @param {string} rid
+* @return {number} Return 0 if the given rid is not a segment
+*/
+DataTable.prototype.getSegmentLevel = function(rid) {
+	let segment = this.getSegment(rid);
+	if(segment) {
+		return segment.getSegmentLevel() + 1;
+	}
+	return 0;
+};
+/**
+* @public
+* @param {string} rid
+* @return {string} parent row id of this segmentation. If the parent row id for this segmentation cannot be found, return ""
+*/
+DataTable.prototype.getSegmentParentRowId = function(rid) {
+	if(this._segments) {
+		return this._segments.getParentRowId(rid);
+	}
+	return "";
+};
+/**
+* @public
+* @param {Array.<string>=} rids If no row id is given, row ids of this data table is used instead
+* @param {boolean=} partial Indicating that the given ids are not the whole list
+* @return {Array.<number>} Return null if there is no segmentation
+*/
+DataTable.prototype.getSegmentValues = function(rids, partial) {
+	if(this._segments) {
+		this._segments.calcSegmentOrder(this._rids, true); // use cache
+		return this._segments.getSegmentValues(rids || this._rids, partial);
+	}
+	return null;
+};
+/**
+* @private
+* @param {number} at Row index
+* @return {boolean} Return true if the given row is in the last segment
+*/
+DataTable.prototype._isLastSegment = function(at) {
+	let segmentSeparators = this._segments;
+	if(segmentSeparators) {
+		let rids = this._rids;
+		let rowCount = rids.length;
+		for(let r = at + 1; r < rowCount; ++r) {
+			if(segmentSeparators.containsSegment(rids[r])) {
+				return false;
+			}
+		}
+	}
+	return true;
+};
+/**
+* @public
+* @ignore
+* @return {SegmentCollection} Return null if there is no segmentation
+*/
+DataTable.prototype._getSegmentSeparators = function() {
+	return this._segments;
+};
+/** @public
+* @param {boolean=} enabled
+* @ignore
+*/
+DataTable.prototype.enableAutoSegmentFilling = function(enabled) {
+	this._autoSegmentFilling = enabled != false;
+	this._autoFillSegments();
+};
+/** @private
+* @return {boolean} Return true if the fill segments have changed, otherwise return false
+*/
+DataTable.prototype._autoFillSegments = function() {
+	if(this._autoSegmentFilling) {
+		return this.fillSegments();
+	}
+	return false;
+};
+/** Remove existing segment children and fill the segments with all content rows before the next segment separator
+* @public
+* @param {string} segmentId Row id
+*/
+DataTable.prototype.fillSegment = function(segmentId) {
+	if(this._segments) {
+		this._segments.fillSegment(segmentId, this._rids);
+		this.dispatchGlobalChange();
+		this.requestClassifying();
+	}
+};
+/** Remove all existing segment children in each segment and fill the segments with all contnet rows before the next segment separator
+* @public
+* @return {boolean} Return true if the fill segments have changed, otherwise return false
+*/
+DataTable.prototype.fillSegments = function() {
+	if(this._segments) {
+		let dirty = this._segments.fillSegments(this._rids);
+		if(dirty) {
+			this.dispatchGlobalChange();
+			this.requestClassifying();
+		}
+		return dirty;
+	}
+	return false;
+};
+/** @private
+* @param {boolean=} adding This indicates that segment is changed by adding a new child
+*/
+DataTable.prototype._onSegmentChildChanged = function(adding) {
+	if(adding !== false) {
+		this._sort(null);
+	}
+	this._dispatchPositionChange(); // Force rerendering, even if there is no position change
+
+	this.requestClassifying();
+};
+/** @public
+* @param {string} segmentId Row id
+* @param {string} rid Row id
+* @param {string=} dataId Row id for retrieving data
+* @return {boolean} Return true if there is any change
+*/
+DataTable.prototype.addSegmentChild = function(segmentId, rid, dataId) {
+	if(this._segments) {
+		let dirty = this._segments.addSegmentChild(segmentId, rid, dataId);
+		if(dirty) {
+			this._onSegmentChildChanged();
+			return true;
+		}
+	}
+	return false;
+};
+/** @public
+* @param {string} segmentId Row id
+* @param {Array.<string>} rids Row id
+* @param {Array.<string>=} dataIds Row ids for retrieving data
+* @return {boolean} Return true if there is any change
+*/
+DataTable.prototype.addSegmentChildren = function(segmentId, rids, dataIds) {
+	if(this._segments) {
+		let dirty = this._segments.addSegmentChildren(segmentId, rids, dataIds);
+		if(dirty) {
+			this._onSegmentChildChanged();
+			return true;
+		}
+	}
+	return false;
+};
+
+/** Deprecated. Remove all existing children and add new children according to the give array
+* @public
+* @param {Array.<Object>} segmentArr Segment array that contain "segmentId", "rowIds" to set segment children
+* @return {boolean} Return true if there is any change
+*/
+DataTable.prototype.setSegmentChildren = function(segmentArr) {
+	if(!this._segments) {
+		return false;
+	}
+	let dirty = this._segments.removeAllSegmentChildren();
+	let len = segmentArr.length;
+	for (let i = 0; i < len; i++) {
+		let obj = segmentArr[i];
+		if(this._segments.addSegmentChildren(obj["segmentId"], obj["rowIds"])) {
+			dirty = true;
+		}
+	}
+	if(dirty) {
+		this._onSegmentChildChanged();
+		return true;
+	}
+
+	return false;
+};
+/** @public
+* @param {string} segmentId Row id
+* @param {string} rid Row id
+* @return {boolean} Return true if there is any change
+*/
+DataTable.prototype.removeSegmentChild = function(segmentId, rid) {
+	if(this._segments) {
+		let dirty = this._segments.removeSegmentChild(segmentId, rid);
+		if(dirty) {
+			this._onSegmentChildChanged(false);
+		}
+		return dirty;
+	}
+	return false;
+};
+/** @public
+* @param {string} segmentId Row id
+* @param {Array.<string>} rids Row id
+* @return {boolean} Return true if there is any change
+*/
+DataTable.prototype.removeSegmentChildren = function(segmentId, rids) {
+	if(this._segments) {
+		let dirty = this._segments.removeSegmentChildren(segmentId, rids);
+		if(dirty) {
+			this._onSegmentChildChanged(false);
+		}
+		return dirty;
+	}
+	return false;
+};
+/** @public
+* @return {boolean} Return true if there is any change
+*/
+DataTable.prototype.removeAllSegmentChildren = function() {
+	if(this._segments) {
+		let dirty = this._segments.removeAllSegmentChildren(); // This immediately remove all sub segments
+		if (dirty) {
+			this._onSegmentChildChanged(false);
+		}
+		return dirty;
+	}
+	return false;
+};
+/** Get row ids of all segment separator
+* @public
+* @return {Array.<string>} Return null if there is no segment separator
+*/
+DataTable.prototype.getSegmentIds = function() {
+	if(this._segments) {
+		return this._segments.getSegmentIds();
+	}
+	return null;
+};
+/** Get row ids of all children from the specified segment
+* @public
+* @param {string} segmentId
+* @return {Array.<string>} Returns array of row ids. Returns null if there is no child or no segment separator found
+*/
+DataTable.prototype.getSegmentChildIds = function(segmentId) {
+	if(this._segments) {
+		let segment = this._segments.getSegment(segmentId);
+		if(segment) {
+			let chdr = segment.getChildIds();
+			return chdr.length ? chdr : null;
+		}
+	}
+	return null;
+};
+/**
+* @private
+* @param {(Array|number)} sortOrder
+* @param {*} context
+*/
+DataTable.prototype._setSegmentSortContext = function (sortOrder, context) {
+	this._segmentSortOrder = sortOrder;
+	this._segmentSortContext = context;
+};
+/** Sort all of existing segments by multiple sort logics
+* @public
+* @param {Function|Array.<Function>|Object} sortLogics
+* @param {Array.<number|string>=} sortOrders
+* @param {Array.<string>=} cids
+* @return {boolean}
+*/
+DataTable.prototype.sortSeparators = function (sortLogics, sortOrders, cids) {
+	if(!this._segments){
+		return false;
+	}
+	if(typeof sortLogics === "function"){
+		this._setSegmentSortContext(DataTable._getSortOrder(sortOrders), cids);
+		return this.sortSegments(sortLogics);
+	}
+	if(!cids) {
+		return false;
+	}
+	let sortingDefs = DataTable._buildSortContext(
+		[],
+		cids,
+		sortOrders,
+		sortLogics || this._compMap
+	);
+	let defCount = sortingDefs.length;
+	let sortLogic = null;
+	if(defCount > 1) {
+		sortLogic = DataTable._multiColumnSeparatorCompareLogic;
+		this._setSegmentSortContext(1, sortingDefs);
+	} else if(defCount === 1) { // Single level sorting
+		sortLogic = DataTable._singleColumnSeparatorCompareLogic;
+		this._setSegmentSortContext(sortingDefs[0][3], sortingDefs[0]); // sortOrder and context
+	} else {
+		return false;
+	}
+	return this.sortSegments(sortLogic);
+};
+/** Sort all of existing segments by given compare function
+* @public
+* @param {Function} compare
+* @return {boolean}
+*/
+DataTable.prototype.sortSegments = function (compare) {
+	if(!this._segments) {
+		return false;
+	}
+	if(typeof compare !== "function") {
+		return false;
+	}
+
+	this._userSegmentComparer = compare;
+
+	let segments = this._segments;
+	let rootSegments = segments.sortSegments(this._bySegmentSeparator);
+
+	this._userSegmentComparer = null;
+	this._setSegmentSortContext(0, null);
+
+	let rids = this._rids;
+	let origRids = rids.slice();
+	let rowCount = rids.length;
+	rids.length = 0;
+
+	let segmentCount = 0;
+	let dirty = false;
+	for(let i = 0; i < rowCount; ++i) {
+		let rid = origRids[i];
+		let segment = segments.getSegment(rid);
+		if(segment) {
+			if(segment.isRootSegment()) {
+				rootSegments[segmentCount++].getFlattenTreeIds(rids);
+			}
+		} else if(!segments.getParentRowId(rid)) {
+			rids.push(rid);
+		}
+		if(rid !== rids[i]) {
+			dirty = true;
+		}
+	}
+
+	if(dirty) {
+		this._sort(null);
+		this._dispatchPositionChange();
+	}
+	return dirty;
+};
+/** Sort all of existing segments by given compare function
+* @private
+* @param {*} rowA
+* @param {*} rowB
+* @return {number}
+*/
+DataTable.prototype._bySegmentSeparator = function (rowA, rowB) {
+	return /** @type{number} */(this._userSegmentComparer(
+		this._getRowDataFromSegment(rowA),
+		this._getRowDataFromSegment(rowB),
+		this._segmentSortOrder,
+		this._segmentSortContext
+	));
+};
+/** Get row data from either Segment or row id
+* @private
+* @param {*} obj
+* @return {Object}
+*/
+DataTable.prototype._getRowDataFromSegment = function (obj) {
+	var rowData = null;
+	if(obj) {
+		if(typeof obj == "string") {
+			rowData = this.getRowData(obj);
+		} else if(obj.getId) {
+			rowData = this.getRowData(obj.getId());
+		}
+	}
+	return rowData;
+};
+
+/** A data source to be used with segment classification
+* @public
+* @param {DataCache} dc
+*/
+DataTable.prototype.setClassificationSource = function(dc) {
+	this._clsSource = null;
+
+	if(dc && dc._rows) {
+		this._clsSource = dc._rows;
+	}
+};
+/**
+* @public
+* @param {string} segmentId
+* @param {string|Array.<string>} fields
+* @return {boolean}
+*/
+DataTable.prototype.setSegmentClassification = function(segmentId, fields) {
+	if(this._segments) {
+		let dirty = this._segments.setSegmentClassification(segmentId, fields);
+		if(dirty) {
+			return this.classifySegments();
+		}
+	}
+	return false;
+};
+/** @public
+* @return {boolean}
+*/
+DataTable.prototype.classifySegments = function() {
+	if(this._segments) {
+		if(this._rids.length) {
+			return this._segments.classify(this._clsSource || this._rows);
+		}
+	}
+	return false;
+};
+
+/** @public
+*/
+DataTable.prototype.requestClassifying = function() {
+	if(this._segments && !this._classifyingTimer) {
+		if(this._segments.hasClassification()) {
+			this._classifyingTimer = setTimeout(this._onClassifyingTimer, 10);
+		}
+	}
+};
+/** @private
+*/
+DataTable.prototype._onClassifyingTimer = function() {
+	this._classifyingTimer = 0;
+	this.classifySegments();
+};
+/** @private
+* @param {Object} e
+*/
+DataTable.prototype._onSubSegmentChanged = function(e) {
+	let insertionList = /** @type{Array.<Segment>} */(e["insertionList"]);
+	let removalList = /** @type{Array.<string>} */(e["removalList"]);
+
+	let dirty = false;
+	let rows = this._rows;
+	let clsSource = this._clsSource || rows;
+	let rids = this._rids;
+	let prevData = this._prevData;
+	let i;
+
+	let removalCount = removalList.length;
+	let removedRows = {};
+	for(i = 0; i < removalCount; i++) {
+		let rid = removalList[i];
+		if(rows[rid]) {
+			removedRows[rid] = prevData[rid] = rows[rid];
+			delete rows[rid];
+			DataTable._removeArrayItem(rids, rid);
+			dirty = true;
+			// TODO: Remove classification source
+		}
+	}
+
+	let insertionCount = insertionList.length;
+	for(i = 0; i < insertionCount; i++) {
+		let segment = insertionList[i];
+		let parentId = segment.getParentId();
+		let segmentId = segment.getId();
+
+		if(!rows[segmentId]) {
+			prevData[segmentId] = {};
+			segment.setRowData(rows, clsSource);
+
+			let parentAt = rids.indexOf(parentId);
+			if(parentAt < 0 || parentAt + 1 >= rids.length) {
+				rids.push(segmentId);
+			} else {
+				rids.splice(parentAt + 1, 0, segmentId);
+			}
+			dirty = true;
+		}
+	}
+	if(dirty) {
+		e["removedRows"] = removedRows;
+		this._dispatch("subSegmentChanged", e);
+		this.dispatchGlobalChange(); // Rerender everything
+	}
+};
+
+/**
+* @public
+* @param {boolean} bool
+* @return {boolean}
+*/
+DataTable.prototype.setSegmentDefaultCollapsing = function(bool) {
+	if(this._segmentDefaultCollapsing !== bool) {
+		this._segmentDefaultCollapsing = bool;
+		if(this._segments) {
+			this._segments.setDefaultCollapsing(bool);
+		}
+		return true;
+	}
+	return false;
+};
+
+
+/**
+* @public
+* @ignore
+* @param {Array.<Array>} sortingDefs
+* @return {boolean} Return true if there is any change, otherwise false
+*/
+DataTable.prototype._sort = function(sortingDefs) {
+	let rids = this._rids;
+	let dataRows = this.getMultipleRowData(rids);
+	let segmentValues = this.getSegmentValues(rids);
+	let change = DataTable._performMultiLevelSorting(dataRows, sortingDefs, segmentValues);
+
+	if(change) {
+		this._rids = DataTable._reorderItems(rids, change);
+		return true;
+	}
+	return false;
+};
+
+/** Simulate data changed event by firing global change event argument to all listeners<br>
+* Normally this will force data view to do sorting, filtering, and grouping again
+* @public
+* @param {boolean=} suppressEvent
+* @fires DataTable#dataComposed
+* @fires DataTable#dataChanged
+*/
+DataTable.prototype.dispatchGlobalChange = function(suppressEvent) {
+	if(!suppressEvent && this._needFiring()) {
+		this._dispatchDataChange(DataTable._globalChangeArg);
+	}
+};
+/** Position change will not cause dataComposed to be fired
+* @private
+* @param {boolean=} suppressEvent
+* @fires DataTable#dataChanged
+*/
+DataTable.prototype._dispatchPositionChange = function(suppressEvent) {
+	if(!suppressEvent && this._needFiring()) {
+		this._dispatch("dataChanged", DataTable._positionChangeArg);
+	}
+};
+
+/** {@link DataCache#dump} Construct a JSON object that is compatible with console.table()
+* @override
+* @param {Object=} opt_options {@link DataCache#dump}
+* @return {!Array.<Object>} Return a JSON object that is compatible with console.table()
+* @see {@link DataCache#dump}
+*/
+DataTable.prototype.dump = function(opt_options) {
+	return DataCache.constructTable(this.getMultipleRowData(this._rids), opt_options, this._rids);
+};
+
+
+/** @private
+* @param {string} rid
+* @param {string} cid
+* @param {*} value
+* @return {boolean} Return true if there is any change, and false otherwise
+*/
+DataTable.prototype._setData = function(rid, cid, value) {
+	let row = this.getRowData(rid);
+
+	if(!row) {
+		row = {};
+		this._rows[rid] = row;
+		this._prevData[rid] = {};
+		this._rids.push(rid);
+	}
+	this._prevData[rid][cid] = row[cid];
+	row[cid] = value;
+	return true;
+};
+/** @private
+* @param {number} len
+* @param {Array.<string>=} opt_ridList
+* @returns {Array.<string>}
+*/
+DataTable.prototype._generateRids = function(len, opt_ridList) {
+	let r = 0, rids;
+	if(opt_ridList) {
+		rids = opt_ridList;
+	} else {
+		rids = [];
+		let rowCount = this._rids.length;
+		while(r < rowCount && r < len) {
+			rids.push(this._rids[r++]);
+		}
+	}
+	r = rids.length;
+	while(r < len) {
+		rids.push("" + r++); // Auto-generate row id
+	}
+	return rids;
+};
+/** @private
+* @param {Object} values
+* @param {string|null=} rid
+* @return {string}
+*/
+DataTable.prototype._generateUniqueRid = function(values, rid) {
+	if(!rid) {
+		if(values["ROW_ID"]) {
+			return values["ROW_ID"];
+		}
+		rid = "_" + this._runningId++;
+		while(this._rows[rid]) {
+			rid = "_" + this._runningId++;
+		}
+	}
+	return rid;
+};
+
+/** @private
+* @return {boolean}
+*/
+DataTable.prototype._needFiring = function() {
+	return !this._frozen && !this._composing;
+};
+
+/** Deprecated
+* @deprecated
+* @public
+* @function
+*/
+DataTable.getSortingDefinitions = Util._deprecatedFunction;
+/** @public
+* @const
+* @ignore
+* @type {!Object}
+*/
+DataTable._globalChangeArg = {"globalChange": true};
+/** @public
+* @const
+* @ignore
+* @type {!Object}
+*/
+DataTable._positionChangeArg = {"globalChange": true, "positionChangeOnly": true};
+
+
+/**
+* @function
+* @public
+* @ignore
+* @param {!Array.<Array>} out_defs Output object. Array is used to optimize property accessing time.
+* @param {string|Array.<string>} cids
+* @param {string|number|Array.<string|number>=} sortOrders
+* @param {Function|Array.<Function>|Object.<string, DataTable.SortLogic>=} logics
+* @param {*=} contextObj Context object that will be provided as the forth parameter of the given comparer method
+* @return {!Array.<Array>}
+*/
+DataTable._buildSortContext = function(out_defs, cids, sortOrders, logics, contextObj) {
+	let aryColumnIds, aryOrders;
+	if(Array.isArray(cids)) {
+		aryColumnIds = /** @type{Array.<string>} */(cids);
+		aryOrders = /** @type{Array.<string|number>} */(sortOrders);
+	} else {
+		aryColumnIds = [/** @type{string} */(cids)];
+		aryOrders = (cids) ? [/** @type{string|number} */(sortOrders)] : [0];
+	}
+
+	let logic = null;
+	let logicMap = null;
+	if(typeof logics == "function") {
+		logic = logics;
+	} else {
+		logicMap = /** @type{Array.<Function>|Object.<string, DataTable.SortLogic>} */(logics);
+	}
+	let len = aryColumnIds.length;
+	out_defs.length = len;
+	for(let c = len; --c >= 0;) {
+		if (Array.isArray(logicMap)) {
+			logic = logicMap[c];
+		}
+		let sortingDef = out_defs[c];
+		if(!sortingDef) {
+			sortingDef = out_defs[c] = new Array(5);
+		}
+		let columnId = aryColumnIds[c];
+		sortingDef[0] = columnId; // text field
+		sortingDef[1] = null; // Reserved for row data
+		sortingDef[2] = logic || logicMap[columnId] || logicMap["_default"]; // sort logic
+		if(!sortingDef[2]) {
+			sortingDef[2] = DataTable._defaultComparer;
+		}
+		sortingDef[3] = DataTable._getSortOrder(aryOrders[c]); // sort order
+		sortingDef[4] = contextObj;
+	}
+	return out_defs;
+};
+/** Performance is extremely vital in this method
+* @public
+* @ignore
+* @function
+* @param {number} a
+* @param {number} b
+* @param {number} order Not used by in this method
+* @param {Array.<Array>} sortingDefs
+* @return {number}
+*/
+DataTable._multiColumnCompareLogic = function(a, b, order, sortingDefs) {
+	let count = sortingDefs.length;
+	let result = 0;
+	for(let c = 0; c < count; ++c) {
+		let sortingDef = sortingDefs[c];
+		result = DataTable._singleColumnCompareLogic(a, b, sortingDef[3], sortingDef);
+		if(result) {
+			return result;
+		}
+	}
+	return result;
+};
+/** Performance is extremely vital in this method
+* @public
+* @ignore
+* @function
+* @param {number} a
+* @param {number} b
+* @param {number} order
+* @param {Array} sortingDef
+* @return {number}
+*/
+DataTable._singleColumnCompareLogic = function(a, b, order, sortingDef) {
+	let values = /** @type{Array} */(sortingDef[1]);
+	return /** @type{number} */(sortingDef[2](
+		values[a], // Value1
+		values[b], // Value2
+		order, // Sort order (3)
+		sortingDef[4] // Context object
+	));
+};
+/** Performance is extremely vital in this method
+* @public
+* @ignore
+* @function
+* @param {*} a
+* @param {*} b
+* @param {number} order Not used by in this method
+* @param {Array.<Array>} sortingDefs
+* @return {number}
+*/
+DataTable._multiColumnSeparatorCompareLogic = function(a, b, order, sortingDefs) {
+	let count = sortingDefs.length;
+	let result = 0;
+	for(let c = 0; c < count; ++c) {
+		let sortingDef = sortingDefs[c];
+		result = DataTable._singleColumnSeparatorCompareLogic(a, b, sortingDef[3], sortingDef);
+		if(result) {
+			return result;
+		}
+	}
+	return result;
+};
+/** Performance is extremely vital in this method
+* @public
+* @ignore
+* @function
+* @param {*} a
+* @param {*} b
+* @param {number} order
+* @param {Array} sortingDef
+* @return {number}
+*/
+DataTable._singleColumnSeparatorCompareLogic = function(a, b, order, sortingDef) {
+	let key = /** @type{string} */(sortingDef[0]);
+	return /** @type{number} */(sortingDef[2](
+		a[key], // Value1
+		b[key], // Value2
+		order, // Sort order (3)
+		sortingDef[4] // Context object
+	));
+};
+/** @public
+* @function
+* @ignore
+* @param {!Array.<Object>} dataRows
+* @param {Array.<Array>} sortingDefs
+* @param {Array.<number>=} segmentValues
+* @return {Array.<number>} Returns new item positions if there is any change, otherwise returns null
+*/
+DataTable._performMultiLevelSorting = function(dataRows, sortingDefs, segmentValues) {
+	let rowCount = dataRows ? dataRows.length : 0;
+	let defCount = sortingDefs ? sortingDefs.length : 0;
+	if(!rowCount) {
+		return null;
+	}
+
+	let sortLogic;
+	// Populate data for each definition
+	for(let c = 0; c < defCount; ++c) {
+		let sortingDef = sortingDefs[c];
+		let rows = sortingDef[1];
+		sortLogic = sortingDef[2];
+		let rowSorting = sortLogic["rowSorting"];
+		let r;
+		if(rowSorting) {
+			if(rows) {
+				rows.length = rowCount;
+				for(r = 0; r < rowCount; ++r) {
+					rows[r] = dataRows[r];
+				}
+			} else {
+				rows = sortingDef[1] = dataRows;
+			}
+		}	else {
+			if(rows) {
+				rows.length = rowCount;
+			} else {
+				rows = sortingDef[1] = new Array(rowCount);
+			}
+			let columnId = sortingDef[0];
+			for(r = 0; r < rowCount; ++r) {
+				rows[r] = dataRows[r][columnId];
+			}
+		}
+	}
+
+	if(segmentValues) {
+		let segmentDef = [ // TODO: Make this static variable
+			"ROW_SEGMENT", // Dummy column id
+			segmentValues, // Segment values
+			DataTable._segmentComparer,
+			1, // Ascending order
+			null // Context object
+		];
+		if(sortingDefs) {
+			sortingDefs = sortingDefs.slice();
+			sortingDefs.unshift(segmentDef);
+		} else {
+			sortingDefs = [segmentDef];
+		}
+		++defCount;
+	}
+
+	if(!defCount) {
+		return null;
+	}
+
+	let sortOrder = 0;
+	let sortContext;
+	if(defCount > 1) {
+		sortLogic = DataTable._multiColumnCompareLogic;
+		sortContext = sortingDefs;
+		sortOrder = 1; // sortOrder is not used by _multiColumnCompareLogic
+	} else { // Single level sorting
+		sortLogic = DataTable._singleColumnCompareLogic;
+		sortContext = sortingDefs[0];
+		sortOrder = /** @type{number} */(sortContext[3]);
+	}
+
+	return DataTable._mergeSort(rowCount, sortOrder, sortLogic, sortContext);
+};
+/**
+* @function
+* @public
+* @ignore
+* @param {number} len Length of array item
+* @param {number} order
+* @param {DataTable.SortLogic} comparer
+* @param {*=} contextObj Context object that will be provided as the forth parameter of the given comparer method
+* @return {Array.<number>} Returns new item positions if there is any change, otherwise returns null
+*/
+DataTable._mergeSort = function(len, order, comparer, contextObj) {
+	let change = false;
+
+	let grpSize = 1;
+	let iter, lhsFrom, rhsFrom, lhsTo, rhsTo;
+	let subj = DataTable._createIndexArray(len);
+	let obj = subj.slice();
+
+	while(grpSize <= len) {
+		iter = rhsTo = 0; // start from 0
+		while(iter < len) {
+			lhsFrom = rhsTo;
+			lhsTo = lhsFrom + grpSize;
+			rhsFrom = lhsTo;
+			rhsTo = rhsFrom + grpSize;
+			if(rhsTo > len) rhsTo = len;
+
+			if(rhsFrom < rhsTo) {
+				while(true) { // Merge two groups together
+					if(comparer(subj[lhsFrom], subj[rhsFrom], order, contextObj) <= 0) {
+						obj[iter++] = subj[lhsFrom];
+						if(++lhsFrom >= lhsTo) {
+							while(rhsFrom < rhsTo) {
+								obj[iter++] = subj[rhsFrom];
+								++rhsFrom;
+							}
+							break;
+						}
+					} else {
+						change = true;
+						obj[iter++] = subj[rhsFrom];
+						if(++rhsFrom >= rhsTo) {
+							while(lhsFrom < lhsTo) {
+								obj[iter++] = subj[lhsFrom];
+								++lhsFrom;
+							}
+							break;
+						}
+					}
+				}
+			} else {
+				while(iter < len) {
+					obj[iter] = subj[iter];
+					++iter;
+				}
+			}
+		}
+
+		let tmp = subj;
+		subj = obj;
+		obj = tmp;
+		grpSize <<= 1;
+	}
+	return change ? subj : null;
+};
+/** reorderItems(["a", "b", "c", "d"], [1, 3, 0, 2]) === ["b", "d", "a", "c"]; (Move the first item to where its corresponding index is) <br>
+* Not in-place reordering. Orders array will become the results
+* @function
+* @public
+* @ignore
+* @param {!Array} ary
+* @param {Array} orders
+* @return {!Array}
+*/
+DataTable._reorderItems = function (ary, orders) {
+	if(orders) {
+		for(let i = ary.length; --i >= 0;) {
+			orders[i] = ary[orders[i]];
+		}
+		return orders;
+	}
+	return ary;
+};
+/** Create array of incremental series starting from 0 (e.g. [0, 1, 2, 3, ...])
+* @private
+* @function
+* @ignore
+* @param {number} len Length of the generated array
+* @return {!Array.<number>}
+*/
+DataTable._createIndexArray = function(len) {
+	let ary = DataTable._idxAryMap[len];
+	if(!ary) {
+		if(DataTable._idxAryCount > 50) { // Clear cache to avoid caching huge memory
+			DataTable._idxAryMap = {};
+			DataTable._idxAryCount = 0;
+		}
+		ary = DataTable._idxAryMap[len] = new Array(len);
+		DataTable._idxAryCount++;
+
+		for(let i = 0; i < len; ++i) {
+			ary[i] = i;
+		}
+	}
+	return ary.slice(); // Fastest way to clone an array is to perform slice() method
+};
+/** Remove _idxAryMap and _idAryCount
+* @private
+*/
+DataTable._removeIndexArray = function() {
+	DataTable._idxAryMap = {};
+	DataTable._idxAryCount = 0;
+};
+/** @private
+* @type {Object.<number, Array.<number>>}
+*/
+DataTable._idxAryMap = {};
+/** @private
+* @type {number}
+*/
+DataTable._idxAryCount = 0;
+
+/** @private
+* @function
+* @param {number} a
+* @param {number} b
+* @return {number}
+*/
+DataTable._segmentComparer = function(a, b) {
+	if(a === b) {
+		return 0;
+	}
+	return (a < b) ? -1 : 1;
+};
+/** @private
+* @function
+* @param {*} a
+* @param {*} b
+* @param {number} order
+* @return {number}
+*/
+DataTable._defaultComparer = function(a, b, order) { // User data may contain invalid value such as undefined or null
+	if(a == null || a !== a) {
+		if(b == null || b !== b) {
+			return 0;
+		}
+		return 1;
+	}
+	if(b == null || b !== b) {
+		return -1;
+	}
+
+	if(a < b) {
+		return -order;
+	}
+	if(b < a) {
+		return order;
+	}
+	return 0;
+};
+/** @private
+* @function
+* @param {string|number=} sortOrder
+* @returns {number}
+*/
+DataTable._getSortOrder = function(sortOrder) {
+	if(typeof sortOrder === "number") {
+		return sortOrder;
+	} else if(sortOrder && typeof sortOrder === "string") {
+		sortOrder = sortOrder.charAt(0).toLowerCase();
+		if(sortOrder === "a") {
+			return 1;
+		} else if(sortOrder === "d") {
+			return -1;
+		}
+	}
+	return 0;
+};
+
+DataTable._proto = DataTable.prototype;
+
+export default DataTable;
+export { DataTable };