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

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

@@ -0,0 +1,1001 @@
+import Ext from "../../../tr-grid-util/es6/Ext.js";
+import EventDispatcher from "../../../tr-grid-util/es6/EventDispatcher.js";
+
+/** @constructor
+* @extends {EventDispatcher}
+* @param {string} rid
+* @param {!Object} sharedObj
+*/
+let Segment = function(rid, sharedObj) {
+	this._rid = rid;
+	this._childIds = [];
+	this._shared = sharedObj;
+	if(sharedObj.defaultCollapsing) {
+		this._collapsed = true;
+	}
+};
+Ext.inherits(Segment, EventDispatcher);
+
+/** @public
+* @type {string}
+* @constant
+*/
+const UNCATEGORY = "Uncategorized";
+
+/** @private
+* @function
+* @param {string} a
+* @param {string} b
+* @return {number}
+*/
+Segment._subSegSortLogic = function(a, b) {
+	if(a === UNCATEGORY) {
+		return 1;
+	}
+	if(b === UNCATEGORY) {
+		return -1;
+	}
+
+	if(a < b) {
+		return -1;
+	}
+	if(b < a) {
+		return 1;
+	}
+
+	return 0;
+};
+
+/** @type {Object}
+* @private
+*/
+Segment.prototype._shared = null;
+
+/** @type {string}
+* @private
+*/
+Segment.prototype._rid;
+/** @type {!Array.<string>}
+* @private
+*/
+Segment.prototype._childIds;
+/** @type {Object}
+* @private
+*/
+Segment.prototype._childDataIds = null;
+/** @type {boolean}
+* @private
+*/
+Segment.prototype._collapsed = false;
+/** @type {number}
+* @private
+*/
+Segment.prototype._order = 0;
+/** @type {number}
+* @private
+*/
+Segment.prototype._offsetOrder = 0;
+/** @type {number}
+* @private
+*/
+Segment.prototype._depth = 0;
+/** @type {boolean}
+* @private
+*/
+Segment.prototype._disposed = false;
+
+/** @type {Object}
+* @private
+*/
+Segment.prototype._subSegDef = null;
+/** @type {boolean}
+* @private
+*/
+Segment.prototype._subSegment = false; // This indicates that the segment is autogenerated (subsegment)
+/** @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/ids
+/** @type {string}
+* @private
+*/
+Segment.prototype._subSegName = "";
+/** @type {*}
+* @private
+*/
+Segment.prototype._subSegVal;
+
+
+/** @public
+*/
+Segment.prototype.dispose = function() {
+	if(this._disposed) {
+		return;
+	}
+	this._disposed = true;
+
+	this.removeAllEventListeners();
+	let segmentNames = this._subSegNames;
+	if(segmentNames) {
+		let segmentCount = segmentNames.length;
+		let segmentMap = this._subSegMap;
+		for(let i = 0; i < segmentCount; ++i) {
+			segmentMap[segmentNames[i]].dispose();
+		}
+		this._subSegMap = this._subSegNames = null;
+	}
+	if(this._collapsed) {
+		this.markCollapsingStateDirty();
+	}
+
+	this._childDataIds = null;
+	this._childIds.length = 0;
+	this._shared = null;
+	this._subSegDef = this._subSegVal = null;
+};
+/** @public
+* @return {string}
+*/
+Segment.prototype.getId = function() {
+	return this._rid;
+};
+/** @public
+* @return {string}
+*/
+Segment.prototype.getParentId = function() {
+	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 null;
+};
+/** @public
+* @param {Array.<string>=} out_ary
+* @return {Array.<string>}
+*/
+Segment.prototype.getSubSegmentIds = function(out_ary) {
+	let segmentNames = this._subSegNames;
+	if(segmentNames) {
+		if(!out_ary) {
+			out_ary = [];
+		}
+		let segmentCount = segmentNames.length;
+		let segmentMap = this._subSegMap;
+		for(let i = 0; i < segmentCount; ++i) {
+			let segmentName = segmentNames[i];
+			let segment = segmentMap[segmentName];
+			out_ary.push(segment.getId());
+			segment.getSubSegmentIds(out_ary);
+		}
+
+		return out_ary;
+	}
+	return null;
+};
+/** @public
+* @param {string} rid
+* @param {string=} dataId Row id for retrieving data
+* @return {boolean} Returns true only a new child is added
+*/
+Segment.prototype.addChild = function(rid, dataId) {
+	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(dataId != null) { // Update data id
+		if(dataId && dataId !== rid) {
+			if(!this._childDataIds) {
+				this._childDataIds = {};
+			}
+			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
+* @param {Array.<string>} rids
+* @param {Array.<string>=} dataIds Row ids for retrieving data
+* @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) {
+		dataIds = Array.isArray(dataIds) ? dataIds : [dataIds];
+		for(i = 0; i < rowCount; ++i) {
+			dirty |= this.addChild(rowIds[i], dataIds[i]);
+		}
+	} else {
+		for(i = 0; i < rowCount; ++i) {
+			dirty |= this.addChild(rowIds[i]);
+		}
+	}
+	return dirty ? true : false;
+};
+/** @public
+* @param {string} rid
+* @return {boolean}
+*/
+Segment.prototype.containsChild = function(rid) {
+	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._subSegment) {
+		return false; // Sub segments are not allowed to remove its children
+	}
+	if(!this._childIds.length) {
+		return false;
+	}
+	let at = this._childIds.indexOf(rid);
+	if(at < 0) {
+		return false; // The specified rid is not a child of this segment
+	}
+
+	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;
+	}
+	return true;
+};
+/** @public
+* @param {Array.<string>} rids
+* @return {boolean}
+*/
+Segment.prototype.removeChildren = function(rids) {
+	if(this._subSegment) {
+		return false; // Sub segments are not allowed to remove its children
+	}
+	if(!this._childIds.length) {
+		return false;
+	}
+	let rowIds = Array.isArray(rids) ? rids : [rids];
+	let rowCount = rowIds.length;
+	let dirty = 0;
+	for(let i = 0; i < rowCount; ++i) {
+		dirty |= this.removeChild(rowIds[i]);
+	}
+	return dirty ? true : false;
+};
+/** @public
+* @return {boolean}
+*/
+Segment.prototype.removeAllChildren = function() {
+	if(this._subSegment) {
+		return false; // Sub segments are not allowed to remove its children
+	}
+	let childCount = this._childIds.length;
+	if(!this._childIds.length) {
+		return false;
+	}
+	let segmentId = this._rid;
+	let objMap = this._shared.childToSegment;
+	let chdr = this._childIds;
+	for(let i = 0; i < childCount; ++i) {
+		let rid = chdr[i];
+		if(objMap[rid] === segmentId) {
+			delete objMap[rid];
+		}
+	}
+	this._childIds.length = 0;
+	this._childDataIds = null;
+
+	if(this._collapsed) {
+		this._shared.dirtyCollapsingState = true;
+	}
+	return true;
+};
+/** @public
+* @return {!Array.<string>}
+*/
+Segment.prototype.getChildIds = function() {
+	return this._childIds; // WARNING: Returns private members
+};
+/** @public
+* @return {!Object}
+*/
+Segment.prototype.getChildren = function() {
+	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._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>}
+*/
+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._subSegment) {
+		return false; // subsegment cannot be classified
+	}
+	let classifiers = null;
+	if(this._subSegDef) {
+		classifiers = this._subSegDef.classifiers;
+	}
+
+	let newClassifiers = null;
+	if(fields) {
+		if(typeof fields === "string") {
+			newClassifiers = [fields];
+		} else if(Array.isArray(fields)) {
+			newClassifiers = fields;
+		}
+	}
+	let i;
+	let fieldCount = newClassifiers ? newClassifiers.length : 0;
+
+	if(fieldCount) {
+		let 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.classifierChanged = true;
+		this._subSegDef = null; // WARNING: All subsegments 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) {
+	let classifiers = this._subSegDef ? this._subSegDef.classifiers : null;
+	let classifierCount = classifiers ? classifiers.length : 0;
+
+	let segmentNames = this._subSegNames;
+	let segmentCount = segmentNames ? segmentNames.length : 0;
+
+	if(!segmentCount) {
+		if(this._depth >= classifierCount) {
+			return false; // Current segment level is beyond existing classification level and this segment should already be removed
+		}
+	}
+
+	let sharedObj = this._shared;
+	if(this._collapsed) {
+		sharedObj.dirtyCollapsingState = true;
+	}
+
+	// Prepare existing subsegments for checking change in its members
+	let i;
+	let segmentName = "";
+	let nonExistenceGroups = {};
+	let removalCount = 0;
+	let segmentMap = this._subSegMap;
+	let segment = null;
+	if(segmentCount) {
+		removalCount = segmentCount;
+		for(i = 0; i < removalCount; ++i) {
+			segmentName = segmentNames[i];
+			nonExistenceGroups[segmentName] = 1;
+
+			segment = segmentMap[segmentName];
+			if(segment._childIds.length) { // Quick cleaning up
+				segment._childIds.length = 0;
+			}
+			if(segment._collapsed) {
+				sharedObj.dirtyCollapsingState = true;
+			}
+		}
+	}
+
+	// Loop through row children and assign them to their corresponding subsegment
+	let rootSegment = !this._subSegment;
+	let dataIds = this._childDataIds || {};
+	let rid;
+	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._depth];
+
+		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
+
+			sharedObj.childToSegment[rid] = this._rid; // Relocate child in case of it has been moved to a non existence group
+
+			segmentName = UNCATEGORY;
+			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
+				let subSegId = this._rid + "/" + segmentName;
+				segment = new Segment(subSegId, sharedObj);
+				segment._subSegDef = this._subSegDef;
+				segment._subSegment = true; // this indicates that the segment is autogenerated (subsegment)
+				segment._depth = this._depth + 1;
+				segment._subSegName = segmentName;
+				segment._subSegVal = val;
+				sharedObj.childToSegment[subSegId] = this._rid; // WARNING: this will mix autogenerated rows with actual rows
+
+				segmentMap[segmentName] = segment;
+				segmentNames.push(segmentName);
+
+				this._dispatch("subSegmentAdded", {
+					"rid": subSegId,
+					"segment": segment
+				});
+			}
+
+			segment.addChild(rid, dataId);
+		}
+	} 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 subsegments 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
+				let 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 subsegments
+	segmentCount = segmentNames ? segmentNames.length : 0;
+	if(segmentCount) {
+		segmentNames.sort(Segment._subSegSortLogic);
+		for(i = 0; i < segmentCount; ++i) {
+			segment = segmentMap[segmentNames[i]];
+			segment.classify(rows);
+		}
+	}
+
+	return true;
+};
+/** SubSegment implies being classified
+* @public
+* @return {boolean}
+*/
+Segment.prototype.hasSubSegments = function() {
+	if(this._subSegNames) {
+		return this._subSegNames.length ? true : false;
+	}
+	return false;
+};
+/** SubSegment implies autogenerated segment
+* @public
+* @return {boolean}
+*/
+Segment.prototype.isSubSegment = function() {
+	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() {
+	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 ancestor || null;
+};
+/** @public
+* @param {Array.<Segment>=} out_ary
+* @return {Array.<Segment>}
+*/
+Segment.prototype.getAllSubSegments = function(out_ary) {
+	let segmentNames = this._subSegNames;
+	if(segmentNames) {
+		if(!out_ary) {
+			out_ary = [];
+		}
+		let segmentMap = this._subSegMap;
+		let segmentCount = segmentNames.length;
+		for(let i = 0; i < segmentCount; ++i) {
+			let segment = segmentMap[segmentNames[i]];
+			out_ary.push(segment);
+			segment.getAllSubSegments(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
+* @param {number} rootOrder
+* @param {Object} ridMap Row id map that stores row order of the entire tree
+* @return {number} Last order of the segment
+*/
+Segment.prototype.updateTreeStructure = function(counter, rootOrder, ridMap) {
+	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(!rootOrder) {
+		rootOrder = 0;
+	}
+	if(!ridMap) {
+		ridMap = {};
+	}
+
+	let i;
+	let segmentNames = this._subSegNames;
+	let subSegmentCount = segmentNames ? segmentNames.length : 0;
+	if(subSegmentCount) { // Classified segment
+		let segmentMap = this._subSegMap;
+		for(i = 0; i < subSegmentCount; ++i) {
+			let subSegment = segmentMap[segmentNames[i]];
+			++counter;
+			ridMap[subSegment.getId()] = rootOrder + counter;
+			subSegment.setOrder(counter);
+			counter = subSegment.updateTreeStructure(counter, rootOrder, ridMap);
+		}
+	} else {
+		let childIds = this._childIds;
+		let childCount = childIds.length;
+		let segmentSeparators = this._shared.segments;
+		let prevSeg = "";
+		for(i = 0; i < childCount; ++i) {
+			let childId = childIds[i];
+			let childSegment = segmentSeparators[childId];
+			let segmentId = (childSegment) ? childSegment.getId() : UNCATEGORY;
+			if(prevSeg !== segmentId) {
+				++counter;
+				prevSeg = segmentId;
+			}
+			ridMap[childId] = rootOrder + counter;
+			if(childSegment) {
+				childSegment._depth = this._depth + 1;
+				childSegment.setOrder(counter);
+				counter = childSegment.updateTreeStructure(counter, rootOrder, ridMap);
+			}
+		}
+	}
+
+	return this.setLastOrder(counter);
+};
+/** Deprecated.
+* @ignore
+* @public
+* @function
+* @param {number} counter
+* @return {number}
+*/
+Segment.prototype.calcSubSegmentOrder = Segment.prototype.updateTreeStructure;
+/** @public
+* @return {number}
+*/
+Segment.prototype.getSegmentLevel = function() {
+	return this._depth;
+};
+/** This method will be called on subsegments only
+* @public
+* @param {Object=} rows
+* @param {Object=} clsSource
+*/
+Segment.prototype.setRowData = function(rows, clsSource) {
+	if(!rows) {
+		return;
+	}
+	let row = rows[this._rid];
+	if(!row) {
+		row = rows[this._rid] = {};
+	}
+
+	if(!clsSource) {
+		clsSource = rows;
+	}
+	row = clsSource[this._rid];
+	if(!row) {
+		row = clsSource[this._rid] = {};
+	}
+
+	let segment = this;
+	while(segment && segment.isSubSegment()) {
+		segment.getSubSegmentName(row);
+		segment = segment.getParent();
+	}
+};
+/** @public
+* @param {Object=} row
+* @return {string}
+*/
+Segment.prototype.getSubSegmentName = function(row) {
+	if(row && this._subSegment) {
+		let classifiers = this.getClassification();
+		let field = classifiers[this._depth - 1];
+		if(field) {
+			row[field] = this._subSegName;
+		}
+	}
+	return this._subSegName;
+};
+/**
+* @public
+* @param {!Function} comparer
+* @returns {boolean} Returns true if there is any change
+*/
+Segment.prototype.sortSegments = function(comparer) {
+	if(!comparer || this.hasSubSegments()) {
+		return false;
+	}
+
+	let childIds = this._childIds;
+	let childCount = childIds.length;
+	let segments = this._shared.segments;
+	for(let i = 0; i < childCount; ++i) {
+		if(segments[childIds[i]]) {
+			this._childIds.sort(comparer); // Perform segment sorting only if children have at least one segment
+			return true;
+		}
+	}
+
+	return false;
+};
+/** Get segment id and ids of children, including nested segments, but excluding sub segments
+* @public
+* @param {Array.<string>} ary
+* @return {!Array.<string>}
+*/
+Segment.prototype.getFlattenTreeIds = function(ary) {
+	if(!ary) {
+		ary = [];
+	}
+
+	if(!this._subSegment) { // Sub segments are excluded from tree
+		ary.push(this._rid);
+	}
+	let i;
+	let segmentNames = this._subSegNames;
+	if(segmentNames) { // Classified segment
+		let segmentCount = segmentNames.length;
+		let segmentMap = this._subSegMap;
+		for(i = 0; i < segmentCount; ++i) {
+			segmentMap[segmentNames[i]].getFlattenTreeIds(ary);
+		}
+	} else {
+		let childIds = this._childIds;
+		let childCount = childIds.length;
+		let segments = this._shared.segments;
+		for(i = 0; i < childCount; ++i) {
+			let childId = childIds[i];
+			let childSegment = segments[childId];
+			if(childSegment) {
+				childSegment.getFlattenTreeIds(ary);
+			} else {
+				ary.push(childId);
+			}
+		}
+	}
+
+	return ary;
+};
+
+/** @public
+* @param {boolean=} bool
+* @return {boolean}
+*/
+Segment.prototype.collapse = function(bool) {
+	bool = (bool !== false);
+	if(this._collapsed !== bool) {
+		this._collapsed = bool;
+		this.markCollapsingStateDirty();
+		return true;
+	}
+	return false;
+};
+/** @public
+* @param {boolean=} bool
+* @return {boolean}
+*/
+Segment.prototype.expand = function(bool) {
+	return this.collapse(bool === false);
+};
+/** @public
+* @return {boolean}
+*/
+Segment.prototype.isCollapsed = function() {
+	return this._collapsed;
+};
+/** 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 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 = {};
+	}
+	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(segment && segment.getCollapsingStates(objMap, childCollapsed)) {
+			dirty = true;
+		}
+	}
+	return dirty;
+};
+
+/** @public
+* @return {number}
+*/
+Segment.prototype.getOrder = function() {
+	let ancestor = this.getFirstAncestor();
+	if(ancestor) {
+		return ancestor._order + this._order;
+	}
+	return this._order; // This is root order
+};
+/** 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() {
+	let ancestor = this.getFirstAncestor();
+	if(ancestor) {
+		return ancestor.getLastOrder();
+	}
+	return this._order + this._offsetOrder; // This is root last order
+};
+/** @public
+* @param {number} val
+*/
+Segment.prototype.setOrder = function(val) {
+	this._order = val;
+};
+/** WARNING: This actually sets offset from the starting order
+* @public
+* @param {number} val
+* @returns {number} Returns the number set
+*/
+Segment.prototype.setLastOrder = function(val) {
+	return (this._offsetOrder = val); // WARNING: this._offsetOrder cannot be greater than 9999
+};
+
+/** @private
+* @type {Array.<string>}
+*/
+Segment._tabs = null;
+/** @public
+* @param {Array.<string>=} lines
+* @param {number=} tabLevel
+* @return {!Array.<string>} lines
+*/
+Segment.prototype.log = function(lines, tabLevel) {
+	if(!lines) {
+		lines = [];
+	}
+
+	let i;
+	let tabs = Segment._tabs;
+	if(!tabs) {
+		tabs = Segment._tabs = [];
+		let tabCh = "";
+		for(i = 0; i < 11; ++i) {
+			tabs[i] = tabCh;
+			tabCh += "  ";
+		}
+	}
+	if(!tabLevel) {
+		tabLevel = 0;
+	}
+
+	let collapsedCh = this._collapsed ? "+ " : "- ";
+	lines.push(tabs[tabLevel] + collapsedCh + this._rid);
+
+	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
+		}
+
+		if(segment) {
+			segment.log(lines, childLevel);
+		} else {
+			lines.push(childIndent + "- " + rid);
+		}
+	}
+	return lines;
+};
+
+
+export default Segment;
+export { Segment, UNCATEGORY };