@refinitiv-ui/efx-grid 6.0.146 → 6.0.148

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

@@ -8,7 +8,7 @@ import EventDispatcher from "../../../tr-grid-util/es6/EventDispatcher.js";
 */
 let Segment = function(rid, sharedObj) {
 	this._rid = rid;
-	this._children = {};
+	this._childIds = [];
 	this._shared = sharedObj;
 	if(sharedObj.defaultCollapsing) {
 		this._collapsed = true;
@@ -39,14 +39,6 @@ Segment._subSegSortLogic = function(a, b) {
 
 	return 0;
 };
-/** @private
-* @function
-* @param {Segment} segment
-* @param {number} idx
-*/
-Segment._assignSubSegmentOrder = function(segment, idx) {
-	segment.setOrder(idx + 1);
-};
 
 /** @type {Object}
 * @private
@@ -57,14 +49,14 @@ Segment.prototype._shared = null;
 * @private
 */
 Segment.prototype._rid;
-/** @type {!Object}
+/** @type {!Array.<string>}
 * @private
 */
-Segment.prototype._children;
-/** @type {number}
+Segment.prototype._childIds;
+/** @type {Object}
 * @private
 */
-Segment.prototype._childCount = 0;
+Segment.prototype._childDataIds = null;
 /** @type {boolean}
 * @private
 */
@@ -73,6 +65,14 @@ Segment.prototype._collapsed = false;
 * @private
 */
 Segment.prototype._order = 0;
+/** @type {number}
+* @private
+*/
+Segment.prototype._offsetOrder = 0;
+/** @type {number}
+* @private
+*/
+Segment.prototype._depth = 0;
 /** @type {boolean}
 * @private
 */
@@ -82,10 +82,10 @@ Segment.prototype._disposed = false;
 * @private
 */
 Segment.prototype._subSegDef = null;
-/** @type {number}
+/** @type {boolean}
 * @private
 */
-Segment.prototype._subSegLevel = 0;
+Segment.prototype._subSegment = false; // This indicates that the segment is autogenerated (subsegment)
 /** @type {Object.<string, Segment>}
 * @private
 */
@@ -93,7 +93,7 @@ Segment.prototype._subSegMap = null; // For immediate sub-segment children
 /** @type {Array.<string>}
 * @private
 */
-Segment.prototype._subSegNames = null; // For immediate sub-segment child names
+Segment.prototype._subSegNames = null; // For immediate sub-segment child names/ids
 /** @type {string}
 * @private
 */
@@ -102,10 +102,6 @@ Segment.prototype._subSegName = "";
 * @private
 */
 Segment.prototype._subSegVal;
-/** @type {Segment}
-* @private
-*/
-Segment.prototype._subSegParent = null;
 
 
 /** @public
@@ -127,14 +123,13 @@ Segment.prototype.dispose = function() {
 		this._subSegMap = this._subSegNames = null;
 	}
 	if(this._collapsed) {
-		if(this._childCount || this._subSegDef) {
-			this._shared.dirtyCollapsingState = true;
-		}
+		this.markCollapsingStateDirty();
 	}
 
-	this._childCount = 0;
+	this._childDataIds = null;
+	this._childIds.length = 0;
 	this._shared = null;
-	this._subSegParent = this._subSegDef = this._subSegVal = null;
+	this._subSegDef = this._subSegVal = null;
 };
 /** @public
 * @return {string}
@@ -146,10 +141,17 @@ Segment.prototype.getId = function() {
 * @return {string}
 */
 Segment.prototype.getParentId = function() {
-	if(this._subSegParent) {
-		return this._subSegParent.getId();
+	return this._shared.childToSegment[this._rid] || "";
+};
+/** @public
+* @return {Segment}
+*/
+Segment.prototype.getParent = function() {
+	let parentId = this.getParentId();
+	if(parentId) {
+		return this._shared.segments[parentId] || null;
 	}
-	return "";
+	return null;
 };
 /** @public
 * @param {Array.<string>=} out_ary
@@ -177,22 +179,44 @@ Segment.prototype.getSubSegmentIds = function(out_ary) {
 /** @public
 * @param {string} rid
 * @param {string=} dataId Row id for retrieving data
-* @return {boolean}
+* @return {boolean} Returns true only a new child is added
 */
 Segment.prototype.addChild = function(rid, dataId) {
-	if(rid) {
+	if(!rid) {
+		return false;
+	}
+	let prevSegmentId = this._shared.childToSegment[rid];
+	if(prevSegmentId) {
+		if(prevSegmentId !== this._rid) {
+			let prevSegment = this._shared.segments[prevSegmentId];
+			if(prevSegment && !prevSegment.hasSubSegments()) { // Children of a classified segment always stick the root segment
+				prevSegment.removeChild(rid);
+			}
+			this._shared.childToSegment[rid] = this._rid;
+		}
+	} else {
 		this._shared.childToSegment[rid] = this._rid;
-		if(this._children[rid]) {
-			this._children[rid] = dataId || rid; // Update data id
-		} else {
-			if(this._collapsed) {
-				this._shared.dirtyCollapsingState = true; // TODO: Check if we need to update this only when new child is added
+	}
+
+	if(dataId != null) { // Update data id
+		if(dataId && dataId !== rid) {
+			if(!this._childDataIds) {
+				this._childDataIds = {};
 			}
-			this._children[rid] = dataId || rid;
-			++this._childCount;
-			return true;
+			this._childDataIds[rid] = dataId;
+		} else if(this._childDataIds) {
+			delete this._childDataIds[rid];
 		}
 	}
+
+	let at = this._childIds.indexOf(rid);
+	if(at < 0) {
+		if(this._collapsed) {
+			this._shared.dirtyCollapsingState = true; // TODO: Check if we need to update this only when new child is added
+		}
+		this._childIds.push(rid);
+		return true;
+	}
 	return false;
 };
 /** @public
@@ -201,8 +225,15 @@ Segment.prototype.addChild = function(rid, dataId) {
 * @return {boolean}
 */
 Segment.prototype.addChildren = function(rids, dataIds) {
+	if(!rids) {
+		return false;
+	}
 	let rowIds = Array.isArray(rids) ? rids : [rids];
 	let rowCount = rowIds.length;
+	if(!rowCount) {
+		return false;
+	}
+
 	let dirty = 0;
 	let i;
 	if(dataIds != null) {
@@ -222,27 +253,35 @@ Segment.prototype.addChildren = function(rids, dataIds) {
 * @return {boolean}
 */
 Segment.prototype.containsChild = function(rid) {
-	return this._children[rid] ? true : false;
+	return this._childIds.indexOf(rid) >= 0;
+};
+/** @public
+* @param {string} rid
+* @return {number}
+*/
+Segment.prototype.getChildIndex = function(rid) {
+	return this._childIds.indexOf(rid);
 };
 /** @public
 * @param {string} rid
 * @return {boolean}
 */
 Segment.prototype.removeChild = function(rid) {
-	if(this._subSegLevel) {
+	if(this._subSegment) {
 		return false; // Sub segments are not allowed to remove its children
 	}
-	if(!this._childCount) {
+	if(!this._childIds.length) {
 		return false;
 	}
-	if(!this._children[rid]) {
+	let at = this._childIds.indexOf(rid);
+	if(at < 0) {
 		return false; // The specified rid is not a child of this segment
 	}
 
-	let objMap = this._shared.childToSegment;
-	delete objMap[rid];
-	delete this._children[rid]; // Slow
-	--this._childCount;
+	if(this._shared.childToSegment[rid] === this._rid) {
+		delete this._shared.childToSegment[rid];
+	}
+	this._childIds.splice(at, 1); // Slow
 
 	if(this._collapsed) {
 		this._shared.dirtyCollapsingState = true;
@@ -254,10 +293,10 @@ Segment.prototype.removeChild = function(rid) {
 * @return {boolean}
 */
 Segment.prototype.removeChildren = function(rids) {
-	if(this._subSegLevel) {
+	if(this._subSegment) {
 		return false; // Sub segments are not allowed to remove its children
 	}
-	if(!this._childCount) {
+	if(!this._childIds.length) {
 		return false;
 	}
 	let rowIds = Array.isArray(rids) ? rids : [rids];
@@ -272,21 +311,24 @@ Segment.prototype.removeChildren = function(rids) {
 * @return {boolean}
 */
 Segment.prototype.removeAllChildren = function() {
-	if(this._subSegLevel) {
+	if(this._subSegment) {
 		return false; // Sub segments are not allowed to remove its children
 	}
-	if(!this._childCount) {
+	let childCount = this._childIds.length;
+	if(!this._childIds.length) {
 		return false;
 	}
+	let segmentId = this._rid;
 	let objMap = this._shared.childToSegment;
-	let chdr = this._children;
-	for(let rid in chdr) {
-		if(objMap[rid]) {
-			delete objMap[rid]; // TODO: Check if we need to do this
+	let chdr = this._childIds;
+	for(let i = 0; i < childCount; ++i) {
+		let rid = chdr[i];
+		if(objMap[rid] === segmentId) {
+			delete objMap[rid];
 		}
 	}
-	this._children = {};
-	this._childCount = 0;
+	this._childIds.length = 0;
+	this._childDataIds = null;
 
 	if(this._collapsed) {
 		this._shared.dirtyCollapsingState = true;
@@ -297,24 +339,41 @@ Segment.prototype.removeAllChildren = function() {
 * @return {!Array.<string>}
 */
 Segment.prototype.getChildIds = function() {
-	return this._childCount ? Object.keys(this._children) : [];
+	return this._childIds; // WARNING: Returns private members
 };
 /** @public
 * @return {!Object}
 */
 Segment.prototype.getChildren = function() {
-	return this._children;
+	let obj = {};
+	let chdr = this._childIds;
+	let childCount = chdr.length;
+	let dataIds = this._childDataIds || {};
+	for(let i = 0; i < childCount; ++i) {
+		let rid = chdr[i];
+		obj[rid] = dataIds[rid] || rid;
+	}
+	return obj;
 };
 /** @public
 * @return {number}
 */
 Segment.prototype.getChildCount = function() {
-	return this._childCount;
+	return this._childIds.length;
+};
+/** When a segment is not empty, the visibility of its content need to be updated.
+* @public
+*/
+Segment.prototype.markCollapsingStateDirty = function() {
+	// A segment can have a child and/or autogenerated segment (subsegment) to not be considered as empty.
+	if(this._childIds.length ||  this._subSegDef) {
+		this._shared.dirtyCollapsingState = true;
+	}
 };
 
 
 /** @public
-* @return {Array.<string>} fields
+* @return {Array.<string>}
 */
 Segment.prototype.getClassification = function() {
 	if(this._subSegDef) {
@@ -327,8 +386,8 @@ Segment.prototype.getClassification = function() {
 * @return {boolean}
 */
 Segment.prototype.setClassification = function(fields) {
-	if(this._subSegLevel) {
-		return false; // non-root segment cannot be classified
+	if(this._subSegment) {
+		return false; // subsegment cannot be classified
 	}
 	let classifiers = null;
 	if(this._subSegDef) {
@@ -371,9 +430,8 @@ Segment.prototype.setClassification = function(fields) {
 		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
+		this._subSegDef = null; // WARNING: All subsegments remain existing
 		return true;
 	}
 	return false;
@@ -390,7 +448,7 @@ Segment.prototype.classify = function(rows) {
 	let segmentCount = segmentNames ? segmentNames.length : 0;
 
 	if(!segmentCount) {
-		if(this._subSegLevel >= classifierCount) {
+		if(this._depth >= classifierCount) {
 			return false; // Current segment level is beyond existing classification level and this segment should already be removed
 		}
 	}
@@ -400,7 +458,7 @@ Segment.prototype.classify = function(rows) {
 		sharedObj.dirtyCollapsingState = true;
 	}
 
-	// Prepare existing sub segments for checking change in its members
+	// Prepare existing subsegments for checking change in its members
 	let i;
 	let segmentName = "";
 	let nonExistenceGroups = {};
@@ -414,9 +472,8 @@ Segment.prototype.classify = function(rows) {
 			nonExistenceGroups[segmentName] = 1;
 
 			segment = segmentMap[segmentName];
-			if(segment._childCount) { // Quick cleaning up
-				segment._children = {};
-				segment._childCount = 0;
+			if(segment._childIds.length) { // Quick cleaning up
+				segment._childIds.length = 0;
 			}
 			if(segment._collapsed) {
 				sharedObj.dirtyCollapsingState = true;
@@ -424,20 +481,23 @@ Segment.prototype.classify = function(rows) {
 		}
 	}
 
-	// Loop through row children and assign them to their corresponding sub segment
-	let isRootSegment = !this._subSegLevel;
+	// Loop through row children and assign them to their corresponding subsegment
+	let rootSegment = !this._subSegment;
+	let dataIds = this._childDataIds || {};
 	let rid;
-	let children = this._children;
-	if(this._subSegLevel < classifierCount && rows) {
+	let chdr = this._childIds;
+	let childCount = chdr.length;
+	if(this._depth < classifierCount && rows) {
 		if(!segmentMap) {
 			segmentMap = this._subSegMap = {};
 			segmentNames = this._subSegNames = [];
 		}
 
-		let classifier = classifiers[this._subSegLevel];
+		let classifier = classifiers[this._depth];
 
-		for(rid in children) {
-			let dataId = children[rid];
+		for(i = 0; i < childCount; ++i) {
+			rid = chdr[i];
+			let dataId = dataIds[rid] || rid;
 			let record = rows[dataId];
 			let val = record ? record[classifier] : null; // WARNING: row could already be removed
 
@@ -454,31 +514,34 @@ Segment.prototype.classify = function(rows) {
 
 			segment = segmentMap[segmentName];
 			if(!segment) { // New group is detected
-				segment = new Segment(this._rid + "/" + segmentName, sharedObj);
+				let subSegId = this._rid + "/" + segmentName;
+				segment = new Segment(subSegId, sharedObj);
 				segment._subSegDef = this._subSegDef;
-				segment._subSegLevel = this._subSegLevel + 1;
+				segment._subSegment = true; // this indicates that the segment is autogenerated (subsegment)
+				segment._depth = this._depth + 1;
 				segment._subSegName = segmentName;
 				segment._subSegVal = val;
-				segment._subSegParent = this;
+				sharedObj.childToSegment[subSegId] = this._rid; // WARNING: this will mix autogenerated rows with actual rows
 
 				segmentMap[segmentName] = segment;
 				segmentNames.push(segmentName);
 
 				this._dispatch("subSegmentAdded", {
-					"rid": segment.getId(),
+					"rid": subSegId,
 					"segment": segment
 				});
 			}
 
 			segment.addChild(rid, dataId);
 		}
-	} else if(isRootSegment) { // In case of no classification
-		for(rid in children) {
+	} else if(rootSegment) { // In case of no classification
+		for(i = 0; i < childCount; ++i) {
+			rid = chdr[i];
 			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
+	// Remove all subsegments with no members
 	if(removalCount > 0) {
 		if(removalCount >= segmentNames.length) {
 			segmentNames.length = 0;
@@ -506,7 +569,7 @@ Segment.prototype.classify = function(rows) {
 		}
 	}
 
-	// Sort and classify existing sub segments
+	// Sort and classify existing subsegments
 	segmentCount = segmentNames ? segmentNames.length : 0;
 	if(segmentCount) {
 		segmentNames.sort(Segment._subSegSortLogic);
@@ -516,22 +579,17 @@ Segment.prototype.classify = function(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) {
-				let subSegments = this._subSegDef.subSegments = [];
-				this.getAllSubSegments(subSegments);
-				subSegments.forEach(Segment._assignSubSegmentOrder);
-			} else {
-				this._subSegDef.subSegments = null;
-			}
-			// this._subSegDef.classifierChanged = false;
+	// Collecting all subsegments including all descendants and reassigning segment order.
+	if(rootSegment && this._subSegDef) {
+		if(segmentCount) {
+			this.calcSubSegmentOrder(0);
 		}
+		// this._subSegDef.classifierChanged = false;
 	}
 	return true;
 };
-/** @public
+/** SubSegment implies being classified
+* @public
 * @return {boolean}
 */
 Segment.prototype.hasSubSegments = function() {
@@ -540,21 +598,37 @@ Segment.prototype.hasSubSegments = function() {
 	}
 	return false;
 };
-/** @public
+/** SubSegment implies autogenerated segment
+* @public
 * @return {boolean}
 */
 Segment.prototype.isSubSegment = function() {
-	return this._subSegLevel ? true : false;
+	return this._subSegment;
+};
+/** @public
+* @return {boolean}
+*/
+Segment.prototype.isRootSegment = function() {
+	return this._shared.childToSegment[this._rid] ? false : true;
 };
 /** @public
 * @return {Segment}
 */
 Segment.prototype.getFirstAncestor = function() {
-	if(this._subSegLevel && this._subSegDef) {
-		let ancestor = this._subSegDef.root;
-		return /** @type{Segment} */(ancestor) || null;
+	let ancestor = null;
+	if(this._subSegment && this._subSegDef) { // Quick way to get root
+		ancestor = this._subSegDef.root;
+	} else { // Slow
+		ancestor = this.getParent();
+		if(ancestor) {
+			let parentSeg = ancestor.getParent();
+			while(parentSeg) { // This could cause infinite loop
+				ancestor = parentSeg;
+				parentSeg = ancestor.getParent();
+			}
+		}
 	}
-	return null;
+	return ancestor || null;
 };
 /** @public
 * @param {Array.<Segment>=} out_ary
@@ -576,13 +650,75 @@ Segment.prototype.getAllSubSegments = function(out_ary) {
 	}
 	return out_ary || null;
 };
+/** This method sets order, last order, and depth to entire tree structure in the segment, including the segment itself
+* @public
+* @param {number} counter
+* @return {number}
+*/
+Segment.prototype.updateTreeStructure = function(counter) {
+	if(!counter) {
+		counter = 0;
+		if(!this._subSegment) { // Subsegment's depth cannot be reset back to 0
+			this._depth = 0; // WARNING: this assumes counter at 0 is the root segment
+		}
+	}
+	if(this.hasSubSegments()) {
+		return this.setLastOrder(counter); // Sub segments has already been calculated
+	}
+	let segmentSeparators = this._shared.segments;
+	let childCount = this._childIds.length;
+	let prevSeg = null;
+	for(let i = 0; i < childCount; ++i) {
+		let rid = this._childIds[i];
+		let segment = segmentSeparators[rid];
+		let segmentId = (segment) ? segment.getId() : "Uncategorized";
+		if(prevSeg !== segmentId) {
+			++counter; // 0 become 1
+			prevSeg = segmentId;
+		}
+		if(segment) {
+			segment._depth = this._depth + 1;
+			segment.setOrder(counter);
+			counter = segment.updateTreeStructure(counter);
+		}
+	}
+
+	return this.setLastOrder(counter);
+};
+/** @public
+* @param {number} counter
+* @return {number}
+*/
+Segment.prototype.calcSubSegmentOrder = function(counter) {
+	if(!this.hasSubSegments()) {
+		return this.setLastOrder(counter);
+	}
+
+	let segmentMap = this._subSegMap;
+	let childCount = this._subSegNames.length;
+	let prevSeg = null;
+	for(let i = 0; i < childCount; ++i) {
+		let segmentName = this._subSegNames[i];
+		let segment = segmentMap[segmentName];
+		let segmentId = (segment) ? segment.getId() : "Uncategorized";
+		if(prevSeg !== segmentId) {
+			++counter; // 0 become 1
+			prevSeg = segmentId;
+		}
+		if(segment) {
+			segment.setOrder(counter);
+			counter = segment.calcSubSegmentOrder(counter);
+		}
+	}
+	return this.setLastOrder(counter);
+};
 /** @public
 * @return {number}
 */
 Segment.prototype.getSegmentLevel = function() {
-	return this._subSegLevel;
+	return this._depth;
 };
-/** This method will be called on sub segments only
+/** This method will be called on subsegments only
 * @public
 * @param {Object=} rows
 * @param {Object=} clsSource
@@ -607,7 +743,7 @@ Segment.prototype.setRowData = function(rows, clsSource) {
 	let segment = this;
 	while(segment && segment.isSubSegment()) {
 		segment.getSubSegmentName(row);
-		segment = segment._subSegParent;
+		segment = segment.getParent();
 	}
 };
 /** @public
@@ -615,9 +751,9 @@ Segment.prototype.setRowData = function(rows, clsSource) {
 * @return {string}
 */
 Segment.prototype.getSubSegmentName = function(row) {
-	if(row && this._subSegLevel) {
+	if(row && this._subSegment) {
 		let classifiers = this.getClassification();
-		let field = classifiers[this._subSegLevel - 1];
+		let field = classifiers[this._depth - 1];
 		if(field) {
 			row[field] = this._subSegName;
 		}
@@ -633,9 +769,7 @@ Segment.prototype.collapse = function(bool) {
 	bool = (bool !== false);
 	if(this._collapsed !== bool) {
 		this._collapsed = bool;
-		if(this._childCount || this._subSegDef) {
-			this._shared.dirtyCollapsingState = true;
-		}
+		this.markCollapsingStateDirty();
 		return true;
 	}
 	return false;
@@ -653,82 +787,87 @@ Segment.prototype.expand = function(bool) {
 Segment.prototype.isCollapsed = function() {
 	return this._collapsed;
 };
-/** @public
+/** Get all collapsing state from all children (subsegments and child segments), excluding the segment itself
+* @public
 * @param {Object=} objMap
 * @param {boolean=} parentState=false Collapsing state from parent segment
 * @return {boolean}
 */
 Segment.prototype.getCollapsingStates = function(objMap, parentState) {
-	let segmentNames = this._subSegNames;
-	if(!this._subSegLevel) { // Only root segment
-		if(!segmentNames) { // No sub segment
-			if(!this._collapsed) {
-				return false;
-			}
-		}
+	let childList = this._subSegNames;
+	let segmentMap = this._subSegMap;
+	let subSegment = true; // Normal segments can have subsegments without being subsegment themselve
+	if(!childList && this._shared) { // Ensure that segment has not been disposed
+		childList = this._childIds;
+		segmentMap = this._shared.segments;
+		subSegment = false;
+	}
+	let childCount = childList ? childList.length : 0;
+	if(!childCount) {
+		return false;
 	}
 
+	let dirty = false;
+	let childCollapsed = (parentState || this._collapsed) ? true : false;
+
 	if(!objMap) {
 		objMap = {};
 	}
-	let dirty = false;
-	if(this._subSegLevel) { // Sub segments are also subjected to collapsing
-		if(parentState) {
-			objMap[this._rid] = true;
+	for(let i = 0; i < childCount; ++i) {
+		let rid = "";
+		let segment = null;
+		if(subSegment) {
+			segment = segmentMap[childList[i]]; // Use segment name to retrieve subsegment
+			rid = segment.getId();
+		} else {
+			rid = childList[i];
+			segment = segmentMap[rid]; // Use row id to retrieve segment from shared map
+		}
+		if(childCollapsed) {
+			objMap[rid] = childCollapsed; // Collapsing states for all children is registered here
 			dirty = true;
 		}
-	}
-	if(this._childCount) {
-		let collapsed = parentState || this._collapsed;
-		if(segmentNames) {
-			let segmentMap = this._subSegMap;
-			let segmentCount = segmentNames.length;
-			for(let i = 0; i < segmentCount; ++i) {
-				let segment = segmentMap[segmentNames[i]];
-				objMap[segment.getId()] = !!parentState;
-				if(segment.getCollapsingStates(objMap, collapsed)) {
-					dirty = true;
-				}
-			}
-		} else if(collapsed) {
-			let chdr = this._children;
-			for(let rid in chdr) {
-				objMap[rid] = collapsed;
-			}
+		if(segment && segment.getCollapsingStates(objMap, childCollapsed)) {
 			dirty = true;
 		}
 	}
 	return dirty;
 };
 
+/** @private
+* @return {number}
+*/
+Segment.prototype._getOrder = function() {
+	return this._order * 10000;
+};
+/** @private
+* @return {number}
+*/
+Segment.prototype._getLastOrder = function() {
+	return this._getOrder() + this._offsetOrder;
+};
 /** @public
 * @return {number}
 */
 Segment.prototype.getOrder = function() {
-	if(this._subSegLevel) {
-		let ancestor = this.getFirstAncestor();
-		if(ancestor) {
-			// WARNING: this._order cannot be greater than 9999
-			return ancestor.getOrder() + this._order;
-		}
+	let ancestor = this.getFirstAncestor();
+	if(ancestor) {
+		// WARNING: this._order cannot be greater than 9999
+		return ancestor._getOrder() + this._order;
 	}
-	return this._order * 10000;
+	return this._getOrder();
 };
 /** Get the last (highest) order from the entire tree regardless of the current position segment in the hierachy
 * @public
 * @return {number}
 */
 Segment.prototype.getLastOrder = function() {
-	if(this._subSegDef) {
-		let subSegments = this._subSegDef.subSegments;
-		if(subSegments) {
-			let lastSegment = subSegments[subSegments.length - 1];
-			if(lastSegment) {
-				return lastSegment.getOrder();
-			}
-		}
+	let ancestor = this.getFirstAncestor();
+	if(ancestor) {
+		// WARNING: this._order cannot be greater than 9999
+		return ancestor._getLastOrder();
 	}
-	return this.getOrder();
+	return this._getLastOrder();
 };
 /** @public
 * @param {number} val
@@ -736,6 +875,13 @@ Segment.prototype.getLastOrder = function() {
 Segment.prototype.setOrder = function(val) {
 	this._order = val;
 };
+/** @public
+* @param {number} val
+* @returns {number} Returns the number set
+*/
+Segment.prototype.setLastOrder = function(val) {
+	return (this._offsetOrder = val);
+};
 
 /** @private
 * @type {Array.<string>}
@@ -743,9 +889,10 @@ Segment.prototype.setOrder = function(val) {
 Segment._tabs = null;
 /** @public
 * @param {Array.<string>=} lines
+* @param {number=} tabLevel
 * @return {!Array.<string>} lines
 */
-Segment.prototype.log = function(lines) {
+Segment.prototype.log = function(lines, tabLevel) {
 	if(!lines) {
 		lines = [];
 	}
@@ -760,23 +907,43 @@ Segment.prototype.log = function(lines) {
 			tabCh += "  ";
 		}
 	}
+	if(!tabLevel) {
+		tabLevel = 0;
+	}
+
 	let collapsedCh = this._collapsed ? "+ " : "- ";
-	lines.push(tabs[this._subSegLevel] + collapsedCh + this._rid);
+	lines.push(tabs[tabLevel] + collapsedCh + this._rid);
 
-	let segmentNames = this._subSegNames;
-	if(segmentNames) {
-		let segmentCount = segmentNames.length;
-		let segmentMap = this._subSegMap;
-		for(i = 0; i < segmentCount; ++i) {
-			segmentMap[segmentNames[i]].log(lines);
+	let childLevel = tabLevel + 1;
+	let childIndent = tabs[childLevel];
+
+	let childList = this._subSegNames;
+	let segmentMap = this._subSegMap;
+	let subSegment = true; // Normal segments can have subsegments without being subsegment themselve
+	if(!childList && this._shared) { // Ensure that segment has not been disposed
+		childList = this._childIds;
+		segmentMap = this._shared.segments;
+		subSegment = false;
+	}
+	let childCount = childList ? childList.length : 0;
+
+	for(i = 0; i < childCount; ++i) {
+		let rid = "";
+		let segment = null;
+		if(subSegment) {
+			segment = segmentMap[childList[i]]; // Use segment name to retrieve subsegment
+			rid = segment.getId();
+		} else {
+			rid = childList[i];
+			segment = segmentMap[rid]; // Use row id to retrieve segment from shared map
 		}
-	} else if(this._childCount) {
-		let indent = tabs[this._subSegLevel + 1];
-		for(let rid in this._children) {
-			lines.push(indent + "- " + rid);
+
+		if(segment) {
+			segment.log(lines, childLevel);
+		} else {
+			lines.push(childIndent + "- " + rid);
 		}
 	}
-
 	return lines;
 };