@refinitiv-ui/efx-grid 6.0.13 → 6.0.15

package/lib/core/dist/core.js

@@ -11788,7 +11788,7 @@ DataCache_DataCache.prototype._cloneRowData = function (obj, ric, newSubId) {
 
 /** @protected
  * @ignore
- * @type {!Object.<string, Object.<string, *>>}
+ * @type {!Object.<string, Object>}
  */
 DataCache_DataCache.prototype._rows;
 
@@ -11873,15 +11873,221 @@ DataCache_DataCache._proto = DataCache_DataCache.prototype;
 /* harmony default export */ const data_DataCache = (DataCache_DataCache);
 
 
+;// CONCATENATED MODULE: ./node_modules/tr-grid-util/es6/EventDispatcher.js
+/** Abstract base class that provides event management methods for derived class
+* @constructor
+*/
+var EventDispatcher_EventDispatcher = function () {};
+
+/** @type {Object.<string, Function>}
+* @protected
+* @ignore
+*/
+EventDispatcher_EventDispatcher.prototype._events = null;
+/** @type {number}
+* @protected
+* @ignore
+*/
+EventDispatcher_EventDispatcher.prototype._listenerCount = 0;
+
+//#region public function of event
+/** Add the function handler into the specific event.
+* @public
+* @param {string} type Event name
+* @param {Function} handler Event handler
+*/
+EventDispatcher_EventDispatcher.prototype.addEventListener = function(type, handler) {
+	if(!type || !handler) { return; }
+	if(!this._events) {
+		this._events = {};
+	}
+
+	var listeners = this._events[type];
+	if(listeners) {
+		if(listeners.indexOf(handler) < 0) {
+			listeners.push(handler);
+			++this._listenerCount;
+		}
+	} else {
+		this._events[type] = [handler];
+		++this._listenerCount;
+	}
+};
+/** Remove the function handler from the specific event.
+* @public
+* @param {string} type Event name
+* @param {Function} handler Event handler
+*/
+EventDispatcher_EventDispatcher.prototype.removeEventListener = function(type, handler) {
+	var listeners = (this._events) ? this._events[type] : null;
+	if(listeners) {
+		var at = listeners.indexOf(handler);
+		if(at >= 0) {
+			listeners.splice(at, 1);
+			--this._listenerCount;
+		}
+	}
+};
+/** Remove all function handlers from all events.
+* @public
+*/
+EventDispatcher_EventDispatcher.prototype.removeAllEventListeners = function() {
+	this._events = null;
+	this._listenerCount = 0;
+};
+
+/** Check whether the specified event has a function handler.
+* @public
+* @param {string} type Event name
+* @return {boolean}
+*/
+EventDispatcher_EventDispatcher.prototype.hasListener = function(type) {
+	if(this._listenerCount) {
+		if(type) {
+			var listeners = this._events ? this._events[type] : null;
+			return listeners ? (listeners.length > 0) : false;
+		} else {
+			return true;
+		}
+	} else {
+		return false;
+	}
+};
+/** Get event listener (function handler) from the specified event.
+* @public
+* @param {string} type Event name
+* @param {number=} idx=0 Index of the listener to be retrieved. This is used when there are multiple event listeners
+* @return {Function}
+*/
+EventDispatcher_EventDispatcher.prototype.getListener = function(type, idx) {
+	if(type) {
+		var listeners = this._events ? this._events[type] : null;
+		if(listeners) {
+			if(!idx) {
+				idx = 0;
+			}
+			return listeners[idx] || null;
+		}
+	}
+	return null;
+};
+/** A shorthand to retrieve function from an object and add it as an Eventlistener
+* @public
+* @function
+* @param {Object} obj Object that contains a handler with the same name as the given `type`
+* @param {string} type Event name
+* @example
+* var obj = {"mouseUp": function(e) { console.log(e); }};
+* plugin.addListener(obj, "mouseUp");
+* plugin.addListener(obj, "mouseDown");
+*/
+EventDispatcher_EventDispatcher.prototype.addListener = function(obj, type) {
+	var func = obj ? obj[type] : null;
+	if(typeof func === "function") {
+		this.addEventListener(type, func);
+	}
+};
+
+/** Executed before dispatching, allowing modification of user's event argument object
+* @protected
+* @ignore
+* @param {string} type Event name
+* @param {Object} eventArg User's event argument object
+* @return {Object} New event argument object
+*/
+EventDispatcher_EventDispatcher.prototype._prepareEventArguments = function(type, eventArg) {
+	return eventArg;
+};
+
+/** Publish the data to the listener.
+* @protected
+* @ignore
+* @param {string} type Event name
+* @param {Object} eventArg Event arguments
+*/
+EventDispatcher_EventDispatcher.prototype._dispatch = function(type, eventArg) {
+	var listeners = this._events ? this._events[type] : null;
+	if(listeners) {
+		eventArg = this._prepareEventArguments(type, eventArg);
+		var len = listeners.length;
+		for(var i = 0; i < len; ++i) {
+			listeners[i](eventArg);
+		}
+	}
+};
+
+/** @public
+* @function
+* @param {Event} e
+*/
+var preventDefault = function(e) {
+	if(e && e.preventDefault) {
+		e.preventDefault();
+		e.stopPropagation();
+	}
+};
+
+/** @public
+* @function
+* @param {Event} e
+*/
+EventDispatcher_EventDispatcher.preventDefault = preventDefault;
+
+/* harmony default export */ const es6_EventDispatcher = (EventDispatcher_EventDispatcher);
+
+
 ;// CONCATENATED MODULE: ./src/js/data/Segment.js
+
+
+
 /** @constructor
+* @extends {EventDispatcher}
 * @param {string} rid
+* @param {!Object} sharedObj
 */
-var Segment = function(rid) {
+var Segment = function(rid, sharedObj) {
 	this._rid = rid;
 	this._children = {};
+	this._shared = sharedObj;
 };
+es6_Ext.inherits(Segment, es6_EventDispatcher);
 
+/** @private
+* @function
+* @param {string} a
+* @param {string} b
+* @return {number}
+*/
+Segment._subSegSortLogic = function(a, b) {
+	if(a === "Uncategorized") {
+		return 1;
+	}
+	if(b === "Uncategorized") {
+		return -1;
+	}
+
+	if(a < b) {
+		return -1;
+	}
+	if(b < a) {
+		return 1;
+	}
+
+	return 0;
+};
+/** @private
+* @function
+* @param {Segment} segment
+* @param {number} idx
+*/
+Segment._assignSubSegmentOrder = function(segment, idx) {
+	segment.setOrder(idx + 1);
+};
+
+/** @type {Object}
+* @private
+*/
+Segment.prototype._shared = null;
 
 /** @type {string}
 * @private
@@ -11902,13 +12108,67 @@ Segment.prototype._collapsed = false;
 /** @type {number}
 * @private
 */
-Segment.prototype._value = 0;
+Segment.prototype._order = 0;
+/** @type {boolean}
+* @private
+*/
+Segment.prototype._disposed = false;
+
+/** @type {Object}
+* @private
+*/
+Segment.prototype._subSegDef = null;
 /** @type {number}
 * @private
 */
-Segment.prototype._order = 0;
+Segment.prototype._subSegLevel = 0;
+/** @type {Object.<string, Segment>}
+* @private
+*/
+Segment.prototype._subSegMap = null; // For immediate sub-segment children
+/** @type {Array.<string>}
+* @private
+*/
+Segment.prototype._subSegNames = null; // For immediate sub-segment child names
+/** @type {string}
+* @private
+*/
+Segment.prototype._subSegName = "";
+/** @type {*}
+* @private
+*/
+Segment.prototype._subSegVal;
+/** @type {Segment}
+* @private
+*/
+Segment.prototype._subSegParent = null;
 
 
+/** @public
+*/
+Segment.prototype.dispose = function() {
+	if(this._disposed) {
+		return;
+	}
+	this._disposed = true;
+
+	this.removeAllEventListeners();
+	var segmentNames = this._subSegNames;
+	if(segmentNames) {
+		var segmentCount = segmentNames.length;
+		var segmentMap = this._subSegMap;
+		for(var i = 0; i < segmentCount; ++i) {
+			segmentMap[segmentNames[i]].dispose();
+		}
+		this._subSegMap = this._subSegNames = null;
+	}
+	if(this._collapsed) {
+		this._shared.dirtyCollapsingState = true;
+	}
+
+	this._shared = null;
+	this._subSegParent = this._subSegDef = this._subSegVal = null;
+};
 /** @public
 * @return {string}
 */
@@ -11916,32 +12176,66 @@ Segment.prototype.getId = function() {
 	return this._rid;
 };
 /** @public
+* @return {string}
+*/
+Segment.prototype.getParentId = function() {
+	if(this._subSegParent) {
+		return this._subSegParent.getId();
+	}
+	return "";
+};
+/** @public
+* @param {Array.<string>=} out_ary
+* @return {Array.<string>}
+*/
+Segment.prototype.getSubSegmentIds = function(out_ary) {
+	var segmentNames = this._subSegNames;
+	if(segmentNames) {
+		if(!out_ary) {
+			out_ary = [];
+		}
+		var segmentCount = segmentNames.length;
+		var segmentMap = this._subSegMap;
+		for(var i = 0; i < segmentCount; ++i) {
+			var segmentName = segmentNames[i];
+			var segment = segmentMap[segmentName];
+			out_ary.push(segment.getId());
+			segment.getSubSegmentIds(out_ary);
+		}
+
+		return out_ary;
+	}
+	return null;
+};
+/** @public
 * @param {string} rid
-* @param {Object=} objMap
+* @param {string=} dataId Row id for retrieving data
 * @return {boolean}
 */
-Segment.prototype.addChild = function(rid, objMap) {
-	if(rid && !this._children[rid]) {
-		if(objMap) {
-			objMap[rid] = this._rid;
+Segment.prototype.addChild = function(rid, dataId) {
+	if(rid) {
+		this._shared.childToSegment[rid] = this._rid;
+		if(this._collapsed) {
+			this._shared.dirtyCollapsingState = true; // TODO: Check if we need to update this only when new child is added
+		}
+		if(!this._children[rid]) {
+			this._children[rid] = dataId || rid;
+			++this._childCount;
+			return true;
 		}
-		this._children[rid] = 1;
-		++this._childCount;
-		return true;
 	}
 	return false;
 };
 /** @public
 * @param {Array.<string>} rids
-* @param {Object=} objMap
 * @return {boolean}
 */
-Segment.prototype.addChildren = function(rids, objMap) {
+Segment.prototype.addChildren = function(rids) {
 	var rowIds = Array.isArray(rids) ? rids : [rids];
 	var rowCount = rowIds.length;
 	var dirty = 0;
 	for(var i = 0; i < rowCount; ++i) {
-		dirty |= this.addChild(rowIds[i], objMap);
+		dirty |= this.addChild(rowIds[i]);
 	}
 	return dirty ? true : false;
 };
@@ -11954,26 +12248,37 @@ Segment.prototype.containsChild = function(rid) {
 };
 /** @public
 * @param {string} rid
-* @param {Object=} objMap
 * @return {boolean}
 */
-Segment.prototype.removeChild = function(rid, objMap) {
-	if(this._childCount && this._children[rid]) {
-		if(objMap) {
-			delete objMap[rid];
-		}
-		delete this._children[rid]; // Slow
-		--this._childCount;
-		return true;
+Segment.prototype.removeChild = function(rid) {
+	if(this._subSegLevel) {
+		return false; // Sub segments are not allowed to remove its children
 	}
-	return false;
+	if(!this._childCount) {
+		return false;
+	}
+	if(!this._children[rid]) {
+		return false; // The specified rid is not a child of this segment
+	}
+
+	var objMap = this._shared.childToSegment;
+	delete objMap[rid];
+	delete this._children[rid]; // Slow
+	--this._childCount;
+
+	if(this._collapsed) {
+		this._shared.dirtyCollapsingState = true;
+	}
+	return true;
 };
 /** @public
 * @param {Array.<string>} rids
-* @param {Object=} objMap
 * @return {boolean}
 */
-Segment.prototype.removeChildren = function(rids, objMap) {
+Segment.prototype.removeChildren = function(rids) {
+	if(this._subSegLevel) {
+		return false; // Sub segments are not allowed to remove its children
+	}
 	if(!this._childCount) {
 		return false;
 	}
@@ -11981,29 +12286,34 @@ Segment.prototype.removeChildren = function(rids, objMap) {
 	var rowCount = rowIds.length;
 	var dirty = 0;
 	for(var i = 0; i < rowCount; ++i) {
-		dirty |= this.removeChild(rowIds[i], objMap);
+		dirty |= this.removeChild(rowIds[i]);
 	}
 	return dirty ? true : false;
 };
 /** @public
-* @param {Object=} objMap
 * @return {boolean}
 */
-Segment.prototype.removeAllChildren = function(objMap) {
-	if(this._childCount) {
-		if(objMap) {
-			var chdr = this._children;
-			for(var rid in chdr) {
-				if(objMap[rid]) {
-					delete objMap[rid];
-				}
-			}
+Segment.prototype.removeAllChildren = function() {
+	if(this._subSegLevel) {
+		return false; // Sub segments are not allowed to remove its children
+	}
+	if(!this._childCount) {
+		return false;
+	}
+	var objMap = this._shared.childToSegment;
+	var chdr = this._children;
+	for(var rid in chdr) {
+		if(objMap[rid]) {
+			delete objMap[rid]; // TODO: Check if we need to do this
 		}
-		this._children = {};
-		this._childCount = 0;
-		return true;
 	}
-	return false;
+	this._children = {};
+	this._childCount = 0;
+
+	if(this._collapsed) {
+		this._shared.dirtyCollapsingState = true;
+	}
+	return true;
 };
 /** @public
 * @return {!Array.<string>}
@@ -12019,6 +12329,317 @@ Segment.prototype.getChildCount = function() {
 };
 
 
+/** @public
+* @return {Array.<string>} fields
+*/
+Segment.prototype.getClassification = function() {
+	if(this._subSegDef) {
+		return this._subSegDef.classifiers || null;
+	}
+	return null;
+};
+/** @public
+* @param {string|Array.<string>} fields
+* @return {boolean}
+*/
+Segment.prototype.setClassification = function(fields) {
+	if(this._subSegLevel) {
+		return false; // non-root segment cannot be classified
+	}
+	var classifiers = null;
+	if(this._subSegDef) {
+		classifiers = this._subSegDef.classifiers;
+	}
+
+	var newClassifiers = null;
+	if(fields) {
+		if(typeof fields === "string") {
+			newClassifiers = [fields];
+		} else if(Array.isArray(fields)) {
+			newClassifiers = fields;
+		}
+	}
+	var i;
+	var fieldCount = newClassifiers ? newClassifiers.length : 0;
+
+	if(fieldCount) {
+		var curCount = classifiers ? classifiers.length : 0;
+		if(curCount === fieldCount) { // Check duplication
+			for(i = 0; i < fieldCount; ++i) {
+				if(newClassifiers[i] !== classifiers[i]) {
+					break;
+				}
+			}
+			if(i >= fieldCount) {
+				return false; // nothing has change
+			}
+		}
+
+		if(!this._subSegDef) {
+			this._subSegDef = {
+				root: this,
+				subSegments: null
+			};
+		}
+
+		this._subSegDef.classifiers = newClassifiers;
+		// this._subSegDef.classifierChanged = true;
+		return true;
+	} else if(classifiers) { // Remove existing ones
+		this._subSegDef.classifiers = null;
+		this._subSegDef.subSegments = null;
+		// this._subSegDef.classifierChanged = true;
+		this._subSegDef = null; // WARNING: All sub segments remain existing
+		return true;
+	}
+	return false;
+};
+/** @public
+* @param {Object.<string, Object>=} rows Object maps between row id and its record
+* @return {boolean}
+*/
+Segment.prototype.classify = function(rows) {
+	var classifiers = this._subSegDef ? this._subSegDef.classifiers : null;
+	var classifierCount = classifiers ? classifiers.length : 0;
+
+	var segmentNames = this._subSegNames;
+	var segmentCount = segmentNames ? segmentNames.length : 0;
+
+	if(!segmentCount) {
+		if(this._subSegLevel >= classifierCount) {
+			return false; // Current segment level is beyond existing classification level and this segment should already be removed
+		}
+	}
+
+	var sharedObj = this._shared;
+	if(this._collapsed) {
+		sharedObj.dirtyCollapsingState = true;
+	}
+
+	// Prepare existing sub segments for checking change in its members
+	var i;
+	var segmentName = "";
+	var nonExistenceGroups = {};
+	var removalCount = 0;
+	var segmentMap = this._subSegMap;
+	var segment = null;
+	if(segmentCount) {
+		removalCount = segmentCount;
+		for(i = 0; i < removalCount; ++i) {
+			segmentName = segmentNames[i];
+			nonExistenceGroups[segmentName] = 1;
+
+			segment = segmentMap[segmentName];
+			if(segment._childCount) { // Quick cleaning up
+				segment._children = {};
+				segment._childCount = 0;
+			}
+			if(segment._collapsed) {
+				sharedObj.dirtyCollapsingState = true;
+			}
+		}
+	}
+
+	// Loop through row children and assign them to their corresponding sub segment
+	var isRootSegment = !this._subSegLevel;
+	var rid;
+	var children = this._children;
+	if(this._subSegLevel < classifierCount && rows) {
+		if(!segmentMap) {
+			segmentMap = this._subSegMap = {};
+			segmentNames = this._subSegNames = [];
+		}
+
+		var classifier = classifiers[this._subSegLevel];
+
+		for(rid in children) {
+			var dataId = children[rid];
+			var record = rows[dataId];
+			var val = record ? record[classifier] : null; // WARNING: row could already be removed
+
+			sharedObj.childToSegment[rid] = this._rid; // Relocate child in case of it has been moved to a non existence group
+
+			segmentName = "Uncategorized";
+			if(val || val === 0 || val === false) { // Check for null, undefined, "", and NaN value
+				segmentName = val + "";
+			}
+			if(nonExistenceGroups[segmentName]) {
+				nonExistenceGroups[segmentName] = 0;
+				--removalCount;
+			}
+
+			segment = segmentMap[segmentName];
+			if(!segment) { // New group is detected
+				segment = new Segment(this._rid + "/" + segmentName, sharedObj);
+				segment._subSegDef = this._subSegDef;
+				segment._subSegLevel = this._subSegLevel + 1;
+				segment._subSegName = segmentName;
+				segment._subSegVal = val;
+				segment._subSegParent = this;
+
+				segmentMap[segmentName] = segment;
+				segmentNames.push(segmentName);
+
+				this._dispatch("subSegmentAdded", {
+					"rid": segment.getId(),
+					"segment": segment
+				});
+			}
+
+			segment.addChild(rid, dataId);
+		}
+	} else if(isRootSegment) { // In case of no classification
+		for(rid in children) {
+			sharedObj.childToSegment[rid] = this._rid; // Relocate child in case of it has been moved to a non existence group
+		}
+	}
+
+	// Remove all sub segments with no members
+	if(removalCount > 0) {
+		if(removalCount >= segmentNames.length) {
+			segmentNames.length = 0;
+		}
+		for(segmentName in nonExistenceGroups) {
+			if(nonExistenceGroups[segmentName]) {
+				segment = segmentMap[segmentName];
+				delete segmentMap[segmentName];
+				// TODO: Slow
+				var at = segmentNames.indexOf(segmentName);
+				if(at >= 0) {
+					segmentNames.splice(at, 1);
+				}
+
+				this._dispatch("subSegmentRemoved", {
+					"rid": segment.getId(),
+					"segment": segment
+				});
+
+				// segment.dispose(); Already done by segment collection
+			}
+		}
+		if(!segmentNames.length) {
+			segmentNames = this._subSegMap = this._subSegNames = null;
+		}
+	}
+
+	// Sort and classify existing sub segments
+	segmentCount = segmentNames ? segmentNames.length : 0;
+	if(segmentCount) {
+		segmentNames.sort(Segment._subSegSortLogic);
+		for(i = 0; i < segmentCount; ++i) {
+			segment = segmentMap[segmentNames[i]];
+			segment.classify(rows);
+		}
+	}
+
+	// Collecting all sub segments including all descendants and reassigning segment order.
+	if(isRootSegment) { // If this is a root segment
+		if(this._subSegDef) {
+			if(segmentCount) {
+				var subSegments = this._subSegDef.subSegments = [];
+				this.getAllSubSegments(subSegments);
+				subSegments.forEach(Segment._assignSubSegmentOrder);
+			} else {
+				this._subSegDef.subSegments = null;
+			}
+			// this._subSegDef.classifierChanged = false;
+		}
+	}
+	return true;
+};
+/** @public
+* @return {boolean}
+*/
+Segment.prototype.hasSubSegments = function() {
+	if(this._subSegNames) {
+		return this._subSegNames.length ? true : false;
+	}
+	return false;
+};
+/** @public
+* @return {boolean}
+*/
+Segment.prototype.isSubSegment = function() {
+	return this._subSegLevel ? true : false;
+};
+/** @public
+* @return {Segment}
+*/
+Segment.prototype.getFirstAncestor = function() {
+	if(this._subSegLevel && this._subSegDef) {
+		var ancestor = this._subSegDef.root;
+		return /** @type{Segment} */(ancestor) || null;
+	}
+	return null;
+};
+/** @public
+* @param {Array.<Segment>=} out_ary
+* @return {Array.<Segment>}
+*/
+Segment.prototype.getAllSubSegments = function(out_ary) {
+	var segmentNames = this._subSegNames;
+	if(segmentNames) {
+		if(!out_ary) {
+			out_ary = [];
+		}
+		var segmentMap = this._subSegMap;
+		var segmentCount = segmentNames.length;
+		for(var i = 0; i < segmentCount; ++i) {
+			var segment = segmentMap[segmentNames[i]];
+			out_ary.push(segment);
+			segment.getAllSubSegments(out_ary);
+		}
+	}
+	return out_ary || null;
+};
+/** @public
+* @return {number}
+*/
+Segment.prototype.getSegmentLevel = function() {
+	return this._subSegLevel;
+};
+/** This method will be called on sub segments only
+* @public
+* @param {Object=} rows
+* @param {Object=} clsSource
+*/
+Segment.prototype.setRowData = function(rows, clsSource) {
+	if(!rows) {
+		return;
+	}
+	var row = rows[this._rid];
+	if(!row) {
+		row = rows[this._rid] = {};
+	}
+
+	if(!clsSource) {
+		clsSource = rows;
+	}
+	row = clsSource[this._rid];
+	if(!row) {
+		row = clsSource[this._rid] = {};
+	}
+
+	var segment = this;
+	while(segment && segment.isSubSegment()) {
+		segment.getSubSegmentName(row);
+		segment = segment._subSegParent;
+	}
+};
+/** @public
+* @param {Object=} row
+* @return {string}
+*/
+Segment.prototype.getSubSegmentName = function(row) {
+	if(row && this._subSegLevel) {
+		var classifiers = this.getClassification();
+		var field = classifiers[this._subSegLevel - 1];
+		if(field) {
+			row[field] = this._subSegName;
+		}
+	}
+	return this._subSegName;
+};
 
 /** @public
 * @param {boolean=} bool
@@ -12028,6 +12649,7 @@ Segment.prototype.collapse = function(bool) {
 	bool = (bool !== false);
 	if(this._collapsed !== bool) {
 		this._collapsed = bool;
+		this._shared.dirtyCollapsingState = true;
 		return true;
 	}
 	return false;
@@ -12047,44 +12669,109 @@ Segment.prototype.isCollapsed = function() {
 };
 /** @public
 * @param {Object=} objMap
-* @return {!Object}
+* @param {boolean=} parentState=false Collapsing state from parent segment
+* @return {boolean}
 */
-Segment.prototype.getCollapsingStates = function(objMap) {
+Segment.prototype.getCollapsingStates = function(objMap, parentState) {
+	var segmentNames = this._subSegNames;
+	if(!this._subSegLevel) { // Only root segment
+		if(!segmentNames) { // No sub segment
+			if(!this._collapsed) {
+				return false;
+			}
+		}
+	}
+
 	if(!objMap) {
 		objMap = {};
 	}
+	var dirty = false;
+	if(this._subSegLevel) { // Sub segments are also subjected to collapsing
+		if(parentState) {
+			objMap[this._rid] = true;
+			dirty = true;
+		}
+	}
 	if(this._childCount) {
-		var chdr = this._children;
-		var collapsed = this._collapsed;
-		for(var rid in chdr) {
-			objMap[rid] = collapsed;
+		var collapsed = parentState || this._collapsed;
+		if(segmentNames) {
+			var segmentMap = this._subSegMap;
+			var segmentCount = segmentNames.length;
+			for(var i = 0; i < segmentCount; ++i) {
+				var segment = segmentMap[segmentNames[i]];
+				objMap[segment.getId()] = !!parentState;
+				if(segment.getCollapsingStates(objMap, collapsed)) {
+					dirty = true;
+				}
+			}
+		} else if(collapsed) {
+			var chdr = this._children;
+			for(var rid in chdr) {
+				objMap[rid] = collapsed;
+			}
+			dirty = true;
 		}
 	}
-	return objMap;
+	return dirty;
 };
+
 /** @public
 * @return {number}
 */
-Segment.prototype.getValue = function() {
-	return this._value;
+Segment.prototype.getOrder = function() {
+	if(this._subSegLevel) {
+		var ancestor = this.getFirstAncestor();
+		if(ancestor) {
+			// WARNING: this._order cannot be greater than 9999
+			return ancestor.getOrder() + this._order;
+		}
+	}
+	return this._order * 10000;
 };
 /** @public
 * @param {number} val
 */
-Segment.prototype.setValue = function(val) {
-	this._value = val;
+Segment.prototype.setOrder = function(val) {
+	this._order = val;
 };
-/** @public
-* @return {number}
+
+/** @private
+* @type {Array.<string>}
 */
-Segment.prototype.getOrder = function() {
-	return this._order;
-};
+Segment._tabs = null;
 /** @public
-* @param {number} val
+* @param {Array.<string>} lines
+* @return {Array.<string>} lines
 */
-Segment.prototype.setOrder = function(val) {
-	this._order = val;
+Segment.prototype.log = function(lines) {
+	var i;
+	var tabs = Segment._tabs;
+	if(!tabs) {
+		tabs = Segment._tabs = [];
+		var tabCh = "";
+		for(i = 0; i < 11; ++i) {
+			tabs[i] = tabCh;
+			tabCh += "  ";
+		}
+	}
+	var collapsedCh = this._collapsed ? "+ " : "- ";
+	lines.push(tabs[this._subSegLevel] + collapsedCh + this._rid);
+
+	var segmentNames = this._subSegNames;
+	if(segmentNames) {
+		var segmentCount = segmentNames.length;
+		var segmentMap = this._subSegMap;
+		for(i = 0; i < segmentCount; ++i) {
+			segmentMap[segmentNames[i]].log(lines);
+		}
+	} else if(this._childCount) {
+		var indent = tabs[this._subSegLevel + 1];
+		for(var rid in this._children) {
+			lines.push(indent + "- " + rid);
+		}
+	}
+
+	return lines;
 };
 
 
@@ -12094,18 +12781,31 @@ Segment.prototype.setOrder = function(val) {
 ;// CONCATENATED MODULE: ./src/js/data/SegmentCollection.js
 
 
+
+
 /** @constructor
+* @extends {EventDispatcher}
 */
 var SegmentCollection = function() {
+	this._onSubSegmentAdded = this._onSubSegmentAdded.bind(this);
+	this._onSubSegmentRemoved = this._onSubSegmentRemoved.bind(this);
+
 	this._segments = {};
-	this._childToSegmentId = {};
+	this._insertionList = [];
+	this._removalList = [];
+
+	this._shared = {
+		childToSegment: {}, // child Id to segment Id
+		dirtyCollapsingState: false
+	};
 };
+es6_Ext.inherits(SegmentCollection, es6_EventDispatcher);
 
 
 /** @type {!Object.<string, Segment>}
 * @private
 */
-SegmentCollection.prototype._segments;
+SegmentCollection.prototype._segments; // Contains both segment and their sub segments
 /** @type {number}
 * @private
 */
@@ -12114,28 +12814,54 @@ SegmentCollection.prototype._segmentCount = 0;
 * @private
 */
 SegmentCollection.prototype._collapsedRids = null;
+/** @type {!Object}
+* @private
+*/
+SegmentCollection.prototype._shared;
+/** @type {Array.<Segment>}
+* @private
+*/
+SegmentCollection.prototype._segmentList = null; // Array of main segments
+/** @type {Array.<Segment>}
+* @private
+*/
+SegmentCollection.prototype._insertionList = null; // Array of sub segments
+/** @type {Array.<string>}
+* @private
+*/
+SegmentCollection.prototype._removalList = null; // Array of sub segment ids
 /** @type {boolean}
 * @private
 */
-SegmentCollection.prototype._dirtyCollapsingState = false;
-/** @type {!Object.<string, string>}
+SegmentCollection.prototype._classification = false;
+/** @type {boolean}
 * @private
 */
-SegmentCollection.prototype._childToSegmentId;
-
+SegmentCollection.prototype._classifierChanged = false;
 
+/** @public
+*/
+SegmentCollection.prototype.dispose = function() {
+	this.removeAllSegments();
+	this.removeAllEventListeners();
+	this._collapsedRids = null;
+	this._segmentList = this._insertionList = this._removalList = null;
+};
 /** @public
 * @param {string} rid
 * @return {boolean} Returns true if there is any change. Otherwise, returns false
 */
 SegmentCollection.prototype.addSegment = function(rid) {
 	if(rid && !this._segments[rid]) {
-		if(this._childToSegmentId[rid]) {
+		if(this.getParentRowId(rid)) {
 			console.log("child of a segment cannot be set as a segment separator");
 			return false;
 		}
-		this._segments[rid] = new data_Segment(rid);
+		var segment = this._segments[rid] = new data_Segment(rid, this._shared);
+		segment.addEventListener("subSegmentAdded", this._onSubSegmentAdded);
+		segment.addEventListener("subSegmentRemoved", this._onSubSegmentRemoved);
 		++this._segmentCount;
+		this._segmentList = null; // order could be changed
 		return true;
 	}
 	return false;
@@ -12165,7 +12891,7 @@ SegmentCollection.prototype.containsSegment = function(rid) {
 * @return {string} parent row id of this segmentation. If the parent row id for this segmentation cannot be found, return ""
 */
 SegmentCollection.prototype.getParentRowId = function(rid) {
-	return this._childToSegmentId[rid] || "";
+	return this._shared.childToSegment[rid] || "";
 };
 /** @public
 * @param {string} rid
@@ -12174,10 +12900,27 @@ SegmentCollection.prototype.getParentRowId = function(rid) {
 SegmentCollection.prototype.removeSegment = function(rid) {
 	var segment = this._segments[rid];
 	if(segment) {
-		if(segment.isCollapsed()) {
-			this._dirtyCollapsingState = true;
+		if(this._segmentCount <= 1) {
+			return this.removeAllSegments();
+		}
+		if(segment.isSubSegment()) {
+			this._removalList.push(segment.getId());
+		}
+		var subSegIds = segment.getSubSegmentIds();
+		if(subSegIds) {
+			var len = subSegIds.length;
+			for(var i = 0; i < len; ++i) {
+				var subSegId = subSegIds[i];
+				if(this._segments[subSegId]) {
+					this._removalList.push(subSegId);
+					delete this._segments[subSegId]; // Slow
+					--this._segmentCount;
+				}
+			}
 		}
-		segment.removeAllChildren(this._childToSegmentId);
+		segment.removeAllChildren(); // This is important for updating childToSegment
+		segment.dispose();
+
 		delete this._segments[rid]; // Slow
 		--this._segmentCount;
 		return true;
@@ -12189,10 +12932,15 @@ SegmentCollection.prototype.removeSegment = function(rid) {
 */
 SegmentCollection.prototype.removeAllSegments = function() {
 	if(this._segmentCount) {
+		for(var key in this._segments) {
+			this._segments[key].dispose();
+		}
 		this._segments = {};
-		this._childToSegmentId = {};
 		this._segmentCount = 0;
-		this._dirtyCollapsingState = true;
+		this._segmentList = null;
+		this._shared.childToSegment = {};
+
+		this._classification = this._classifierChanged = false;
 		return true;
 	}
 	return false;
@@ -12233,11 +12981,7 @@ SegmentCollection.prototype.getSegmentIds = function() {
 SegmentCollection.prototype.collapseSegment = function(segmentId, bool) {
 	var segment = this._segments[segmentId];
 	if(segment) {
-		var dirty = segment.collapse(bool);
-		if(dirty) {
-			this._dirtyCollapsingState = true;
-			return true;
-		}
+		return segment.collapse(bool);
 	}
 	return false;
 };
@@ -12260,7 +13004,6 @@ SegmentCollection.prototype.expandAllSegments = function() {
 			dirty |= segmentSeparators[rid].expand();
 		}
 		if(dirty) {
-			this._dirtyCollapsingState = true;
 			return true;
 		}
 	}
@@ -12281,17 +13024,19 @@ SegmentCollection.prototype.isCollapsedSegment = function(segmentId) {
 * @return {Object}
 */
 SegmentCollection.prototype.getCollapsedRows = function() {
-	if(this._dirtyCollapsingState) {
-		this._dirtyCollapsingState = false;
+	if(this._shared.dirtyCollapsingState) {
+		this._shared.dirtyCollapsingState = false;
 		var collapsedRids = null;
 		var count = 0;
 		if(this._segmentCount) {
 			var segmentSeparators = this._segments;
 			collapsedRids = {};
 			for(var rid in segmentSeparators) {
-				if(segmentSeparators[rid].isCollapsed()) {
-					segmentSeparators[rid].getCollapsingStates(collapsedRids);
-					++count;
+				var segment = segmentSeparators[rid];
+				if(!segment.isSubSegment()) {
+					if(segment.getCollapsingStates(collapsedRids)) {
+						++count;
+					}
 				}
 			}
 		}
@@ -12303,18 +13048,13 @@ SegmentCollection.prototype.getCollapsedRows = function() {
 /** @public
 * @param {string} segmentId
 * @param {string} rid
+* @param {string=} dataId Row id for retrieving data
 * @return {boolean} Returns true if there is any change. Otherwise, returns false
 */
-SegmentCollection.prototype.addSegmentChild = function(segmentId, rid) {
+SegmentCollection.prototype.addSegmentChild = function(segmentId, rid, dataId) {
 	var segment = this._segments[segmentId];
-	if(segment) {
-		var dirty = segment.addChild(rid, this._childToSegmentId);
-		if(dirty) {
-			if(segment.isCollapsed()) {
-				this._dirtyCollapsingState = true;
-			}
-			return true;
-		}
+	if(segment && !segment.isSubSegment()) {
+		return segment.addChild(rid, dataId);
 	}
 	return false;
 };
@@ -12325,14 +13065,8 @@ SegmentCollection.prototype.addSegmentChild = function(segmentId, rid) {
 */
 SegmentCollection.prototype.addSegmentChildren = function(segmentId, rids) {
 	var segment = this._segments[segmentId];
-	if(segment) {
-		var dirty = segment.addChildren(rids, this._childToSegmentId);
-		if(dirty) {
-			if(segment.isCollapsed()) {
-				this._dirtyCollapsingState = true;
-			}
-			return true;
-		}
+	if(segment && !segment.isSubSegment()) {
+		return segment.addChildren(rids);
 	}
 	return false;
 };
@@ -12356,13 +13090,7 @@ SegmentCollection.prototype.containsSegmentChild = function(segmentId, rid) {
 SegmentCollection.prototype.removeSegmentChild = function(segmentId, rid) {
 	var segment = this._segments[segmentId];
 	if(segment) {
-		var dirty = segment.removeChild(rid, this._childToSegmentId);
-		if(dirty) {
-			if(segment.isCollapsed()) {
-				this._dirtyCollapsingState = true;
-			}
-			return true;
-		}
+		return segment.removeChild(rid);
 	}
 	return false;
 };
@@ -12374,13 +13102,7 @@ SegmentCollection.prototype.removeSegmentChild = function(segmentId, rid) {
 SegmentCollection.prototype.removeSegmentChildren = function(segmentId, rids) {
 	var segment = this._segments[segmentId];
 	if(segment) {
-		var dirty = segment.removeChildren(rids, this._childToSegmentId);
-		if(dirty) {
-			if(segment.isCollapsed()) {
-				this._dirtyCollapsingState = true;
-			}
-			return true;
-		}
+		return segment.removeChildren(rids);
 	}
 	return false;
 };
@@ -12388,20 +13110,20 @@ SegmentCollection.prototype.removeSegmentChildren = function(segmentId, rids) {
 * @return {boolean} Returns true if there is any change. Otherwise, returns false
 */
 SegmentCollection.prototype.removeAllSegmentChildren = function() {
-	this._childToSegmentId = {};
+	this._shared.childToSegment = {};
 	var segmentSeparators = this._segments;
-	var dirtyCollapsingState = this._dirtyCollapsingState;
 	var dirty = false;
 	for(var rid in segmentSeparators) {
-		var segment = this._segments[rid];
+		var segment = segmentSeparators[rid];
 		if(segment.removeAllChildren()) {
 			dirty = true;
-			if(!dirtyCollapsingState && segment.isCollapsed()) {
-				dirtyCollapsingState = this._dirtyCollapsingState = true;
-			}
 		}
 	}
 
+	if(dirty) {
+		this.classify(null);
+	}
+
 	return dirty;
 };
 
@@ -12415,22 +13137,18 @@ SegmentCollection.prototype.fillSegment = function(segmentId, rids) {
 		return;
 	}
 	var segmentSeparators = this._segments;
-	var childToSegmentId = this._childToSegmentId;
 	var curSegment = segmentSeparators[segmentId];
-	if(curSegment) {
+	if(curSegment && !curSegment.isSubSegment()) {
 		var segmentAt = rids.indexOf(segmentId);
 		if(segmentAt >= 0) {
-			if(curSegment.isCollapsed()) {
-				this._dirtyCollapsingState = true;
-			}
-			curSegment.removeAllChildren(childToSegmentId);
+			curSegment.removeAllChildren();
 			for(var r = segmentAt + 1; r < rowCount; ++r) {
 				var rid = rids[r];
 				var segmentSeparator = segmentSeparators[rid];
 				if(segmentSeparator) {
 					break;
 				}
-				curSegment.addChild(rid, childToSegmentId);
+				curSegment.addChild(rid);
 			}
 		}
 	}
@@ -12440,23 +13158,20 @@ SegmentCollection.prototype.fillSegment = function(segmentId, rids) {
 * @return {boolean} Return true if the fill segments have changed, otherwise return false
 */
 SegmentCollection.prototype.fillSegments = function(rids) {
+	this._shared.childToSegment = {};
+
 	var rowCount = Array.isArray(rids) ? rids.length : 0;
-	this._childToSegmentId = {};
 	var segmentSeparators = this._segments;
-	var childToSegmentId = this._childToSegmentId;
 	var curSegment = null;
 	var change = false;
 	for(var r = 0; r < rowCount; ++r) {
 		var rid = rids[r];
 		var segmentSeparator = segmentSeparators[rid];
-		if(segmentSeparator) {
+		if(segmentSeparator && !segmentSeparator.isSubSegment()) {
 			curSegment = segmentSeparator;
-			if(curSegment.isCollapsed()) {
-				this._dirtyCollapsingState = true;
-			}
 			curSegment.removeAllChildren();
-		} else if(curSegment) {
-			curSegment.addChild(rid, childToSegmentId);
+		} else if(curSegment && !curSegment.isSubSegment()) {
+			curSegment.addChild(rid);
 			change = true;
 		}
 	}
@@ -12466,6 +13181,13 @@ SegmentCollection.prototype.fillSegments = function(rids) {
 * @param {Array.<string>} rids
 */
 SegmentCollection.prototype.calcSegmentOrder = function(rids) {
+	var segmentList = this._segmentList;
+	if(segmentList) {
+		segmentList.length = 0;
+	} else {
+		segmentList = this._segmentList = [];
+	}
+
 	var ridCount = rids ? rids.length : 0;
 	var segmentSeparators = this._segments;
 	var segmentCount = this._segmentCount;
@@ -12474,8 +13196,11 @@ SegmentCollection.prototype.calcSegmentOrder = function(rids) {
 		var rid = rids[i];
 		var segment = segmentSeparators[rid];
 		if(segment) {
-			segment.setOrder(++order);
-			if(order >= segmentCount) {
+			if(!segment.isSubSegment()) {
+				this._segmentList.push(segment);
+				segment.setOrder(++order); // WARNING: Segments and sub segments start with 1
+			}
+			if(--segmentCount <= 0) {
 				break;
 			}
 		}
@@ -12491,7 +13216,7 @@ SegmentCollection.prototype.getSegmentValues = function(rids) {
 		return null;
 	}
 	var segmentSeparators = this._segments;
-	var childToSegmentId = this._childToSegmentId;
+	var childToSegmentId = this._shared.childToSegment;
 	var curSegment = null;
 	var prevSegment = null;
 	var segmentValues = new Array(rowCount);
@@ -12521,6 +13246,126 @@ SegmentCollection.prototype.getSegmentValues = function(rids) {
 
 	return prevSegment ? segmentValues : null;
 };
+/** @public
+* @return {string}
+*/
+SegmentCollection.prototype.logStructure = function() {
+	var segmentList = this._segmentList;
+	if(!segmentList) {
+		return "";
+	}
+	var segmentCount = segmentList.length;
+	var lines = [];
+	for(var i = 0; i < segmentCount; ++i) {
+		segmentList[i].log(lines);
+	}
+
+	return lines.join("\n");
+};
+/** @public
+* @return {string}
+*/
+SegmentCollection.prototype.logRowIdMap = function() {
+	var lines = [];
+	var childToSegmentId = this._shared.childToSegment;
+	for(var rid in childToSegmentId) {
+		var segmentId = childToSegmentId[rid];
+		lines.push(rid + " > " + segmentId);
+	}
+
+	return lines.join("\n");
+};
+
+
+/** @public
+* @param {string} segmentId
+* @param {string|Array.<string>} fields
+* @return {boolean}
+*/
+SegmentCollection.prototype.setSegmentClassification = function(segmentId, fields) {
+	var segment = this._segments[segmentId];
+	if(segment) {
+		if(segment.setClassification(fields)) {
+			if(segment.getClassification()) {
+				this._classification = true;
+			}
+			this._classifierChanged = true;
+
+			return true;
+		}
+	}
+	return false;
+};
+/** @public
+* @return {boolean}
+*/
+SegmentCollection.prototype.hasClassification = function() {
+	// WARNING: This include the time when classification is removed
+	return this._classification || this._classifierChanged;
+};
+/** @public
+* @param {Object.<string, Object>} rows Object maps between row id and its record
+* @return {boolean}
+*/
+SegmentCollection.prototype.classify = function(rows) {
+	if(!this._segmentCount) {
+		return false;
+	}
+	if(!this.hasClassification()) {
+		return false;
+	}
+	this._classification = this._classifierChanged = false;
+
+	var segmentSeparators = this._segments;
+	for(var rid in segmentSeparators) {
+		var segment = this._segments[rid];
+		if(!segment.isSubSegment()) {
+			if(segment.getClassification()) {
+				this._classification = true;
+			}
+			segment.classify(rows);
+		}
+	}
+	if(this._insertionList.length || this._removalList.length) {
+		this._dispatch("subSegmentChanged", {
+			"insertionList": this._insertionList,
+			"removalList": this._removalList
+		});
+		this._insertionList.length = 0;
+		this._removalList.length = 0;
+
+		this._dispatch("classified", {});
+		return true;
+	}
+
+	this._dispatch("classified", {});
+	return false;
+};
+
+/** @private
+* @param {!Object} e
+*/
+SegmentCollection.prototype._onSubSegmentAdded = function(e) {
+	var rid = e["rid"];
+	if(!this._segments[rid]) {
+		var segment = /** @type{Segment} */(e["segment"]);
+		this._insertionList.push(segment);
+		this._segments[rid] = segment;
+		this._segmentCount++;
+
+		segment.addEventListener("subSegmentAdded", this._onSubSegmentAdded);
+		segment.addEventListener("subSegmentRemoved", this._onSubSegmentRemoved);
+	} else {
+		console.log("Incorrect logic detected.");
+	}
+};
+/** @private
+* @param {!Object} e
+*/
+SegmentCollection.prototype._onSubSegmentRemoved = function(e) {
+	var rid = e["rid"];
+	this.removeSegment(rid);
+};
 
 
 /* harmony default export */ const data_SegmentCollection = (SegmentCollection);
@@ -12530,6 +13375,7 @@ SegmentCollection.prototype.getSegmentValues = function(rids) {
 
 
 
+ // eslint-disable-line
 
 
 /** Trigger when data within the table has been changed
@@ -12552,11 +13398,15 @@ var DataTable = function() {
 
 	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");
 };
 es6_Ext.inherits(DataTable, data_DataCache);
 
@@ -12599,6 +13449,14 @@ DataTable.prototype._removedRows = null;
 * @type {Function}
 */
 DataTable.prototype._userSegmentComparer = null;
+/** @private
+* @type {Object.<string, Object>}
+*/
+DataTable.prototype._clsSource = null;
+/** @private
+* @type {number}
+*/
+DataTable.prototype._classifyingTimer = 0;
 
 
 /** @typedef {Function} DataTable~SortLogic
@@ -12627,8 +13485,17 @@ 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._segments = null;
+	this._clsSource = null;
+	if(this._segments) {
+		this._segments.dispose();
+		this._segments = null;
+	}
 };
 
 /** {@link DataCache#getColumnData}
@@ -12746,7 +13613,7 @@ DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data chang
 			this._prevData[rid] = {};
 			if(eventArg) {
 				var nextRid = /** @type{string} */(eventArg["nextRid"]); // Used for insertion only
-				var rowIndex = (nextRid != null) ? this.getRowIndex(nextRid) : -1;
+				var rowIndex = (nextRid) ? this.getRowIndex(nextRid) : -1;
 				if(rowIndex < 0) {
 					rowIndex = /** @type{number} */(eventArg["fallback"]);
 				}
@@ -12778,6 +13645,7 @@ DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data chang
 				var segment = this._segments.getSegment(rid);
 				if(segment) {
 					if(this._segments.removeSegment(rid)) {
+						// TODO: Handle sub segment removal
 						segmentChanged = true;
 						if(!this._segments.getSegmentCount()) {
 							this._segments = null;
@@ -12785,12 +13653,7 @@ DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data chang
 					}
 				}
 			}
-			for(var i = this._rids.length; --i >= 0;) {
-				if(this._rids[i] === rid) {
-					this._rids.splice(i, 1);
-					break;
-				}
-			}
+			DataTable._removeArrayItem(this._rids, rid);
 			dirty = true;
 		}
 	}
@@ -12809,7 +13672,7 @@ DataTable.prototype.setRowData = function(rid, values, eventArg) { // Data chang
 			}
 			this._dispatchDataChange(e);
 		}
-
+		this.requestClassifying(); // TODO: Check if needFiring method should have an effect on this request
 	}
 	return dirty;
 };
@@ -13012,7 +13875,7 @@ DataTable.prototype.unshiftRow = function(opt_values, opt_rid) {
 	return this.insertRow(0, opt_values, opt_rid);
 };
 /** @public
-* @param {string|number|null=} rowRef
+* @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
@@ -13021,11 +13884,13 @@ DataTable.prototype.unshiftRow = function(opt_values, opt_rid) {
 * @see {@link DataTable#removeRow}
 */
 DataTable.prototype.insertRow = function(rowRef, values, rid) {
-	var arg = {};
+	var arg = null;
 	if(typeof rowRef === "number") {
+		arg = {};
 		arg["nextRid"] = this._rids[rowRef];
 		arg["fallback"] = rowRef; // Fallback index in case of no nextRid found
-	} else {
+	} else if(rowRef) {
+		arg = {};
 		arg["nextRid"] = /** @type{string} */(rowRef);
 	}
 
@@ -13110,12 +13975,34 @@ DataTable.prototype.removeRows = function(refs) {
 DataTable.prototype._removeRows = function(rid) {
 	return !this._removedRows[rid];
 };
+
+/** @private
+* @param {Array} ary
+* @param {*} item
+* @return {boolean}
+*/
+DataTable._removeArrayItem = function(ary, item) {
+	var 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 = {};
+	// TODO: Clear all segments
+	if(this._segments) {
+		this._segments.removeAllSegmentChildren(); // This immediately remove all sub segments
+	}
 
 	if(this._rids.length) {
 		this._rids.length = 0;
@@ -13422,6 +14309,7 @@ DataTable.prototype.setSegmentSeparator = function(rid, enabled) {
 		if(enabled !== false) {
 			if(!this._segments) {
 				this._segments = new data_SegmentCollection();
+				this._segments.addEventListener("subSegmentChanged", this._onSubSegmentChanged);
 			}
 			if(this._autoSegmentFilling) {
 				var parentId = this._segments.getParentRowId(rid);
@@ -13494,6 +14382,29 @@ DataTable.prototype.isSegmentSeparator = function(rid) {
 	}
 	return false;
 };
+/** Get Segment object
+* @public
+* @param {string} rid Row id
+* @return {Segment} Return 0 if the given rid is not a segment
+*/
+DataTable.prototype.getSegment = function(rid) {
+	if(this._segments) {
+		return this._segments.getSegment(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) {
+	var segment = this.getSegment(rid);
+	if(segment) {
+		return segment.getSegmentLevel() + 1;
+	}
+	return 0;
+};
 /**
 * @public
 * @param {string} rid
@@ -13567,6 +14478,7 @@ 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
@@ -13578,6 +14490,7 @@ DataTable.prototype.fillSegments = function() {
 		var dirty = this._segments.fillSegments(this._rids);
 		if(dirty) {
 			this.dispatchGlobalChange();
+			this.requestClassifying();
 		}
 		return dirty;
 	}
@@ -13586,15 +14499,17 @@ DataTable.prototype.fillSegments = function() {
 /** @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) {
+DataTable.prototype.addSegmentChild = function(segmentId, rid, dataId) {
 	if(this._segments) {
-		var dirty = this._segments.addSegmentChild(segmentId, rid);
+		var dirty = this._segments.addSegmentChild(segmentId, rid, dataId);
 		if(dirty) {
 			if(this._sort(null)) {
 				this._dispatchPositionChange();
 			}
+			this.requestClassifying();
 			return true;
 		}
 	}
@@ -13612,6 +14527,7 @@ DataTable.prototype.addSegmentChildren = function(segmentId, rids) {
 			if(this._sort(null)) {
 				this._dispatchPositionChange();
 			}
+			this.requestClassifying();
 			return true;
 		}
 	}
@@ -13627,6 +14543,7 @@ DataTable.prototype.removeSegmentChild = function(segmentId, rid) {
 		var dirty = this._segments.removeSegmentChild(segmentId, rid);
 		if(dirty) {
 			this.dispatchGlobalChange();
+			this.requestClassifying();
 		}
 		return dirty;
 	}
@@ -13642,6 +14559,7 @@ DataTable.prototype.removeSegmentChildren = function(segmentId, rids) {
 		var dirty = this._segments.removeSegmentChildren(segmentId, rids);
 		if(dirty) {
 			this.dispatchGlobalChange();
+			this.requestClassifying();
 		}
 		return dirty;
 	}
@@ -13652,7 +14570,7 @@ DataTable.prototype.removeSegmentChildren = function(segmentId, rids) {
 */
 DataTable.prototype.removeAllSegmentChildren = function() {
 	if(this._segments) {
-		var dirty = this._segments.removeAllSegmentChildren();
+		var dirty = this._segments.removeAllSegmentChildren(); // This immediately remove all sub segments
 		if (dirty) {
 			this.dispatchGlobalChange();
 		}
@@ -13688,10 +14606,15 @@ DataTable.prototype.getSegmentChildIds = function(segmentId) {
 /** Sort all of existing segments by given compare function
 * @public
 * @param {Function} compare
+* @return {boolean}
 */
 DataTable.prototype.sortSegments = function (compare) {
-	if(!this._segments || typeof compare !== "function") {
-		return;
+	if(!this._segments) {
+		return false;
+	}
+	if(typeof compare !== "function") {
+		this._segments.calcSegmentOrder(this._rids);
+		return false;
 	}
 	var rids = this._rids;
 	var segments = this._segments;
@@ -13735,7 +14658,9 @@ DataTable.prototype.sortSegments = function (compare) {
 		this._segments.calcSegmentOrder(rids);
 		this._sort(null);
 		this._dispatchPositionChange();
+		return true;
 	}
+	return false;
 };
 /** Sort all of existing segments by given compare function
 * @private
@@ -13750,6 +14675,112 @@ DataTable.prototype._bySegmentSeparator = function (segmentA, segmentB) {
 	));
 };
 
+/** 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) {
+		var 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) {
+	var insertionList = /** @type{Array.<Segment>} */(e["insertionList"]);
+	var removalList = /** @type{Array.<string>} */(e["removalList"]);
+
+	var dirty = false;
+	var rows = this._rows;
+	var clsSource = this._clsSource || rows;
+	var rids = this._rids;
+	var prevData = this._prevData;
+	var i;
+
+	var removalCount = removalList.length;
+	var removedRows = {};
+	for(i = 0; i < removalCount; i++) {
+		var 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
+		}
+	}
+
+	var insertionCount = insertionList.length;
+	for(i = 0; i < insertionCount; i++) {
+		var segment = insertionList[i];
+		var parentId = segment.getParentId();
+		var segmentId = segment.getId();
+
+		if(!rows[segmentId]) {
+			prevData[segmentId] = {};
+			segment.setRowData(rows, clsSource);
+
+			var 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
@@ -16190,6 +17221,7 @@ Conflator.prototype.enable = function (opt_enabled) {
 
  // eslint-disable-line
 
+ // eslint-disable-line
 
 
 
@@ -18534,6 +19566,22 @@ DataView.prototype.isSegmentSeparator = function(rid) {
 	return this._dt.isSegmentSeparator(rid);
 };
 
+/** Get Segment object
+* @public
+* @param {string} rid Row id
+* @return {Segment} Return 0 if the given rid is not a segment
+*/
+DataView.prototype.getSegment = function(rid) {
+	return this._dt.getSegment(rid);
+};
+/** Segment level starts from 1
+* @public
+* @param {string} rid Row id
+* @return {number} Return 0 if the given rid is not a segment
+*/
+DataView.prototype.getSegmentLevel = function(rid) {
+	return this._dt.getSegmentLevel(rid);
+};
 /**
 * @public
 * @param {string} rid
@@ -18615,13 +19663,14 @@ DataView.prototype.fillSegments = function() {
 /** @public
 * @param {string|number} segmentRef Row id or row index
 * @param {string|number} rowRef Row id, row index
+* @param {string=} dataId Row id for retrieving data
 * @return {boolean} Return true if there is any change
 */
-DataView.prototype.addSegmentChild = function(segmentRef, rowRef) {
+DataView.prototype.addSegmentChild = function(segmentRef, rowRef, dataId) {
 	if(this._dt._getSegmentSeparators()) {
 		var segmentId = this._toRowId(segmentRef);
 		var rowId = this._toRowId(rowRef);
-		return this._dt.addSegmentChild(segmentId, rowId);
+		return this._dt.addSegmentChild(segmentId, rowId, dataId);
 	}
 	return false;
 };
@@ -18693,6 +19742,16 @@ DataView.prototype.sortSegments = function (compare) {
 	this._dt.sortSegments(compare);
 };
 
+/**
+* @public
+* @param {string|number} segmentRef Row id or row index
+* @param {string|Array.<string>} fields
+* @return {boolean}
+*/
+DataView.prototype.setSegmentClassification = function(segmentRef, fields) {
+	return this._dt.setSegmentClassification(this._toRowId(segmentRef), fields);
+};
+
 /** @public
 * @ignore
 * @return {Object}
@@ -23149,7 +24208,7 @@ Core_Core.prototype._rowHeightTimerId = 0;
 * @return {string}
 */
 Core_Core.getVersion = function () {
-	return "5.1.20";
+	return "5.1.27";
 };
 /** {@link ElementWrapper#dispose}
 * @override