@refinitiv-ui/efx-grid 6.0.0-next.0

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

@@ -0,0 +1,1317 @@
+import Ext from "../../../tr-grid-util/es6/Ext.js";
+import EventDispatcher from "../grid/event/EventDispatcher.js";
+
+/**
+ * Trigger when data within the table has been changed
+ * @event DataCache#dataChanged
+ * @property {boolean} globalChange Indicates a big change. User should expect all data has been change
+ * @property {string} type Type of changes. Possible values are "inserted", "removed", "updated", and undefined
+ * @property {string} rid Row Id
+ * @property {Object.<string, *>} rowData Column values of the changed row in JSON object format
+ */
+
+/**
+ * Trigger before DataCache#dataChanged. Perform any data update during the event will NOT cause more dataChanged events
+ * @event DataCache#dataComposed
+ */
+
+/**
+ * @constructor
+ * @extends {EventDispatcher}
+ */
+var DataCache = function () {
+	var _t = this;
+
+	_t._rows = {};
+	_t._subs = {};
+	_t._staticFields = {};
+	_t._onInsert = _t._onInsert.bind(_t);
+	_t._onUpdate = _t._onUpdate.bind(_t);
+	_t._onDelete = _t._onDelete.bind(_t);
+	_t._onBatchRequestADCData = _t._onBatchRequestADCData.bind(_t);
+	_t._onADCUpdate = _t._onADCUpdate.bind(_t);
+	_t._onADCError = _t._onADCError.bind(_t);
+	_t._onQ2DataChanged = _t._onQ2DataChanged.bind(_t);
+	_t._onQ2SubAdded = _t._onQ2SubAdded.bind(_t);
+	_t._onQ2SubRemoved = _t._onQ2SubRemoved.bind(_t);
+
+	_t._addEvent("dataComposed");
+	_t._addEvent("dataChanged");
+};
+Ext.inherits(DataCache, EventDispatcher);
+
+//#region Public
+/**
+ * @public
+ */
+DataCache.prototype.dispose = function () {
+	this.unlistenAll();
+	this.clearAllData(true);
+	this._quotes2 = null;
+};
+
+/**
+ * Deprecated. Built-in Data Service is deprecated due to the lack of flexibility. This API supports only Quotes2's "Subscriptions" object.
+ * @public
+ * @param {Object} subs Subscriptions object from JET.Quotes2
+ */
+DataCache.prototype.setSubscriptions = function (subs) {
+	if (this._quotes2) {
+		this._quotes2["removeEventListener"]("dataChanged", this._onQ2DataChanged);
+		this._quotes2["removeEventListener"]("subscriptionAdded", this._onQ2SubAdded);
+		this._quotes2["removeEventListener"]("subscriptionRemoved", this._onQ2SubRemoved);
+	}
+
+	this._quotes2 = subs;
+
+	if (this._quotes2) {
+		this._quotes2["addEventListener"]("dataChanged", this._onQ2DataChanged);
+		this._quotes2["addEventListener"]("subscriptionAdded", this._onQ2SubAdded);
+		this._quotes2["addEventListener"]("subscriptionRemoved", this._onQ2SubRemoved);
+	}
+};
+
+/**
+ * Deprecated. Built-in Data Service is deprecated due to the lack of flexibility.This API supports only Quotes2's
+ * "Subscriptions" object.
+ * @public
+ * @return {Object} subs Subscriptions object from JET.Quotes2
+ */
+DataCache.prototype.getSubscriptions = function () {
+	return this._quotes2;
+};
+
+/**
+ * Deprecated. Built-in Data Service is deprecated due to the lack of flexibility.
+ * @public
+ * @param {Object} sub Subscription object from JET.Quote
+ * @param {string=} opt_primaryRic Main RIC for creating Id or recalling subscription. This is because subscription
+ * object does not provide a way to access its data
+ * @param {Object=} opt_values Initial values
+ */
+DataCache.prototype.addSubscription = function (sub, opt_primaryRic, opt_values) {
+	if (this.getSubscription(sub["id"])) {
+		return;
+	}
+
+	var internalSub = {"s": sub, "rics": {}};
+
+	this._subs[sub["id"]] = internalSub;
+
+	if (!this._quotes2) {
+		sub["onNewRow"](this._onInsert);
+		sub["onUpdate"](this._onUpdate);
+		sub["onRemoveRow"](this._onDelete);
+	}
+
+	if (opt_primaryRic) {
+		internalSub["primary"] = opt_primaryRic;
+
+		if (!opt_values) {
+			opt_values = {};
+		}
+
+		this._onInsert(sub, opt_primaryRic, opt_values);
+	}
+};
+
+/**
+ * Deprecated. Built-in Data Service is deprecated due to the lack of flexibility.
+ * @public
+ * @param {Object} sub Subscription object from JET.Quote
+ */
+DataCache.prototype.removeSubscription = function (sub) { // All RICs associated to the subscription are removed
+	var subId = sub["id"];
+
+	if (!sub || !this._subs[subId]) {
+		return;
+	}
+
+	if (!this._quotes2) {
+		sub["stop"]();
+	}
+
+	var rics = this._subs[subId]["rics"];
+
+	for (var ric in rics) {
+		this.setRowData(subId + ric, null); // No subscription attached
+	}
+
+	delete this._subs[subId];
+};
+
+/**
+ * Deprecated. Built-in Data Service is deprecated due to the lack of flexibility.
+ * @public
+ */
+DataCache.prototype.startAllSubscriptions = function () {
+	if (this._quotes2) {
+		this._quotes2["start"]();
+	} else {
+		for (var key in this._subs) {
+			this._subs[key]["s"]["start"]();
+		}
+	}
+};
+
+/**
+ * Deprecated. Built-in Data Service is deprecated due to the lack of flexibility.
+ * @public
+ */
+DataCache.prototype.stopAllSubscriptions = function () {
+	if (this._quotes2) {
+		this._quotes2["stop"]();
+	} else {
+		for (var key in this._subs) {
+			this._subs[key]["s"]["stop"]();
+		}
+	}
+};
+
+/**
+ * @public
+ * @param {string} sub_id
+ * @return {Object} Subscription object from JET.Quote
+ */
+DataCache.prototype.getSubscription = function (sub_id) {
+	return (this._subs[sub_id]) ? this._subs[sub_id]["s"] : null;
+};
+
+/**
+ * @public
+ * @param {string} sub_id
+ * @return {string} ric that has been input when calling addSubscription
+ */
+DataCache.prototype.getPrimaryRic = function (sub_id) {
+	var subDef = this._subs[sub_id];
+	if (subDef) {
+		return subDef["primary"];
+	}
+	return "";
+};
+
+/**
+ * @public
+ * @param {boolean=} opt_suppressEvent
+ * @fires DataCache#dataChanged
+ */
+DataCache.prototype.clearAllData = function (opt_suppressEvent) { // All subscriptions are also removed
+	if (this._quotes2) {
+		this._quotes2["removeAllSubscriptions"]();
+	} else {
+		this.stopAllSubscriptions();
+	}
+
+	this._subs = {};
+	this._rows = {};
+
+	if (this._adcTimerId >= 0) {
+		clearTimeout(this._adcTimerId);
+		this._adcTimerId = -1;
+	}
+
+	this._adcRicMap = null;
+
+	if (!opt_suppressEvent) {
+		this._dispatchDataChange({"globalChange": true});
+	}
+};
+
+/**
+ * @public
+ * @param {Array.<string>|string} colId
+ * @param {boolean=} opt_suppressEvent
+ * @fires DataCache#dataChanged
+ */
+DataCache.prototype.clearColumnData = function (colId, opt_suppressEvent) {
+	var cids = (typeof colId === "string") ? [/** @type {string} */(colId)] : /** @type {Array.<string>} */(colId);
+
+	for (var i = cids.length; --i >= 0;) {
+		var cid = cids[i];
+
+		if (cid) {
+			for (var rid in this._rows) {
+				delete this._rows[rid][cid];
+			}
+		}
+	}
+
+	if (!opt_suppressEvent) {
+		this._dispatchDataChange({"globalChange": true});
+	}
+};
+
+/**
+ * @public
+ * @param {string} rid
+ * @param {string} cid
+ * @return {*}
+ */
+DataCache.prototype.getData = function (rid, cid) {
+	var row = this.getRowData(rid);
+
+	return (row) ? row[cid] : null;
+};
+
+/**
+ * Deprecated. Built-in Data Service is deprecated due to the lack of flexibility.
+ * @public
+ * @return {Object.<string, Array.<string>>} Map of Array of subscription object
+ */
+DataCache.prototype.getAllRics = function () { // Slow
+	var ricMap = {};
+
+	for (var subId in this._subs) {
+		var rics = this._subs[subId]["rics"];
+
+		for (var ric in rics) {
+			if (!ricMap[ric]) {
+				ricMap[ric] = [];
+			}
+
+			ricMap[ric].push(subId);
+		}
+	}
+
+	return ricMap; // No duplicate ric
+};
+
+/**
+ * @public
+ * @return {Array.<string>}
+ */
+DataCache.prototype.getAllRowIds = function () {
+	var rids = [];
+
+	for (var rid in this._rows) {
+		rids.push(rid);
+	}
+
+	return rids;
+};
+
+/**
+ * @public
+ * @param {string} rid ID of a row to be checked for its presence.
+ * @return {boolean} `true` if row was found, `false` if row was not found.
+ */
+DataCache.prototype.hasRowId = function (rid) {
+	return !!this._rows[rid];
+};
+
+/**
+ * @public
+ * @param {string} cid
+ * @return {!Array.<*>}
+ */
+DataCache.prototype.getColumnData = function (cid) {
+	var fieldRows = [];
+
+	for (var rid in this._rows) {
+		fieldRows.push(this._rows[rid][cid]);
+	}
+
+	return fieldRows;
+};
+
+/**
+ * @public
+ * @param {string} rid
+ * @return {Object.<string, *>}
+ */
+DataCache.prototype.getRowData = function (rid) {
+	return this._rows[rid] || null;
+};
+
+/**
+ * @public
+ * @param {Array.<string>} rids
+ * @param {number=} opt_from
+ * @param {number=} opt_to EXCLUSIVE
+ * @return {!Array.<Object>}
+ */
+DataCache.prototype.getMultipleRowData = function (rids, opt_from, opt_to) {
+	var len = rids.length;
+
+	if (opt_to == null) {
+		opt_to = len;
+	}
+
+	if (opt_to > len) {
+		opt_to = len;
+	}
+
+	if (!(opt_from > 0)) {
+		opt_from = 0;
+	}
+
+	var out_ary = new Array(len);
+	var rowMap = this._rows;
+
+	for (var i = opt_from; i < opt_to; ++i) {
+		out_ary[i] = rowMap[rids[i]] || null;
+	}
+
+	return out_ary;
+};
+
+/** Return a new copy of row data
+ * @public
+ * @return {!Array.<Object.<string, *>>}
+ */
+DataCache.prototype.getAllRowData = function () {
+	var rows = [];
+	var rowMap = this._rows;
+
+	for (var rid in rowMap) {
+		rows.push(rowMap[rid]);
+	}
+
+	return rows;
+};
+
+/**
+ * @public
+ * @param {string} rid Row Id
+ * @param {string} cid Column Id
+ * @param {*} value
+ * @return {boolean} Return true if there is any change, and false otherwise
+ * @fires DataCache#dataChanged
+ */
+DataCache.prototype.setData = function (rid, cid, value) { // Data changed event is always dispatched
+	var values = {};
+
+	values[cid] = value;
+
+	return this.setRowData(rid, values);
+};
+
+/**
+ * @public
+ * @param {string} rid
+ * @return {boolean}
+ */
+DataCache.prototype.hasDataCloudData = function (rid) {
+	if (!this._adcFields) {
+		return false;
+	}
+
+	var row = this.getRowData(rid);
+
+	if (!row) {
+		return false;
+	}
+
+	for (var i = this._adcFields.length; --i >= 0;) {
+		var data = row[this._adcFields[i]];
+
+		if (data != null) {
+			return true;
+		}
+	}
+
+	return false;
+};
+
+/**
+ * @public
+ * @param {string} rid Row Id
+ * @param {Object.<string, *>=} values Object where the key is column Id and value is the data to be set
+ * @param {Object=} opt_eventArg Additional arguments to be attached to the event fired
+ * @return {boolean} Return true if there is any change, and false otherwise
+ * @fires DataCache#dataChanged
+ */
+DataCache.prototype.setRowData = function (rid, values, opt_eventArg) { // Data changed event is always dispatched
+	var row = this.getRowData(rid);
+	var dirty = false;
+	var changes = null;
+
+	if (values) {
+		if (!row) {
+			row = values; // WARNING: Dangerous use of external reference. User may modify data without using DataCache's API
+
+			this._rows[rid] = row;
+			dirty = true;
+
+		} else {
+			for (var cid in values) {
+				row[cid] = values[cid];
+				dirty = true;
+			}
+
+			changes = values;
+		}
+	} else {
+		if (row) {
+			delete this._rows[rid];
+			dirty = true;
+		}
+	}
+
+	if (dirty && !this._composing) {
+		var e = opt_eventArg || {};
+
+		e["rid"] = rid;
+
+		if (changes) {
+			e["changes"] = changes;
+		}
+
+		e["rowData"] = row;
+
+		this._dispatchDataChange(e);
+	}
+
+	return dirty;
+};
+
+/**
+ * @public
+ * @param {string} rid
+ * @return {Object}
+ */
+DataCache.prototype.cloneRowData = function (rid) {
+	var fields = this._rows[rid];
+
+	if (!fields) {
+		return null;
+	}
+
+	var values = {};
+
+	for (var key in fields) {
+		if (key.indexOf("FREE_TEXT") === 0) { // TODO: This is not generic and will cause unintentional error. Also, it posts some performance penalty
+			continue; // Skip free text column
+		}
+
+		values[key] = fields[key];
+	}
+
+	return values;
+};
+
+/**
+ * Deprecated. Built-in Data Service is deprecated due to the lack of flexibility.
+ * @public
+ * @param {Array.<string>} fields
+ * @suppress {checkTypes}
+ */
+DataCache.prototype.addStaticFields = function (fields) {
+	if (!Array.isArray(fields)) {
+		return;
+	}
+
+	for (var i in fields) {
+		if (!this._staticFields[fields[i]]) {
+			this._staticFields[fields[i]] = 1;
+		} else {
+			this._staticFields[fields[i]]++;
+		}
+	}
+};
+
+/**
+ * Deprecated. Built-in Data Service is deprecated due to the lack of flexibility.
+ * @public
+ * @param {Array.<string>} fields
+ * @suppress {checkTypes}
+ */
+DataCache.prototype.removeStaticFields = function (fields) {
+	if (!Array.isArray(fields)) {
+		return;
+	}
+
+	for (var i in fields) {
+		if (this._staticFields[fields[i]]) {
+			this._staticFields[fields[i]]--;
+
+			if (this._staticFields[fields[i]] === 0) {
+				delete this._staticFields[fields[i]];
+			}
+		}
+	}
+};
+
+/**
+ * Deprecated. Built-in Data Service is deprecated due to the lack of flexibility.
+ * @public
+ */
+DataCache.prototype.resetStaticFields = function () {
+	this._staticFields = {};
+};
+
+/**
+ * Deprecated. Built-in Data Service is deprecated due to the lack of flexibility.
+ * @public
+ * @return {Object.<string, number>}
+ */
+DataCache.prototype.getStaticFields = function () {
+	return this._staticFields;
+};
+
+/**
+ * Construct a JSON object that is compatible with console.table()
+ * @public
+ * @param {Object=} options
+ * @return {!Array.<Object>} Return a JSON object that is compatible with console.table()
+ * @example
+ * var options = {
+ *   "colNames": Array.<string>,
+ *   "rowCount": number,
+ *   "startIndex": number,
+ *   "getter": function(Object, string):*,
+ *   "withRowIds": boolean
+ * };
+ */
+DataCache.prototype.dump = function (options) {
+	return DataCache.constructTable(this.getAllRowData(), options, Object.keys(this._rows));
+};
+
+/**
+ * Print current data and structure to console panel
+ * @public
+ * @param {Object=} opt_options
+ * @example
+ * var options = {
+ *   "colNames": Array.<string>,
+ *   "rowCount": number,
+ *   "startIndex": number,
+ *   "getter": function(Object, string):*,
+ *   "withRowIds": boolean
+ * };
+ */
+DataCache.prototype.log = function (opt_options) {
+	console.table(this.dump(opt_options));
+};
+
+//#region ADC
+/** Deprecated. Built-in Data Service is deprecated due to the lack of flexibility.
+ * @public
+ * @param {string} userId
+ * @param {string} productId
+ * @param {string} url
+ * @param {string=} opt_lang
+ */
+DataCache.prototype.setDataCloudSettings = function (userId, productId, url, opt_lang) {
+	if (userId != null) {
+		this._userId = userId;
+	}
+
+	if (productId != null) {
+		this._productId = productId;
+	}
+
+	if (url != null) {
+		this._adcUrl = url;
+	}
+
+	if (opt_lang) {
+		this._lang = opt_lang;
+	}
+};
+
+/**
+ * Deprecated. Built-in Data Service is deprecated due to the lack of flexibility.
+ * @public
+ * @return {Array.<string>}
+ */
+DataCache.prototype.getDataCloudFields = function () {
+	return this._adcFields; // Return private members
+};
+
+/**
+ * Deprecated. Built-in Data Service is deprecated due to the lack of flexibility.
+ * @public
+ * @param {Array.<string>|string} fields
+ * @return {boolean} Return true if success, and false otherwise
+ */
+DataCache.prototype.addDataCloudFields = function (fields) {
+	if (!this._adcFields) {
+		this._adcFields = [];
+		this._adcRefMap = {};
+	}
+
+	var newFields = [];
+
+	if (fields instanceof Array) {
+		for (var i = fields.length; --i >= 0;) {
+			this._addDataCloudField(fields[i], newFields);
+		}
+	} else {
+		this._addDataCloudField(/** @type {string} */(fields), newFields);
+	}
+
+	if (newFields.length <= 0) {
+		return false;
+	}
+
+	var ricMap = this.getAllRics();
+
+	this._batchRequestDataCloud(ricMap, newFields);
+
+	return true;
+};
+
+/**
+ * Deprecated. Built-in Data Service is deprecated due to the lack of flexibility.
+ * @public
+ * @param {string} field
+ * @return {boolean} Return true if success, and false otherwise
+ */
+DataCache.prototype.removeDataCloudField = function (field) {
+	if (!this._adcFields) {
+		return false;
+	}
+
+	if (!this._adcRefMap[field]) {
+		return false;
+	}
+
+	--this._adcRefMap[field];
+
+	if (!this._adcRefMap[field]) {
+		var foundAt = this._adcFields.indexOf(field);
+
+		this._adcFields.splice(foundAt, 1);
+		this.clearColumnData(field);
+	}
+
+	return true;
+};
+//#endregion ADC
+//#endregion Public
+
+/**
+ * @protected
+ * @ignore
+ * @param {!Object} e
+ * @fires DataTable#dataComposed
+ * @fires DataTable#dataChanged
+ */
+DataCache.prototype._dispatchDataChange = function (e) {
+	if (this._composing) {
+		return;
+	}
+
+	this._composing = true;
+	this._dispatch("dataComposed", e);
+	this._composing = false;
+	this._dispatch("dataChanged", e);
+};
+
+/**
+ * @private
+ * @param {string} propertyName
+ * @param {Object} rowData
+ * @param {string} colName
+ * @return {*}
+ */
+DataCache._defaultPropertyGetter = function (propertyName, rowData, colName) {
+	var d = rowData[colName];
+
+	return d ? d[propertyName] : null;
+};
+
+/**
+ * @private
+ * @param {Object} rowData
+ * @param {string} colName
+ * @return {*}
+ */
+DataCache._defaultGetter = function (rowData, colName) {
+	return rowData[colName];
+};
+
+
+/** Construct a JSON object that is compatible with console.table()
+ * @public
+ * @ignore
+ * @param {!Array.<Object>} dataset
+ * @param {Object=} opt_options { "rowCount": number,  "colNames": Array.<string>,  "getter": function(Object, string):*, startIndex: number, "withRowIds": boolean }
+ * @param {Array.<string>=} opt_rowIds Optional row ids corresponding to the given dataset
+ * @return {!Array.<Object>} Return a JSON object that is compatible with console.table()
+ */
+DataCache.constructTable = function (dataset, opt_options, opt_rowIds) {
+	var startIndex = 0;
+	var rLen = dataset.length;
+	var rowLim = rLen;
+	var colMap = null;
+	var rids = opt_rowIds || null;
+	var getter = DataCache._defaultGetter;
+	var transformation = false;
+
+	if (opt_options) {
+		if (opt_options["rowCount"]) {
+			rowLim = opt_options["rowCount"];
+			transformation = true;
+		}
+
+		if (opt_options["colNames"]) {
+			colMap = {};
+
+			var len = opt_options["colNames"].length;
+
+			for (var i = 0; i < len; ++i) {
+				colMap[opt_options["colNames"][i]] = true;
+			}
+
+			transformation = true;
+		}
+
+		if (opt_options["getter"]) {
+			if (typeof opt_options["getter"] == "string") {
+				getter = DataCache._defaultPropertyGetter.bind(null, opt_options["getter"]);
+			} else { // Function
+				getter = opt_options["getter"];
+			}
+
+			transformation = true;
+		}
+
+		if (opt_options["startIndex"]) {
+			startIndex = /** @type{number} */(opt_options["startIndex"]);
+			transformation = true;
+		}
+
+		if (opt_options["withRowIds"] === false) {
+			rids = null;
+		}
+	}
+
+	if (!transformation && !rids) {
+		return dataset; // The dataset is already compatible with console.table
+	}
+
+	var rows = [];
+
+	for (var r = startIndex; r < rLen; ++r) {
+		if (rows.length >= rowLim) {
+			break;
+		}
+
+		var rowData = dataset[r];
+		var columns = (rids) ? {"rid": rids[r]} : {};
+
+		if (rowData) { // Header and footer don't have any row data
+			var colName;
+
+			if (colMap) {
+				for (colName in colMap) {
+					if (rowData[colName] != null) {
+						columns[colName] = getter(rowData, colName);
+					}
+				}
+			} else {
+				for (colName in rowData) {
+					columns[colName] = getter(rowData, colName);
+				}
+			}
+		}
+
+		rows.push(columns);
+	}
+
+	return rows;
+};
+
+
+//#region Private
+/**
+ * For Quotes2 only
+ * @private
+ * @param {string} subId
+ * @param {string} ric
+ * @param {Object.<string, *>} values
+ */
+DataCache.prototype._insertRic = function (subId, ric, values) {
+	// HACK: Some chain may have 0# symbol in there chain index (e.g. 0#CL:)
+	ric = ric.replace("0#", "");
+
+	var rid = subId + ric;
+
+	// We cannot cache event arguments because user may want to collect all the updates
+	this._onADCForNewRic(subId, ric);
+
+	if (!this.getRowData(rid)) { // Ensure that we have subscription id and ric from Quotes2
+		var tmp = values;
+
+		values = {}; // Clone a new object for duplicated ric
+
+		for (var key in tmp) { // Slow
+			values[key] = tmp[key];
+		}
+
+		values["SUB_ID"] = subId;
+		values["RIC"] = ric;
+	}
+
+	this.setRowData(rid, values);
+};
+
+/**
+ * @private
+ * @param {Object} e
+ */
+DataCache.prototype._onQ2DataChanged = function (e) {
+	var subId = e["subId"];
+	var ric = e["ric"];
+	var values = /** @type{Object.<string, *>} */(e["values"]);
+
+	if (values) {
+		this._insertRic(subId, ric, values);
+	} else { // Remove ric
+		delete this._subs[subId]["rics"][ric];
+
+		this.setRowData(subId + ric, null);
+	}
+};
+
+/**
+ * @private
+ * @param {Object} e
+ */
+DataCache.prototype._onQ2SubAdded = function (e) {
+	var subs = e["subs"];
+	var duplicateSubIds = e["duplicateSubIds"];
+	var len = subs.length;
+
+	for (var i = 0; i < len; ++i) {
+		var sub = subs[i];
+		var ric = sub["ric"];
+
+		this.addSubscription(sub, ric);
+
+		if (duplicateSubIds) { // There will be no network request for duplicate subs, and hence we need to update the data from our cache
+			var dupSubId = duplicateSubIds[i];
+
+			if (dupSubId) {
+				window.setTimeout(
+					this._onDuplicateRic.bind(this, sub["id"], this.getRowData(dupSubId + ric)),
+					10);
+			}
+		}
+	}
+};
+
+/**
+ * @private
+ * @param {Object} e
+ */
+DataCache.prototype._onQ2SubRemoved = function (e) {
+	var subs = e["subs"];
+	var len = subs.length;
+
+	for (var i = 0; i < len; ++i) {
+		var sub = subs[i];
+		this.removeSubscription(sub);
+	}
+};
+
+/**
+ * @private
+ * @param {string} subId Subscription id
+ * @param {string} ric
+ */
+DataCache.prototype._onADCForNewRic = function (subId, ric) {
+	var sub = this._subs[subId];
+
+	if (!sub) {
+		return;
+	}
+
+	if (this._adcFields) {
+		if (!sub["rics"][ric]) { // First time insertion
+			if (this._adcTimerId < 0) {
+				this._adcRicMap = {};
+				this._adcTimerId = setTimeout(this._onBatchRequestADCData, 100);
+			}
+
+			if (!this._adcRicMap[ric]) {
+				this._adcRicMap[ric] = [];
+			}
+
+			this._adcRicMap[ric].push(subId);
+		}
+	}
+
+	sub["rics"][ric] = true;
+};
+
+/**
+ * @private
+ * @param {string} subId
+ * @param {Object.<string, *>} dupData
+ */
+DataCache.prototype._onDuplicateRic = function (subId, dupData) {
+	var sub = this._subs[subId];
+
+	if (!sub) {
+		return;
+	}
+
+	sub = sub["s"]; // Quotes2' subscription
+
+	var ric = sub["ric"];
+	var dupSubId = /** @type{string} */(dupData["SUB_ID"]);
+	var values = this._cloneRowData(dupData, ric, subId);
+
+	if (!values) {
+		return;
+	}
+
+	this._onInsert(sub, ric, values);
+
+	var children = sub["children"];
+
+	if (children) {
+		var childCount = children.length;
+
+		for (var i = 0; i < childCount; ++i) {
+			ric = children[i];
+			values = this._cloneRowData(dupSubId, ric, subId);
+
+			this._onInsert(sub, ric, values); // TODO: This makes a lot of ADC request
+		}
+	}
+};
+
+/**
+ * @private
+ * @param {Object} sub Subscription object from JET.Quote
+ * @param {string} ric
+ * @param {Object.<string, *>} values
+ */
+DataCache.prototype._onInsert = function (sub, ric, values/*, rowN*/) {
+	var subId = sub["id"];
+
+	if (this._quotes2) {
+		this._insertRic(subId, ric, values);
+	} else {
+		this._onADCForNewRic(subId, ric);
+		this.setRowData(subId + ric, values, {"subscription": sub, "ric": ric});
+	}
+};
+
+/**
+ * @private
+ * @function
+ */
+DataCache.prototype._onUpdate = DataCache.prototype._onInsert;
+
+/**
+ * This is a legacy code and should be deprecated
+ * @private
+ * @param {Object} sub Subscription object from JET.Quote
+ * @param {string} ric
+ * @param {Array.<string, *>} values
+ */
+DataCache.prototype._onDelete = function (sub, ric, values/*, rowN*/) {
+	delete this._subs[sub["id"]]["rics"][ric];
+
+	// We cannot cache event arguments because user may want to collect all the updates
+	this.setRowData(sub["id"] + ric, null, {"subscription": sub, "ric": ric});
+};
+
+/**
+ * @private
+ * @param {string} field
+ * @param {Array.<string>} ary_out
+ */
+DataCache.prototype._addDataCloudField = function (field, ary_out) {
+	if (!this._adcRefMap[field]) {
+		this._adcFields.push(field);
+
+		ary_out.push(field);
+
+		this._adcRefMap[field] = 1;
+	} else {
+		++this._adcRefMap[field];
+	}
+};
+
+/**
+ * @private
+ * @param {Object} e
+ * @suppress {missingProperties}
+ */
+DataCache.prototype._onADCUpdate = function (e) {
+	var xhr = e["currentTarget"]; // XMLHttpRequest
+	var resp = null;
+
+	try {
+		resp = JSON.parse(xhr.responseText);
+		// window.console.log("Successfully parse: " + resp.rows);
+	} catch (err) {
+		return;
+	}
+
+	if (resp["status"] !== "Ok") {
+		return;
+	}
+
+	var colCount = resp["cols"];
+	var rows = resp["rows"];
+	var colDefs = rows[0]; // The first row is always the column definition
+	var ricIndex = -1;
+	var fieldIndices = {};
+
+	for (var i = 0; i < colCount; ++i) {
+		var colDef = colDefs[i];
+
+		if (colDef["i"] === "instrument") {
+			ricIndex = i;
+		} else if (colDef["r"]) {
+			fieldIndices[colDef["r"]] = i;
+		}
+	}
+
+	var rowCount = rows.length;
+
+	for (var j = 1; j < rowCount; ++j) { // Start from 1
+		var row = rows[j];
+		var ric = row[ricIndex];
+		var values = {};
+
+		for (var field in fieldIndices) {
+			var value = row[fieldIndices[field]];
+
+			if (value != null) {
+				// Data should be merged from the backend.
+				// Don't override data with null value.
+				// TODO: Merge all the row into one single row
+				if (value !== null && value["f"] == null) {
+					if (this._quotes2) {
+						values[field] = value;
+						values[field + "_FORMATTED"] = value;
+					} else {
+						values[field] = {"formatted": value + "", "raw": value};
+					}
+				}
+			}
+		}
+
+		var subIds = xhr.ricMap[ric];
+
+		if (subIds) { // Only ric within the subscription can be updated
+			for (i = subIds.length; --i >= 0;) {
+				var subId = subIds[i];
+
+				if (this._subs[subId]) { // Only update the existing subscription
+					// window.console.log("ADC update " + subId + ric + " with " + JSON.stringify(values));
+					this.setRowData(subId + ric, values); // Event is fired
+				}
+			}
+		}
+	}
+};
+
+/**
+ * @private
+ * @param {Object} e
+ */
+DataCache.prototype._onADCError = function (e) {
+	window.console.log(e);
+};
+
+/**
+ * @private
+ * @param {Object} e
+ */
+DataCache.prototype._onBatchRequestADCData = function (e) {
+	if (this._adcTimerId <= 0) {
+		return;
+	}
+
+	this._adcTimerId = -1;
+	this._batchRequestDataCloud(this._adcRicMap, this._adcFields);
+	this._adcRicMap = null;
+};
+
+/**
+ * @private
+ * @param {Object.<string, Array.<string>>} ricMap of Array of subscription object
+ * @param {Array.<string>} fields
+ * @return {XMLHttpRequest}
+ */
+DataCache.prototype._batchRequestDataCloud = function (ricMap, fields) {
+	if (!this._adcUrl) {
+		return null;
+	}
+
+	var rics = [];
+
+	for (var ric in ricMap) {
+		rics.push(ric);
+	}
+
+	// Request data cloud in small multiple batches because the service cannot handle a long request
+	while (rics.length > 30) {
+		this._requestDataCloud(ricMap, fields, rics.splice(0, 30));
+	}
+
+	return this._requestDataCloud(ricMap, fields, rics);
+};
+
+/**
+ * @private
+ * @param {Object.<string, Array.<string>>} ricMap of Array of subscription object
+ * @param {Array.<string>} fields
+ * @param {Array.<string>} rics
+ * @return {XMLHttpRequest}
+ */
+DataCache.prototype._requestDataCloud = function (ricMap, fields, rics) { // Small batch
+	if (!rics || rics.length <= 0) {
+		return null;
+	}
+
+	if (!fields || fields.length <= 0) {
+		return null;
+	}
+
+	var xhr = new XMLHttpRequest();
+
+	xhr.onload = this._onADCUpdate;
+	xhr.onerror = this._onADCError;
+	xhr.ricMap = ricMap;
+
+	xhr.open("POST", this._adcUrl, true);
+	xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
+
+	var body = 'formula=' + fields + '&identifiers=' + rics;
+
+	// window.console.log("ADC is requested with " + body);
+	if (this._productId) {
+		body += '&productid=' + this._productId;
+	}
+
+	if (this._userId) {
+		body += '&uuid=' + this._userId;
+	}
+
+	if (this._lang) {
+		body += '&lang=' + this._lang;
+	}
+
+	xhr.send(body);
+
+	return xhr;
+};
+
+/**
+ * @private
+ * @param {string|Object.<string, *>} obj
+ * @param {string} ric
+ * @param {string} newSubId
+ * @return {Object}
+ */
+DataCache.prototype._cloneRowData = function (obj, ric, newSubId) {
+	var subId = (typeof obj === "string") ? obj : obj["SUB_ID"];
+	var fields = this._rows[subId + ric];
+
+	if (!fields) { // The specified row has been removed
+		if (typeof obj === "object") {
+			fields = obj;
+		} else {
+			return null;
+		}
+	}
+
+	var values = {};
+
+	for (var key in fields) {
+		if (this._staticFields[key] == null) { // Static field must not be cloned
+			values[key] = fields[key];
+		}
+	}
+
+	values["SUB_ID"] = newSubId;
+
+	return values;
+};
+
+/** @protected
+ * @ignore
+ * @type {!Object.<string, Object.<string, *>>}
+ */
+DataCache.prototype._rows;
+
+/**
+ * @private
+ * @type {!Object.<string, Object>}
+ */
+DataCache.prototype._subs;
+
+/**
+ * @private
+ * @type {Object}
+ */
+DataCache.prototype._quotes2 = null;
+
+/**
+ * @private
+ * @type {Object.<string, number>}
+ */
+DataCache.prototype._staticFields = null;
+
+//#region ADC
+/**
+ * @private
+ * @type {Array.<string>}
+ */
+DataCache.prototype._adcFields = null;
+
+/**
+ * @private
+ * @type {Object.<string, number>}
+ */
+DataCache.prototype._adcRefMap = null;
+
+/**
+ * @private
+ * @type {number}
+ */
+DataCache.prototype._adcTimerId = -1;
+
+/**
+ * @private
+ * @description ricMap of Array of subscription object
+ * @type {Object.<string, Array.<string>>}
+ */
+DataCache.prototype._adcRicMap = null;
+
+/**
+ * @private
+ * @type {string}
+ */
+DataCache.prototype._adcUrl = "/datacloud/rest/select";
+
+/**
+ * @private
+ * @type {string}
+ */
+DataCache.prototype._userId = "";
+
+/**
+ * @private
+ * @type {string}
+ */
+DataCache.prototype._productId = "";
+
+/** @protected
+ * @ignore
+ * @type {boolean}
+ */
+DataCache.prototype._composing = false;
+
+/** @protected
+ * @ignore
+ * @type {string}
+ */
+DataCache.prototype._lang = "";
+//#endregion ADC
+//#endregion Private
+
+DataCache._proto = DataCache.prototype;
+
+export default DataCache;
+export { DataCache };