@magic-xpa/engine 4.1100.0-dev4110.19 → 4.1100.0-dev4110.190

package/esm2022/src/data/Record.mjs

@@ -0,0 +1,866 @@
+import { DataModificationTypes, EMPTY_DCREF, ExpVal, ObjectReferenceBase, ObjectReferencesCollection, RecordUtils } from '@magic-xpa/gui';
+import { ApplicationException, Int32, ISO_8859_1_Encoding, NNumber, NString, RefParam, StringBuilder, isNullOrUndefined } from '@magic-xpa/mscorelib';
+import { Base64, Constants, Logger, StorageAttribute, StorageAttributeCheck, StrUtil, UtilStrByteMode, XMLConstants, XmlParser } from '@magic-xpa/utils';
+import { ExpressionEvaluator, NullValueException } from '../exp/ExpressionEvaluator';
+import { ConstInterface } from '../ConstInterface';
+import { Environment } from '../env/Environment';
+import { DataViewBase } from './DataViewBase';
+import { RemoteCommandsProcessor } from "../remote/RemoteCommandsProcessor";
+export class Record {
+    static FLAG_NULL = (0x01);
+    static FLAG_INVALID = (0x02);
+    static FLAG_MODIFIED = (0x04);
+    static FLAG_UPDATED = (0x08);
+    static FLAG_CRSR_MODIFIED = (0x10);
+    static FLAG_VALUE_NOT_PASSED = (0x20);
+    static FLAG_MODIFIED_ATLEAST_ONCE = (0x40);
+    _id = Int32.MinValue;
+    dbViewRowIdx = 0;
+    _mode = DataModificationTypes.None;
+    _dcRefs = null;
+    _inCompute = false;
+    _inRecompute = false;
+    _newRec = false;
+    get InCompute() {
+        return this._inCompute;
+    }
+    get InRecompute() {
+        return this._inRecompute;
+    }
+    static INCREASE = true;
+    static DECREASE = false;
+    _tableCache;
+    _inDeleteProcess;
+    _addAfter;
+    _causeInvalidation;
+    _dbPosBase64Val;
+    _dataview = null;
+    _fieldsData;
+    _flags;
+    _flagsHistory;
+    _forceSaveOrg;
+    _hashKey;
+    _computed;
+    _lateCompute;
+    _linksFldsPos;
+    _modified;
+    _next;
+    _prev;
+    _sendToServer = true;
+    _updated;
+    InForceUpdate;
+    Synced;
+    ValueInBase64;
+    constructor(dvOrTableCacheOrCIdOrRecord, dataview) {
+        if (dvOrTableCacheOrCIdOrRecord instanceof Record)
+            Object.assign(this, dvOrTableCacheOrCIdOrRecord);
+        else if (arguments.length === 1)
+            this.constructor_0(dvOrTableCacheOrCIdOrRecord);
+        else
+            this.constructor_1(dvOrTableCacheOrCIdOrRecord, dataview);
+    }
+    constructor_0(dvOrTableCache) {
+        if (dvOrTableCache instanceof DataViewBase)
+            this._dataview = dvOrTableCache;
+        else
+            this._tableCache = dvOrTableCache;
+        this._fieldsData = new Array(this.getFieldsTab().getSize());
+        this._flags = new Uint8Array(this.getFieldsTab().getSize());
+        this._flagsHistory = new Uint8Array(this.getFieldsTab().getSize());
+        this._dcRefs = new ObjectReferencesCollection();
+    }
+    Initialize() {
+        for (let i = 0; i < this._flags.length; i = i + 1) {
+            let field = this.getFieldsTab().getField(i);
+            this._flags[i] = ((field.isNullDefault() || field.getType() === StorageAttribute.BLOB_VECTOR) ? Record.FLAG_NULL : 0);
+            if (this._dataview !== null && field.IsVirtual) {
+                let record = this._dataview.getCurrRec();
+                if (record != null && record.IsFldModifiedAtLeastOnce(i)) {
+                    this.setFlag(i, Record.FLAG_MODIFIED_ATLEAST_ONCE);
+                }
+            }
+            this._flagsHistory[i] = this._flags[i];
+        }
+        this.setNewRec();
+    }
+    constructor_1(cId, dataview) {
+        this.constructor_0(dataview);
+        this.setId(cId);
+    }
+    get Modified() {
+        return this._modified;
+    }
+    get Updated() {
+        return this._updated;
+    }
+    get SendToServer() {
+        return this._sendToServer;
+    }
+    CompareTo(obj) {
+        let res = 0;
+        let compTo = obj;
+        let key = this._tableCache.GetKeyById(this._tableCache.GetCurrSortKey());
+        if (key != null) {
+            for (let i = 0; i < key.Columns.length; i++) {
+                let currFld = key.Columns.get_Item(i);
+                let currFldId = currFld.getId();
+                if (this.IsNull(currFldId) && compTo.IsNull(currFldId))
+                    continue;
+                else if (this.IsNull(currFldId) && !compTo.IsNull(currFldId)) {
+                    res = 1;
+                    break;
+                }
+                else if (!this.IsNull(currFldId) && compTo.IsNull(currFldId)) {
+                    res = -1;
+                    break;
+                }
+                else {
+                    try {
+                        let first = new ExpVal(currFld.getType(), false, this.GetFieldValue(currFldId));
+                        let second = new ExpVal(currFld.getType(), false, compTo.GetFieldValue(currFldId));
+                        res = ExpressionEvaluator.val_cmp_any(first, second);
+                        if (res !== 0)
+                            break;
+                    }
+                    catch (err) {
+                        if (err instanceof NullValueException)
+                            Logger.Instance.WriteExceptionToLogWithMsg(" in Record.CompareTo null value was reached");
+                    }
+                }
+            }
+            return res;
+        }
+        else {
+            res = -1;
+            return res;
+        }
+    }
+    getMode() {
+        return this._mode;
+    }
+    getId() {
+        return this._id;
+    }
+    isNewRec() {
+        return this._newRec;
+    }
+    getFieldDataXML(fldIdx, getOldVal) {
+        let fldVal;
+        if (!getOldVal)
+            fldVal = this.GetFieldValue(fldIdx);
+        else
+            fldVal = (this.getFieldsTab().getField(fldIdx)).getOriginalValue();
+        if (fldVal == null)
+            throw new ApplicationException("in Record.buildFieldsData() null field value!\nField id: " + fldIdx);
+        let tmpBuf = this.getXMLForValue(fldIdx, fldVal);
+        return XmlParser.escape(tmpBuf.toString()).toString();
+    }
+    getFieldsTab() {
+        if (this._dataview !== null)
+            return this._dataview.GetFieldsTab();
+        else
+            return this._tableCache.FldsTab;
+    }
+    setInitialFldVals(clobberedOnly, isNewRec) {
+        let i, size;
+        let fld = null;
+        size = this.getSizeFld(true);
+        for (i = 0; i < size; i++) {
+            if (this._fieldsData[i] === null || typeof this._fieldsData[i] === "undefined") {
+                fld = this.getFieldsTab().getField(i);
+                this._fieldsData[i] = fld.getNewRecValue(clobberedOnly);
+                if (isNewRec && fld.IsVirtual && !fld.isNull())
+                    this.clearFlag(fld.getId(), Record.FLAG_NULL);
+                if (fld.IsVirtual && fld.getModifiedAtLeastOnce())
+                    this.setFlag(fld.getId(), Record.FLAG_MODIFIED_ATLEAST_ONCE);
+                if (this._fieldsData[i] === null || typeof this._fieldsData[i] === "undefined")
+                    this._fieldsData[i] = fld.getDefaultValue();
+            }
+        }
+    }
+    setId(cId) {
+        this._id = cId;
+        this._hashKey = this._id;
+    }
+    setDBViewRowIdx(rowId) {
+        this.dbViewRowIdx = rowId;
+    }
+    getDBViewRowIdx() {
+        return this.dbViewRowIdx;
+    }
+    fillData(parser) {
+        let isCurrRec = false;
+        let endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());
+        if (endContext !== -1 && endContext < parser.getXMLdata().length) {
+            let tag = parser.getXMLsubstring(endContext);
+            parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_REC) + ConstInterface.MG_TAG_REC.length);
+            let tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            isCurrRec = this.initElements(tokensVector);
+            parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length);
+        }
+        else
+            Logger.Instance.WriteExceptionToLogWithMsg("in Record.FillInnerData() out of bounds");
+        return isCurrRec;
+    }
+    initElements(tokensVector) {
+        let attribute, valueStr;
+        let recFieldsData = null;
+        let recFlags = null;
+        let j = 0;
+        let isCurrRec;
+        isCurrRec = this.peekIsCurrRec(tokensVector);
+        for (; j < tokensVector.length; j += 2) {
+            attribute = (tokensVector.get_Item(j));
+            valueStr = (tokensVector.get_Item(j + 1));
+            switch (attribute) {
+                case ConstInterface.MG_ATTR_MODE:
+                    this._mode = valueStr[0];
+                    break;
+                case XMLConstants.MG_ATTR_ID:
+                    this.setId(XmlParser.getInt(valueStr));
+                    break;
+                case XMLConstants.MG_ATTR_VB_VIEW_ROWIDX:
+                    this.setDBViewRowIdx(XmlParser.getInt(valueStr));
+                    break;
+                case XMLConstants.MG_ATTR_VALUE:
+                    if (this.ValueInBase64) {
+                        recFieldsData = Base64.decode(valueStr);
+                    }
+                    else {
+                        recFieldsData = XmlParser.unescape(valueStr);
+                    }
+                    break;
+                case ConstInterface.MG_ATTR_CURR_REC:
+                    {
+                    }
+                    break;
+                case ConstInterface.MG_ATTR_ADD_AFTER:
+                    this._addAfter = XmlParser.getInt(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_FLAGS:
+                    recFlags = valueStr;
+                    break;
+                case ConstInterface.MG_ATTR_MODIFIED:
+                    this._modified = true;
+                    break;
+                case ConstInterface.MG_ATTR_DC_REFS:
+                    this.fillDCRef(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_DBPOS:
+                    this._dbPosBase64Val = valueStr;
+                    break;
+                default:
+                    Logger.Instance.WriteExceptionToLogWithMsg("in Record.initElements() unknown attribute: " + attribute);
+                    break;
+            }
+        }
+        if (this.ValueInBase64) {
+            let fldValInBytes = ISO_8859_1_Encoding.ISO_8859_1.GetBytes(recFieldsData);
+            this.fillFieldsData(fldValInBytes, recFlags);
+        }
+        else {
+            this.fillFieldsData(recFieldsData, recFlags, isCurrRec);
+        }
+        return isCurrRec;
+    }
+    peekIsCurrRec(tokensVector) {
+        let attribute;
+        let valueStr;
+        for (let j = 0; j < tokensVector.length; j += 2) {
+            attribute = (tokensVector.get_Item(j));
+            if (attribute === ConstInterface.MG_ATTR_CURR_REC) {
+                valueStr = (tokensVector.get_Item(j + 1));
+                return XmlParser.getBoolean(valueStr);
+            }
+        }
+        return false;
+    }
+    fillFieldsData(fldValInBytesOrFldsVal, recFlags, isCurrRec) {
+        if (isNullOrUndefined(isCurrRec))
+            this.fillFieldsData_0();
+        else
+            this.fillFieldsData_1(fldValInBytesOrFldsVal, recFlags, isCurrRec);
+    }
+    fillFieldsData_0() {
+    }
+    fillFieldsData_1(fldsVal, recFlags, isCurrRec) {
+        let val = null;
+        let tmp = null;
+        let parsedLen = new RefParam(0);
+        let i, j = 0, from, size;
+        let currType;
+        let useHex;
+        let fld = null;
+        let valueNotPassed;
+        from = this.getFromFldIdx(isCurrRec);
+        size = this.getSizeFld(isCurrRec);
+        for (i = from; j < size; i++, j++) {
+            fld = this.getFieldsTab().getField(i);
+            currType = fld.getType();
+            useHex = (Environment.Instance.GetDebugLevel() > 1 ||
+                currType === StorageAttribute.ALPHA ||
+                currType === StorageAttribute.UNICODE ||
+                StorageAttributeCheck.isTypeLogical(currType));
+            if (recFlags[j] === '.')
+                this._flags[i] = 0;
+            else if (recFlags[j] === '/')
+                this._flags[i] = 1;
+            else {
+                tmp = recFlags.substr(j * 2, 2);
+                this._flags[i] = parseInt(tmp, 16);
+            }
+            valueNotPassed = Record.FLAG_VALUE_NOT_PASSED === (this._flags[i] & Record.FLAG_VALUE_NOT_PASSED);
+            this._flags[i] = this._flags[i] & ~Record.FLAG_VALUE_NOT_PASSED;
+            this._flagsHistory[i] = this._flags[i];
+            if (Record.FLAG_UPDATED === (this._flags[i] & Record.FLAG_UPDATED))
+                this._updated = true;
+            if (valueNotPassed) {
+                if (Record.FLAG_NULL === (this._flags[i] & Record.FLAG_NULL)) {
+                    val = fld.getDefaultValue();
+                }
+                else {
+                    val = this._dataview.getCurrRec().GetFieldValue(i);
+                }
+            }
+            else {
+                val = RecordUtils.deSerializeItemVal(fldsVal, currType, fld.getSize(), useHex, fld.getCellsType(), parsedLen);
+                fldsVal = fldsVal.substr(parsedLen.value);
+            }
+            this._fieldsData[i] = val;
+        }
+        this.setInitialFldVals(false, false);
+    }
+    fillDCRef(valueStr) {
+        if (!NString.IsNullOrEmpty(valueStr)) {
+            let couples = StrUtil.tokenize(valueStr, "$");
+            let size = couples.length;
+            for (let i = 0; i < size; i = i + 1) {
+                this._dcRefs.Add(DcValuesReference.Parse(couples[i], this._dataview));
+            }
+        }
+    }
+    buildFieldsData(message, isCurrRec, getOldVal) {
+        let tmpStr = new StringBuilder();
+        let from = this.getFromFldIdx(isCurrRec);
+        let size = this.getSizeFld(isCurrRec);
+        for (let i = from; i < from + size; i = i + 1) {
+            let fld = this.getFieldsTab().getField(i);
+            if (fld.IsExposedToClient === false)
+                this.setShrinkFlag(i);
+            if (Record.FLAG_VALUE_NOT_PASSED === (this._flags[i] & Record.FLAG_VALUE_NOT_PASSED))
+                continue;
+            tmpStr.Append(this.getFieldDataXML(i, getOldVal).toString());
+        }
+        if (tmpStr.Length === 0) {
+            tmpStr.Append(" ");
+        }
+        message.Append(tmpStr.ToString());
+    }
+    getXMLForValue(fldIdx, fldVal) {
+        let cellAttr = StorageAttribute.SKIP;
+        let fldAttr = this.getFieldsTab().getType(fldIdx);
+        if (fldAttr === StorageAttribute.BLOB_VECTOR)
+            cellAttr = this.getFieldsTab().getField(fldIdx).getCellsType();
+        let toBase64 = Environment.Instance.GetDebugLevel() <= 1;
+        return Record.serializeItemVal(fldVal, fldAttr, cellAttr, toBase64);
+    }
+    getFromFldIdx(isCurrRec) {
+        if (isCurrRec)
+            return 0;
+        else
+            return this.getFieldsTab().getRMIdx();
+    }
+    getSizeFld(isCurrRec) {
+        if (isCurrRec)
+            return this.getFieldsTab().getSize();
+        else
+            return this.getFieldsTab().getRMSize();
+    }
+    buildXML(message, isCurrRec, forceBuild) {
+        if (isNullOrUndefined(forceBuild))
+            this.buildXML_0(message, isCurrRec);
+        else
+            this.buildXML_1(message, isCurrRec, forceBuild);
+    }
+    buildXML_0(message, isCurrRec) {
+        this.buildXML_1(message, isCurrRec, false);
+    }
+    buildXML_1(message, isCurrRec, forceBuild) {
+        let recFlags;
+        let from, size, i;
+        let aFlag;
+        let hexFlag;
+        if (!forceBuild)
+            if (this._mode !== DataModificationTypes.Insert && this._mode !== DataModificationTypes.Update &&
+                this._mode !== DataModificationTypes.Delete && !isCurrRec)
+                return;
+        message.Append("\n            <" + ConstInterface.MG_TAG_REC);
+        if (this._id > Int32.MinValue)
+            message.Append(" " + XMLConstants.MG_ATTR_ID + "=\"" + this._id + "\"");
+        message.Append(" " + ConstInterface.MG_ATTR_MODE + "=\"" + this._mode + "\"");
+        if (this._mode === DataModificationTypes.Insert && this._prev != null)
+            message.Append(" " + ConstInterface.MG_ATTR_ADD_AFTER + "=\"" + this._prev.getId() + "\"");
+        if (!forceBuild && !isCurrRec)
+            this.clearMode();
+        message.Append(" " + XMLConstants.MG_ATTR_VALUE + "=\"");
+        if (!forceBuild && isCurrRec)
+            this.setShrinkFlags();
+        let getOldVal;
+        if (this.Synced)
+            getOldVal = false;
+        else {
+            let task = this._dataview.getTask();
+            getOldVal = (!isCurrRec && (task.getLevel() === Constants.TASK_LEVEL_RECORD ||
+                task.getLevel() === Constants.TASK_LEVEL_CONTROL) &&
+                this._dataview.getCurrRec() != null && this._dataview.getCurrRec().getId() === this._id);
+        }
+        this.buildFieldsData(message, isCurrRec, getOldVal);
+        message.Append("\"");
+        recFlags = new StringBuilder();
+        from = this.getFromFldIdx(isCurrRec);
+        size = this.getSizeFld(isCurrRec);
+        for (i = from; i < from + size; i++) {
+            aFlag = this._flagsHistory[i];
+            aFlag = aFlag & Record.FLAG_CRSR_MODIFIED;
+            aFlag = aFlag | this._flags[i];
+            hexFlag = NNumber.ToString(aFlag, "X2");
+            recFlags.Append(hexFlag);
+            if (isCurrRec)
+                this._flags[i] = (this._flags[i] & ~Record.FLAG_VALUE_NOT_PASSED);
+        }
+        message.Append(" " + ConstInterface.MG_ATTR_FLAGS + "=\"" + recFlags.ToString() + "\"");
+        if (isCurrRec) {
+            message.Append(" " + ConstInterface.MG_ATTR_CURR_REC + "=\"1\"");
+            if (this.Modified)
+                message.Append(" " + ConstInterface.MG_ATTR_MODIFIED + "=\"1\"");
+        }
+        if (this._linksFldsPos != null)
+            message.Append(" " + ConstInterface.MG_ATTR_DBPOS + "=\"" + XmlParser.escape(this._linksFldsPos) + "\" ");
+        message.Append(XMLConstants.TAG_TERM);
+    }
+    setShrinkFlags() {
+        let i;
+        let size = this.getSizeFld(true);
+        let serverCurrRec = this._dataview.getServerCurrRec();
+        if (serverCurrRec == null)
+            return;
+        for (i = 0; i < size; i++) {
+            if (this.fldValsEqual(serverCurrRec, i) || (Record.FLAG_NULL === (this._flags[i] & Record.FLAG_NULL))) {
+                this._flags[i] = this._flags[i] | Record.FLAG_VALUE_NOT_PASSED;
+            }
+        }
+    }
+    setShrinkFlag(fldIdx) {
+        this._flags[fldIdx] |= Record.FLAG_VALUE_NOT_PASSED;
+    }
+    SetFieldValue(idx, isNull, value) {
+        let field = this.getFieldsTab().getField(idx);
+        field.UpdateNull(isNull, this);
+        value = this.CheckMgValue(value, isNull, field);
+        this._fieldsData[idx] = value;
+        field.takeValFromRec();
+        this.clearFlag(field.getId(), Record.FLAG_INVALID);
+        field.invalidate(true, false);
+    }
+    setFieldValue(fldIdx, mgVal, setRecordUpdated) {
+        let fld = this.getFieldsTab().getField(fldIdx);
+        if (fld.PrevIsNull() === fld.isNull() && mgVal === this.GetFieldValue(fldIdx))
+            return;
+        mgVal = this.CheckMgValue(mgVal, fld.isNull(), fld);
+        if (fldIdx >= 0 && fldIdx < this.getFieldsTab().getSize()) {
+            this._fieldsData[fldIdx] = mgVal;
+            if (setRecordUpdated) {
+                if (fld.PartOfDataview)
+                    this._modified = true;
+                if (RemoteCommandsProcessor.GetInstance().DelayCommandExecution) {
+                    RemoteCommandsProcessor.GetInstance().DelayCommandExecution = false;
+                    this._dataview.getTask().DelayCommandExecution = true;
+                }
+                this._dataview.setChanged(true);
+                this.setMode(DataModificationTypes.Update);
+            }
+        }
+        else
+            Logger.Instance.WriteExceptionToLogWithMsg("in Record.setFieldValue() illegal field index: " + fldIdx);
+    }
+    CheckMgValue(mgVal, isNull, fld) {
+        if (mgVal === null || isNull) {
+            mgVal = fld.getNullValue();
+            if (mgVal === null)
+                mgVal = fld.getMagicDefaultValue();
+        }
+        let size = fld.getSize();
+        if (UtilStrByteMode.isLocaleDefLangDBCS() && fld.getType() !== StorageAttribute.UNICODE) {
+            if (mgVal !== null && UtilStrByteMode.lenB(mgVal) > size)
+                mgVal = UtilStrByteMode.leftB(mgVal, size);
+        }
+        else {
+            if (mgVal !== null && mgVal.length > size)
+                mgVal = mgVal.substr(0, size);
+        }
+        return mgVal;
+    }
+    setModified() {
+        this._modified = true;
+    }
+    resetModified() {
+        this._modified = false;
+    }
+    setUpdated() {
+        this._updated = true;
+    }
+    resetUpdated() {
+        this._updated = false;
+    }
+    GetFieldValue(fldIdx) {
+        let val = null;
+        if (fldIdx >= 0 && fldIdx < this._fieldsData.length)
+            val = this._fieldsData[fldIdx];
+        return val.toString();
+    }
+    replicate() {
+        let record = new Record(this);
+        record._fieldsData = this._fieldsData.slice();
+        record._flags = this._flags.subarray(0);
+        record._flagsHistory = this._flagsHistory.subarray(0);
+        record._dcRefs = this._dcRefs.Clone();
+        return record;
+    }
+    setSameAs(rec, realOnly, rId) {
+        if (arguments.length === 3)
+            this.setSameAs_0(rec, realOnly, rId);
+        else
+            this.setSameAs_1(rec, realOnly);
+    }
+    setSameAs_0(rec, realOnly, rId) {
+        this.setSameAs(rec, realOnly);
+        this.setId(rId);
+    }
+    setSameAs_1(rec, realOnly) {
+        this._id = rec._id;
+        this._hashKey = rec._hashKey;
+        if (!this._dataview.getTask().transactionFailed(ConstInterface.TRANS_RECORD_PREFIX))
+            this.setMode(rec._mode);
+        this._addAfter = rec._addAfter;
+        if (realOnly) {
+            for (let i = 0; i < this.getFieldsTab().getSize(); i = i + 1) {
+                let afield = rec.getFieldsTab().getField(i);
+                if (!afield.IsVirtual) {
+                    this._fieldsData[i] = rec._fieldsData[i];
+                    this._flags[i] = rec._flags[i];
+                    this._flagsHistory[i] = rec._flagsHistory[i];
+                }
+            }
+        }
+        else {
+            this._fieldsData = rec._fieldsData;
+            this._flags = rec._flags;
+            this._flagsHistory = rec._flagsHistory;
+        }
+        this._modified = rec._modified;
+        this._dataview = rec._dataview;
+        this._computed = rec._computed;
+        this._updated = rec._updated;
+        this.setDcRefs(rec._dcRefs);
+        if (rec._next !== this) {
+            this._next = rec._next;
+        }
+        if (rec._prev !== this) {
+            this._prev = rec._prev;
+        }
+    }
+    IsNull(fldIdx) {
+        this.checkFlags(fldIdx);
+        return ((this._flags[fldIdx] & Record.FLAG_NULL) === Record.FLAG_NULL);
+    }
+    isLinkInvalid(fldIdx) {
+        this.checkFlags(fldIdx);
+        return ((this._flags[fldIdx] & Record.FLAG_INVALID) === Record.FLAG_INVALID);
+    }
+    isFldModified(fldIdx) {
+        this.checkFlags(fldIdx);
+        return ((this._flags[fldIdx] & Record.FLAG_MODIFIED) === Record.FLAG_MODIFIED);
+    }
+    IsFldModifiedAtLeastOnce(fldIdx) {
+        this.checkFlags(fldIdx);
+        return ((this._flags[fldIdx] & Record.FLAG_MODIFIED_ATLEAST_ONCE) === Record.FLAG_MODIFIED_ATLEAST_ONCE);
+    }
+    isFldUpdated(fldIdx) {
+        this.checkFlags(fldIdx);
+        return ((this._flags[fldIdx] & Record.FLAG_UPDATED) === Record.FLAG_UPDATED);
+    }
+    setFlag(fldIdx, aFlag) {
+        this.checkFlags(fldIdx);
+        this._flags[fldIdx] = this._flags[fldIdx] | aFlag;
+        if (aFlag === Record.FLAG_CRSR_MODIFIED)
+            this._flagsHistory[fldIdx] = this._flagsHistory[fldIdx] | aFlag;
+    }
+    clearFlag(fldIdx, aFlags) {
+        this.checkFlags(fldIdx);
+        this._flags[fldIdx] = this._flags[fldIdx] & ~aFlags;
+    }
+    clearFlagsHistory() {
+        for (let i = 0; i < this._flags.length; i = i + 1)
+            this._flagsHistory[i] = 0;
+    }
+    clearFlags(aFlags) {
+        for (let i = 0; i < this._flags.length; i = i + 1)
+            this.clearFlag(i, aFlags);
+    }
+    clearFlagsForRealOnly(aFlags) {
+        for (let i = 0; i < this._flags.length; i = i + 1) {
+            let field = this.getFieldsTab().getField(i);
+            if (!field.IsVirtual) {
+                this.clearFlag(i, aFlags);
+            }
+        }
+    }
+    clearHistoryFlag(fldIdx) {
+        if (this._flagsHistory !== null && fldIdx < this.getFieldsTab().getSize() && fldIdx >= 0) {
+            this._flagsHistory[fldIdx] = 0;
+        }
+    }
+    checkFlags(fldIdx) {
+        if (this._flags === null || fldIdx >= this.getFieldsTab().getSize() || fldIdx < 0) {
+            throw new ApplicationException("Cannot find flags");
+        }
+    }
+    restart(oldMode) {
+        let task = this._dataview.getTask();
+        if (oldMode === DataModificationTypes.None) {
+            let rec = this._dataview.getCurrRec();
+            let isCurrRec = (rec != null && rec.getId() === this._id);
+            if ((this._dataview.getTask()).getMode() === Constants.TASK_MODE_CREATE)
+                if (isCurrRec && !task.getAfterRetry() && task.TryingToCommit && !this._dataview.inRollback())
+                    oldMode = DataModificationTypes.Update;
+                else
+                    oldMode = DataModificationTypes.Insert;
+            else
+                oldMode = DataModificationTypes.Update;
+        }
+        this.setMode(oldMode);
+        if (oldMode === DataModificationTypes.Insert)
+            this.setNewRec();
+    }
+    setLateCompute(val) {
+        this._lateCompute = val;
+    }
+    lateCompute() {
+        return this._lateCompute;
+    }
+    setInDeleteProcess(val) {
+        this._inDeleteProcess = val;
+    }
+    inDeleteProcess() {
+        return this._inDeleteProcess;
+    }
+    removeRecFromDc() {
+        if (this._dcRefs !== null) {
+            this._dcRefs.Dispose();
+        }
+    }
+    isSameRecData(rec, currRec, checkOnlyParetOfDataview) {
+        let size = this.getSizeFld(currRec);
+        let start = this.getFromFldIdx(currRec);
+        let i;
+        let field;
+        if (this === rec)
+            return true;
+        try {
+            if (rec.getSizeFld(currRec) !== size)
+                return false;
+            if (rec.getFromFldIdx(currRec) !== start)
+                return false;
+            for (i = 0; i < start + size; i++) {
+                field = this.getFieldsTab().getField(i);
+                if (checkOnlyParetOfDataview && !field.PartOfDataview)
+                    continue;
+                if (!this.fldValsEqual(rec, i))
+                    return false;
+            }
+        }
+        catch (err) {
+            if (err instanceof ApplicationException)
+                return false;
+            throw err;
+        }
+        return true;
+    }
+    fldValsEqual(rec, fldIdx) {
+        let type = this.getFieldsTab().getField(fldIdx).getType();
+        return ExpressionEvaluator.mgValsEqual(this.GetFieldValue(fldIdx), this.IsNull(fldIdx), type, rec.GetFieldValue(fldIdx), rec.IsNull(fldIdx), type);
+    }
+    getHashKey() {
+        return this._hashKey;
+    }
+    setNextRec(nextRec) {
+        this._next = nextRec;
+    }
+    setPrevRec(prevRec) {
+        this._prev = prevRec;
+    }
+    getPrevRec() {
+        return this._prev;
+    }
+    getNextRec() {
+        return this._next;
+    }
+    getDcRefs() {
+        return this._dcRefs.Clone();
+    }
+    setDcRefs(newDcRefs) {
+        this.removeRecFromDc();
+        this._dcRefs = newDcRefs.Clone();
+        this.SetDcValueId();
+    }
+    realModified() {
+        let bRc = false;
+        let tabSize = this.getFieldsTab().getSize();
+        let j;
+        for (j = 0; j < tabSize; j++) {
+            if ((this._flags[j] & Record.FLAG_MODIFIED) === Record.FLAG_MODIFIED) {
+                if (!(this.getFieldsTab().getField(j).IsVirtual)) {
+                    bRc = true;
+                    break;
+                }
+            }
+        }
+        return bRc;
+    }
+    ToString() {
+        let str = new StringBuilder();
+        this.buildXML(str, (this._dataview.getCurrRec()).getId() === this._id, true);
+        return str.ToString();
+    }
+    setSendToServer(val) {
+        this._sendToServer = val;
+    }
+    getRecSize() {
+        let sum = 0;
+        for (let i = 0; i < this.getFieldsTab().getSize(); i = i + 1) {
+            let field = this.getFieldsTab().getField(i);
+            sum = sum + field.getSize();
+        }
+        return sum;
+    }
+    copyCrsrModifiedFlags(rec) {
+        let tabSize = this.getFieldsTab().getSize();
+        let j;
+        for (j = 0; j < tabSize; j++) {
+            this._flags[j] = rec._flags[j];
+            this._flags[j] = this._flags[j] & Record.FLAG_CRSR_MODIFIED;
+        }
+    }
+    getDbPosVal() {
+        return this._dbPosBase64Val;
+    }
+    buildLinksPosStr() {
+        let tbl = this._dataview.getTask().getDataviewHeaders();
+        if (tbl !== null) {
+            this._linksFldsPos = tbl.buildDbPosString();
+        }
+    }
+    setForceSaveOrg(val) {
+        this._forceSaveOrg = val;
+    }
+    getForceSaveOrg() {
+        return this._forceSaveOrg;
+    }
+    isCauseInvalidation() {
+        return this._causeInvalidation;
+    }
+    setCauseInvalidation(causeInvalidation) {
+        this._causeInvalidation = causeInvalidation;
+    }
+    isComputed() {
+        return this._computed;
+    }
+    setComputed(val) {
+        this._computed = val;
+    }
+    setInCompute(val) {
+        if (!val)
+            this.setComputed(true);
+        this._inCompute = val;
+    }
+    setInRecompute(val) {
+        this._inRecompute = val;
+    }
+    setMode(newMode) {
+        switch (newMode) {
+            case DataModificationTypes.None:
+            case DataModificationTypes.Insert:
+            case DataModificationTypes.Update:
+            case DataModificationTypes.Delete:
+                if (this._mode === DataModificationTypes.None ||
+                    this._mode === DataModificationTypes.Update && newMode === DataModificationTypes.Delete)
+                    this._mode = newMode;
+                break;
+            default:
+                Logger.Instance.WriteExceptionToLogWithMsg("in Record.setMode(): illegal mode: " + newMode);
+                break;
+        }
+    }
+    clearMode() {
+        this._mode = DataModificationTypes.None;
+    }
+    setOldRec() {
+        this._newRec = false;
+    }
+    setNewRec() {
+        this._newRec = true;
+    }
+    static serializeItemVal(itemVal, itemAttr, cellAttr, ToBase64) {
+        return RecordUtils.serializeItemVal(itemVal, itemAttr, cellAttr, ToBase64);
+    }
+    SetDcValueId() {
+        let form = this._dataview.getTask().getForm();
+        let mgControl = null;
+        if (form != null && this._dcRefs != null) {
+            this._dcRefs.Refs.forEach((dcRef) => {
+                mgControl = form.getCtrl(dcRef.ditIdx);
+                if (mgControl != null)
+                    mgControl.setDcValId(dcRef.DcValues.getId());
+            });
+        }
+    }
+    resetDcValueId() {
+        let form = this._dataview.getTask().getForm();
+        let mgControl = null;
+        if (form != null && this._dcRefs != null) {
+            this._dcRefs.Refs.forEach(function (dcRef) {
+                mgControl = form.getCtrl(dcRef.ditIdx);
+                if (mgControl != null)
+                    mgControl.setDcValId(EMPTY_DCREF);
+            });
+        }
+    }
+    AddDcValuesReference(controlId, dcValuesId) {
+        let dcValues = this._dataview.getDcValues(dcValuesId);
+        let dcRef = new DcValuesReference(controlId, dcValues);
+        if (this._dcRefs === null) {
+            this._dcRefs = new ObjectReferencesCollection();
+        }
+        this._dcRefs.Add(dcRef);
+    }
+}
+export class DcValuesReference extends ObjectReferenceBase {
+    ditIdx = 0;
+    get DcValues() {
+        return this.Referent;
+    }
+    constructor(controlId, referencedDcValues) {
+        super(referencedDcValues);
+        this.ditIdx = controlId;
+    }
+    Clone() {
+        return new DcValuesReference(this.ditIdx, this.Referent);
+    }
+    static Parse(couple, dcValuesOwner) {
+        let commaPos = couple.indexOf(",");
+        let controlId = NNumber.Parse(couple.substr(0, commaPos));
+        let dcId = NNumber.Parse(couple.substr(commaPos + 1));
+        return new DcValuesReference(controlId, dcValuesOwner.getDcValues(dcId));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Record.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/data/Record.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  DataModificationTypes,\r\n  DcValues,\r\n  EMPTY_DCREF,\r\n  ExpVal,\r\n  FieldDef,\r\n  IRecord,\r\n  ObjectReferenceBase,\r\n  ObjectReferencesCollection,\r\n  RecordUtils\r\n} from '@magic-xpa/gui';\r\nimport {\r\n  ApplicationException,\r\n  IComparable,\r\n  Int32,\r\n  ISO_8859_1_Encoding,\r\n  List,\r\n  NNumber,\r\n  NString,\r\n  RefParam,\r\n  StringBuilder,\r\n  isNullOrUndefined\r\n} from '@magic-xpa/mscorelib';\r\nimport {\r\n  Base64,\r\n  Constants,\r\n  Logger,\r\n  StorageAttribute,\r\n  StorageAttributeCheck,\r\n  StrUtil,\r\n  UtilStrByteMode,\r\n  XMLConstants,\r\n  XmlParser\r\n} from '@magic-xpa/utils';\r\n\r\nimport {Field} from './Field';\r\nimport {TableCache} from '../rt/TableCache';\r\nimport {ExpressionEvaluator, NullValueException} from '../exp/ExpressionEvaluator';\r\nimport {Key} from './Key';\r\nimport {FieldsTableExt as FieldsTable} from './FieldsTable';\r\nimport {Task} from '../tasks/Task';\r\nimport {MgControl} from '../gui/MgControl';\r\nimport {MgForm} from '../gui/MgForm';\r\nimport {ConstInterface} from '../ConstInterface';\r\nimport {DataviewHeaders} from '../rt/DataviewHeaders';\r\nimport {Environment} from '../env/Environment';\r\nimport {DataViewBase} from './DataViewBase';\r\nimport {RemoteCommandsProcessor} from \"../remote/RemoteCommandsProcessor\";\r\n\r\n\r\n/// <summary>\r\n///   this class represents a record object\r\n///   it parses the <rec...> tag\r\n/// </summary>\r\nexport class Record implements IComparable, IRecord {\r\n  // ATTENTION !!! when you add/modify/delete a member variable don't forget to take care\r\n  // about the \"setSameAs()\" function\r\n\r\n  /// <summary>\r\n  ///   CONSTANTS\r\n  /// </summary>\r\n\r\n  public static FLAG_NULL: number = (0x01);\r\n\r\n  public static FLAG_INVALID: number = (0x02);\r\n  public static FLAG_MODIFIED: number = (0x04);\r\n  public static FLAG_UPDATED: number = (0x08);\r\n  public static FLAG_CRSR_MODIFIED: number = (0x10);\r\n  public static FLAG_VALUE_NOT_PASSED: number = (0x20);\r\n  public static FLAG_MODIFIED_ATLEAST_ONCE: number = (0x40);\r\n\r\n  protected _id: number = Int32.MinValue;\r\n  protected dbViewRowIdx: number = 0;\r\n  protected _mode: DataModificationTypes = DataModificationTypes.None;\r\n\r\n  private _dcRefs: ObjectReferencesCollection = null;\r\n  _inCompute: boolean = false;\r\n  _inRecompute: boolean = false;\r\n  _newRec: boolean = false;\r\n\r\n  public get InCompute(): boolean {\r\n    return this._inCompute;\r\n  }\r\n\r\n  public get InRecompute(): boolean {\r\n    return this._inRecompute;\r\n  }\r\n\r\n  protected static INCREASE: boolean = true;\r\n  protected static DECREASE: boolean = false;\r\n\r\n  protected _tableCache: TableCache; // }\r\n  // } for use if the record is part of table cache (there is no way both dv and tablecache are not null at the same time -\r\n\r\n  protected _inDeleteProcess: boolean; // will be set to true before rec suffix from delline.\r\n  protected _addAfter: number;\r\n  protected _causeInvalidation: boolean; // Exit from this record will cause invalidation of all rows in table\r\n  protected _dbPosBase64Val: string; // used only in table cache records holds the tables db_pos value in the cursor\r\n  // }                                               they are Mutually exclusive).\r\n  protected _dataview: DataViewBase = null;\r\n  private _fieldsData: String[];\r\n  protected _flags: Uint8Array;\r\n  protected _flagsHistory: Uint8Array; // History of flags, used when contacting the server\r\n  protected _forceSaveOrg: boolean;\r\n  protected _hashKey: number;\r\n\r\n  protected _computed: boolean;\r\n  protected _lateCompute: boolean; // this record must be computed next time we enter the record, but not before\r\n\r\n  protected _linksFldsPos: string;\r\n  protected _modified: boolean;\r\n\r\n  protected _next: Record;  // Points to the next record, when its part of a list\r\n  protected _prev: Record;  // Points to the prev record, when its part of a list\r\n  protected _sendToServer: boolean = true; // If false, don't send this record to the server, as part of the modified list\r\n  protected _updated: boolean;\r\n\r\n  public InForceUpdate: boolean;\r\n  public Synced: boolean;\r\n  public ValueInBase64: boolean;\r\n\r\n  constructor(dvOrTableCache: DataViewBase | TableCache);\r\n  constructor(cId: number, dataview: DataViewBase);\r\n  constructor(Record: Record);\r\n  constructor(dvOrTableCacheOrCIdOrRecord: any, dataview?: DataViewBase)\r\n  {\r\n    if(dvOrTableCacheOrCIdOrRecord instanceof  Record)\r\n      Object.assign(this, dvOrTableCacheOrCIdOrRecord);\r\n    else if (arguments.length === 1)\r\n      this.constructor_0(dvOrTableCacheOrCIdOrRecord);\r\n    else\r\n      this.constructor_1(dvOrTableCacheOrCIdOrRecord, dataview);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   constructs a new record to be used by the table cache only!!!\r\n  /// </summary>\r\n  private constructor_0(dvOrTableCache: any): void {\r\n    if (dvOrTableCache instanceof DataViewBase)\r\n      this._dataview = <DataViewBase>dvOrTableCache;\r\n    else\r\n      this._tableCache = <TableCache>dvOrTableCache;\r\n\r\n    this._fieldsData = new Array<string>(this.getFieldsTab().getSize());\r\n    this._flags = new Uint8Array(this.getFieldsTab().getSize());\r\n    this._flagsHistory = new Uint8Array(this.getFieldsTab().getSize());\r\n    this._dcRefs = new ObjectReferencesCollection();\r\n  }\r\n\r\n  public Initialize(): void {\r\n    for (let i: number = 0; i < this._flags.length; i = i + 1) {\r\n      let field: FieldDef = this.getFieldsTab().getField(i);\r\n      this._flags[i] = ((field.isNullDefault() || field.getType() === StorageAttribute.BLOB_VECTOR) ? Record.FLAG_NULL : 0);\r\n\r\n      if (this._dataview !== null && (<Field>field).IsVirtual) {\r\n        let record: Record = this._dataview.getCurrRec();\r\n        if (record != null && record.IsFldModifiedAtLeastOnce(i)) {\r\n          this.setFlag(i, Record.FLAG_MODIFIED_ATLEAST_ONCE);\r\n        }\r\n      }\r\n      this._flagsHistory[i] = this._flags[i];\r\n    }\r\n\r\n    this.setNewRec();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   CTOR\r\n  /// </summary>\r\n  /// <param name = \"cId\">the id of the record</param>\r\n  /// <param name = \"ft\">a reference to the fields table</param>\r\n  /// <param>  clobberedOnly is true if we want to init only the values of the virtuals with no init expression </param>\r\n  private constructor_1(cId: number, dataview: DataViewBase): void {\r\n    this.constructor_0(dataview);\r\n    this.setId(cId);\r\n  }\r\n\r\n  public get Modified(): boolean {\r\n    return this._modified;\r\n  }\r\n\r\n  public get Updated(): boolean {\r\n    return this._updated;\r\n  }\r\n\r\n  public get SendToServer(): boolean {\r\n    return this._sendToServer;\r\n  }\r\n\r\n  public CompareTo(obj: Object): number {\r\n    let res: number = 0;\r\n    let compTo = <Record>obj;\r\n\r\n    // get the key by which we are doing the Comparison\r\n    let key: Key = this._tableCache.GetKeyById(this._tableCache.GetCurrSortKey());\r\n\r\n    // if there is no key to compare by then the records are uncomparable\r\n    if (key != null) {\r\n      // all we need from the key in the order of comparing the the record fields\r\n      for (let i: number = 0; i < key.Columns.length; i++) {\r\n        let currFld = key.Columns.get_Item(i);\r\n        let currFldId: number = currFld.getId();\r\n\r\n        if (this.IsNull(currFldId) && compTo.IsNull(currFldId))\r\n          continue;\r\n        else if (this.IsNull(currFldId) && !compTo.IsNull(currFldId)) {\r\n          // null is the greatest value therefore we are the greater\r\n          res = 1;\r\n          break;\r\n        }\r\n        else if (!this.IsNull(currFldId) && compTo.IsNull(currFldId)) {\r\n          res = -1;\r\n          break;\r\n        }\r\n        // both are not null\r\n        else {\r\n          try {\r\n            let first = new ExpVal(currFld.getType(), false,\r\n              this.GetFieldValue(currFldId));\r\n            let second = new ExpVal(currFld.getType(), false,\r\n              compTo.GetFieldValue(currFldId));\r\n\r\n            res = ExpressionEvaluator.val_cmp_any(first, second);\r\n\r\n            if (res !== 0)\r\n              break;\r\n          }\r\n          catch (err)\r\n            // one of the values we are comparing using vl_cmp_any  is null we should never get here\r\n          {\r\n            if (err instanceof NullValueException)\r\n              Logger.Instance.WriteExceptionToLogWithMsg(\" in Record.CompareTo null value was reached\");\r\n          }\r\n\r\n        }\r\n      }\r\n      return res;\r\n    }\r\n    else {\r\n      res = -1;\r\n      return res;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the mode\r\n  /// </summary>\r\n  getMode(): DataModificationTypes {\r\n    return this._mode;\r\n  }\r\n\r\n/// <summary>\r\n  ///   get the record id\r\n  /// </summary>\r\n  getId(): number {\r\n    return this._id;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if this is a new record just created and no record suffix was yet\r\n  ///   processed on it\r\n  /// </summary>\r\n  isNewRec(): boolean {\r\n    return this._newRec;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   build the field value for the XML string of this record\r\n  /// </summary>\r\n  /// <param name = \"fldIdx\">index of field</param>\r\n  /// <returns></returns>\r\n  private getFieldDataXML(fldIdx: number, getOldVal: boolean): string {\r\n    let fldVal: string;\r\n\r\n    if (!getOldVal)\r\n      fldVal = this.GetFieldValue(fldIdx);\r\n    else\r\n      fldVal = (<Field>(this.getFieldsTab().getField(fldIdx))).getOriginalValue();\r\n    if (fldVal == null)\r\n      throw new ApplicationException(\"in Record.buildFieldsData() null field value!\\nField id: \" + fldIdx);\r\n\r\n    let tmpBuf: string = this.getXMLForValue(fldIdx, fldVal);\r\n    return XmlParser.escape(tmpBuf.toString()).toString();\r\n  }\r\n\r\n  /// <summary>\r\n  /// get field table either of DataViewRoot ('dvHeader') or of TableCache\r\n  /// dv and tableCache are mutually exclusive\r\n  /// </summary>\r\n  /// <returns> fieldTable </returns>\r\n  getFieldsTab(): FieldsTable {\r\n    if (this._dataview !== null)\r\n      return <FieldsTable>this._dataview.GetFieldsTab();\r\n\r\n    else\r\n      return this._tableCache.FldsTab;\r\n  }\r\n\r\n  // TODO : check how to implement destructors\r\n  // ~Record()\r\n  // {\r\n  // \tthis.removeRecFromDc();\r\n  // }\r\n\r\n  /// <summary>\r\n  ///   set the initial field values for fields that has a null value\r\n  /// </summary>\r\n  /// <param>  clobberedOnly is true if we want to init only the values of the virtuals with no init expression </param>\r\n  public setInitialFldVals(clobberedOnly: boolean, isNewRec: boolean): void {\r\n    let i: number, size;\r\n    let fld: Field = null;\r\n    size = this.getSizeFld(true);\r\n\r\n    for (i = 0; i < size; i++) {\r\n      // put initial values to the fields using the Magic default value\r\n      if (this._fieldsData[i] === null || typeof this._fieldsData[i] === \"undefined\") {\r\n        fld = <Field>this.getFieldsTab().getField(i);\r\n        this._fieldsData[i] = fld.getNewRecValue(clobberedOnly);\r\n\r\n        if (isNewRec && fld.IsVirtual && !fld.isNull())\r\n          this.clearFlag(fld.getId(), Record.FLAG_NULL);\r\n\r\n        if (fld.IsVirtual && fld.getModifiedAtLeastOnce())\r\n          this.setFlag(fld.getId(), Record.FLAG_MODIFIED_ATLEAST_ONCE);\r\n\r\n        if (this._fieldsData[i] === null || typeof this._fieldsData[i] === \"undefined\")\r\n          this._fieldsData[i] = fld.getDefaultValue();\r\n      }\r\n    }\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   sets the id of the record and an appropriate hash key\r\n  /// </summary>\r\n  /// <param name = \"cId\">the id of the record</param>\r\n  setId(cId: number): void {\r\n    this._id = cId;\r\n    this._hashKey = this._id;\r\n  }\r\n\r\n  /// <summary>\r\n  /// sets the dbViewRowId of the record\r\n  /// </summary>\r\n  /// <param name = \"cId\">the id of the record</param>\r\n  setDBViewRowIdx(rowId: number): void {\r\n    this.dbViewRowIdx = rowId;\r\n  }\r\n\r\n  /// <summary>\r\n  /// return dbViewRowId of the record\r\n  /// </summary>\r\n  /// <param name = \"cId\">the id of the record</param>\r\n  getDBViewRowIdx(): number {\r\n    return this.dbViewRowIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parse input string and fill inner data - returns true when the record is the current record\r\n  /// </summary>\r\n  fillData(parser: XmlParser): boolean {\r\n    let isCurrRec: boolean = false;\r\n    let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());\r\n\r\n    if (endContext !== -1 && endContext < parser.getXMLdata().length) {\r\n      // last position of its tag\r\n      let tag: String = parser.getXMLsubstring(endContext);\r\n      parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_REC) + ConstInterface.MG_TAG_REC.length);\r\n\r\n      let tokensVector: List<string> = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);\r\n      isCurrRec = this.initElements(tokensVector);\r\n      parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length);\r\n    }\r\n    else\r\n      Logger.Instance.WriteExceptionToLogWithMsg(\"in Record.FillInnerData() out of bounds\");\r\n    return isCurrRec;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parse the record - returns true when the record is the current record\r\n  /// </summary>\r\n  /// <param name = \"tokensVector\">the attributes and their values</param>\r\n  protected initElements(tokensVector: List<string>): boolean {\r\n    let attribute: String, valueStr;\r\n    let recFieldsData: string = null;\r\n    let recFlags: string = null;\r\n    let j: number = 0;\r\n    let isCurrRec: boolean;\r\n\r\n    isCurrRec = this.peekIsCurrRec(tokensVector);\r\n\r\n    for (; j < tokensVector.length; j += 2) {\r\n      attribute = (tokensVector.get_Item(j));\r\n      valueStr = (tokensVector.get_Item(j + 1));\r\n\r\n      switch (attribute) {\r\n        case ConstInterface.MG_ATTR_MODE:\r\n          this._mode = <DataModificationTypes>valueStr[0];\r\n          break;\r\n        case XMLConstants.MG_ATTR_ID:\r\n          this.setId(XmlParser.getInt(valueStr));\r\n          break;\r\n        case XMLConstants.MG_ATTR_VB_VIEW_ROWIDX:\r\n          this.setDBViewRowIdx(XmlParser.getInt(valueStr));\r\n          break;\r\n        case XMLConstants.MG_ATTR_VALUE:\r\n          if (this.ValueInBase64) {\r\n            recFieldsData = Base64.decode(valueStr);\r\n          }\r\n          else {\r\n            recFieldsData = XmlParser.unescape(valueStr);\r\n          }\r\n          break;\r\n        case ConstInterface.MG_ATTR_CURR_REC: {\r\n\r\n        }\r\n          break;\r\n        case ConstInterface.MG_ATTR_ADD_AFTER:\r\n          this._addAfter = XmlParser.getInt(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_FLAGS:\r\n          recFlags = valueStr;\r\n          break;\r\n        case ConstInterface.MG_ATTR_MODIFIED:\r\n          this._modified = true;\r\n          break;\r\n        case ConstInterface.MG_ATTR_DC_REFS:\r\n          this.fillDCRef(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_DBPOS:\r\n          this._dbPosBase64Val = valueStr;\r\n          break;\r\n        default:\r\n          Logger.Instance.WriteExceptionToLogWithMsg(\"in Record.initElements() unknown attribute: \" + attribute);\r\n          break;\r\n      }\r\n    }\r\n    if (this.ValueInBase64) {\r\n      let fldValInBytes: Uint8Array = ISO_8859_1_Encoding.ISO_8859_1.GetBytes(recFieldsData);\r\n      this.fillFieldsData(fldValInBytes, recFlags);\r\n    }\r\n    else {\r\n      this.fillFieldsData(recFieldsData, recFlags, isCurrRec);\r\n    }\r\n    return isCurrRec;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   peek the curr_rec value from the tag\r\n  /// </summary>\r\n  /// <param name = \"the\">tokens of the attributes and values in the tag</param>\r\n  protected peekIsCurrRec(tokensVector: List<string>): boolean {\r\n    let attribute: string;\r\n    let valueStr: string;\r\n\r\n    for (let j: number = 0; j < tokensVector.length; j += 2) {\r\n      attribute = (tokensVector.get_Item(j));\r\n      if (attribute === ConstInterface.MG_ATTR_CURR_REC) {\r\n        valueStr = (tokensVector.get_Item(j + 1));\r\n        return XmlParser.getBoolean(valueStr);\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  fillFieldsData(fldValInBytes: Uint8Array, recFlags: string): void;\r\n  fillFieldsData(fldsVal: string, recFlags: string, isCurrRec: boolean): void;\r\n  fillFieldsData(fldValInBytesOrFldsVal: any, recFlags: string, isCurrRec?: boolean): void {\r\n    if (isNullOrUndefined(isCurrRec))\r\n      this.fillFieldsData_0();\r\n    else\r\n      this.fillFieldsData_1(fldValInBytesOrFldsVal, recFlags, isCurrRec);\r\n  }\r\n\r\n  private fillFieldsData_0(): void {\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Fill FieldsData\r\n  /// </summary>\r\n  /// <param name = \"fldsVal\">- string for parsing</param>\r\n  /// <param name = \"isCurrRec\">true if this record is the current record</param>\r\n  private fillFieldsData_1(fldsVal: string, recFlags: String, isCurrRec: boolean): void {\r\n    let val: String = null;\r\n    let tmp: string = null;\r\n    let parsedLen: RefParam<number> = new RefParam<number>(0);\r\n    let i: number, j = 0, from, size;\r\n    let currType: StorageAttribute;\r\n    let useHex: boolean;\r\n    let fld: FieldDef = null;\r\n    let valueNotPassed: boolean;\r\n\r\n    from = this.getFromFldIdx(isCurrRec);\r\n    size = this.getSizeFld(isCurrRec);\r\n\r\n    for (i = from; j < size; i++, j++) {\r\n      fld = this.getFieldsTab().getField(i);\r\n      currType = fld.getType();\r\n\r\n      useHex = (Environment.Instance.GetDebugLevel() > 1 ||\r\n        currType === StorageAttribute.ALPHA ||\r\n        currType === StorageAttribute.UNICODE ||\r\n        StorageAttributeCheck.isTypeLogical(currType));\r\n\r\n      // Qcr #940443 : Old fashion flags are still being used by resident table. So check them 1st coz we  might get exception otherwise.\r\n      // The flags for resident are very simple, only 2 options. '.' = false, '/' = true.\r\n      // We keep using it for resident, since in the server side we do not know if we are creating the xml for richclient or for BC at the creation stage.\r\n      // Since we couldn't create different flags for rich, we will use the old flags here.\r\n\r\n      if (recFlags[j] === '.')\r\n        this._flags[i] = 0;\r\n      else if (recFlags[j] === '/')\r\n        this._flags[i] = 1;\r\n      else {\r\n        // Each flag will appear in the xml in 2 chars representing hex value (\"42\" for 0x42).\r\n        tmp = recFlags.substr(j * 2, 2);\r\n        this._flags[i] = parseInt(tmp, 16);\r\n      }\r\n\r\n      // save the ind that the value was not passed from the server.\r\n      valueNotPassed = Record.FLAG_VALUE_NOT_PASSED === (this._flags[i] & Record.FLAG_VALUE_NOT_PASSED);\r\n      this._flags[i] = this._flags[i] & ~Record.FLAG_VALUE_NOT_PASSED;\r\n\r\n      this._flagsHistory[i] = this._flags[i];\r\n\r\n      if (Record.FLAG_UPDATED === (this._flags[i] & Record.FLAG_UPDATED))\r\n        this._updated = true;\r\n      if (valueNotPassed) {\r\n        if (Record.FLAG_NULL === (this._flags[i] & Record.FLAG_NULL)) {\r\n          // null ind is on, just put any value in the field.\r\n          val = fld.getDefaultValue();\r\n        }\r\n        else {\r\n          // copy the existing value from the existing curr rec.\r\n          val = (<Record> this._dataview.getCurrRec()).GetFieldValue(i);\r\n        }\r\n      }\r\n      else {\r\n        val = RecordUtils.deSerializeItemVal(fldsVal, currType, fld.getSize(), useHex, fld.getCellsType(), parsedLen);\r\n        fldsVal = fldsVal.substr(parsedLen.value);\r\n      }\r\n      this._fieldsData[i] = val;\r\n    }\r\n\r\n    this.setInitialFldVals(false, false);\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   init dcRefs vector and increase reference counter to DataViewRoot.counterArray\r\n  /// </summary>\r\n  /// <param name = \"valueStr\">in form \"dit_idx,dc_id$dit_idx,dc_id$...\"</param>\r\n  fillDCRef(valueStr: string): void {\r\n    if (!NString.IsNullOrEmpty(valueStr)) {\r\n      let couples: string[] = StrUtil.tokenize(valueStr, \"$\");\r\n      let size: number = couples.length;\r\n\r\n      for (let i: number = 0; i < size; i = i + 1) {\r\n        this._dcRefs.Add(DcValuesReference.Parse(couples[i], this._dataview));\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   build the fields value for the XML string of this record\r\n  /// </summary>\r\n  private buildFieldsData(message: StringBuilder, isCurrRec: boolean, getOldVal: boolean): void {\r\n    let tmpStr: StringBuilder = new StringBuilder();\r\n\r\n    let from: number = this.getFromFldIdx(isCurrRec);\r\n    let size: number = this.getSizeFld(isCurrRec);\r\n\r\n    for (let i: number = from; i < from + size; i = i + 1) {\r\n\r\n      // Do not serialize the field value which is not exposed to client.\r\n      let fld: Field =  <Field> this.getFieldsTab().getField(i);\r\n      if (fld.IsExposedToClient === false)\r\n        this.setShrinkFlag(i);\r\n\r\n      // do not write the value if the shrink flag is on.\r\n      if (Record.FLAG_VALUE_NOT_PASSED === (this._flags[i] & Record.FLAG_VALUE_NOT_PASSED))\r\n        continue;\r\n\r\n      tmpStr.Append(this.getFieldDataXML(i, getOldVal).toString());\r\n    }\r\n\r\n\r\n    // if none of the values had changed. pass \" \" instead of \"\".\r\n    if (tmpStr.Length === 0) {\r\n      tmpStr.Append(\" \");\r\n    }\r\n\r\n    message.Append(tmpStr.ToString());\r\n\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  /// <param name=\"fldIdx\"></param>\r\n  /// <param name=\"fldVal\"></param>\r\n  /// <returns></returns>\r\n  getXMLForValue(fldIdx: number, fldVal: string): string {\r\n    let cellAttr: StorageAttribute = StorageAttribute.SKIP; // cell's attribute, if the field's attribute is a vector\r\n    let fldAttr: StorageAttribute = this.getFieldsTab().getType(fldIdx); // field's attribute\r\n    if (fldAttr === StorageAttribute.BLOB_VECTOR)\r\n      cellAttr = this.getFieldsTab().getField(fldIdx).getCellsType();\r\n\r\n    let toBase64: boolean = Environment.Instance.GetDebugLevel() <= 1;\r\n    return Record.serializeItemVal(fldVal, fldAttr, cellAttr, toBase64);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the index of the starting field according to the type of record\r\n  /// </summary>\r\n  /// <param name = \"isCurrRec\">should be true for the current rec</param>\r\n  getFromFldIdx(isCurrRec: boolean): number {\r\n    if (isCurrRec)\r\n      return 0;\r\n    else\r\n      return this.getFieldsTab().getRMIdx();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the number of fields according to the type of record\r\n  /// </summary>\r\n  /// <param name = \"isCurrRec\">should be true for the current rec</param>\r\n  getSizeFld(isCurrRec: boolean): number {\r\n    if (isCurrRec)\r\n      return this.getFieldsTab().getSize();\r\n    else\r\n      return this.getFieldsTab().getRMSize();\r\n  }\r\n\r\n  buildXML(message: StringBuilder, isCurrRec: boolean): void;\r\n  buildXML(message: StringBuilder, isCurrRec: boolean, forceBuild: boolean): void;\r\n  buildXML(message: StringBuilder, isCurrRec: boolean, forceBuild?: boolean): void {\r\n    if (isNullOrUndefined(forceBuild))\r\n      this.buildXML_0(message, isCurrRec);\r\n    else\r\n      this.buildXML_1(message, isCurrRec, forceBuild);\r\n  }\r\n\r\n  private buildXML_0(message: StringBuilder, isCurrRec: boolean):  void {\r\n    this.buildXML_1(message, isCurrRec, false);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   build the XML string of the record\r\n  /// </summary>\r\n  /// <param name = \"message\">the xml message to append to</param>\r\n  /// <param name = \"isCurrRec\">indicate this record as the current record</param>\r\n  protected buildXML_1(message: StringBuilder, isCurrRec: boolean, forceBuild: boolean): void {\r\n    let recFlags: StringBuilder;\r\n    let from: number, size, i;\r\n    let aFlag: number;\r\n    let hexFlag: string;\r\n\r\n    if (!forceBuild)\r\n      if (this._mode !== DataModificationTypes.Insert && this._mode !== DataModificationTypes.Update &&\r\n        this._mode !== DataModificationTypes.Delete && !isCurrRec)\r\n        return;\r\n\r\n    message.Append(\"\\n            <\" + ConstInterface.MG_TAG_REC);\r\n    if (this._id > Int32.MinValue)\r\n      message.Append(\" \" + XMLConstants.MG_ATTR_ID + \"=\\\"\" + this._id + \"\\\"\");\r\n    message.Append(\" \" + ConstInterface.MG_ATTR_MODE + \"=\\\"\" + <string>this._mode + \"\\\"\");\r\n\r\n    if (this._mode === DataModificationTypes.Insert && this._prev != null)\r\n      message.Append(\" \" + ConstInterface.MG_ATTR_ADD_AFTER + \"=\\\"\" + this._prev.getId() + \"\\\"\");\r\n\r\n    // current record's mode is never cleared, the whole record is cleared when we move on.\r\n    if (!forceBuild && !isCurrRec)\r\n      this.clearMode();\r\n\r\n    message.Append(\" \" + XMLConstants.MG_ATTR_VALUE + \"=\\\"\");\r\n\r\n    if (!forceBuild && isCurrRec)\r\n      this.setShrinkFlags();\r\n\r\n    let getOldVal: boolean;\r\n    if (this.Synced)\r\n      getOldVal = false;\r\n    else {\r\n      let task: Task = <Task>this._dataview.getTask();\r\n      getOldVal = (!isCurrRec && (task.getLevel() === Constants.TASK_LEVEL_RECORD ||\r\n        task.getLevel() === Constants.TASK_LEVEL_CONTROL) &&\r\n       this._dataview.getCurrRec() != null && ((<Record> this._dataview.getCurrRec())).getId() === this._id);\r\n    }\r\n\r\n    this.buildFieldsData(message, isCurrRec, getOldVal);\r\n    message.Append(\"\\\"\");\r\n    recFlags = new StringBuilder();\r\n\r\n    from = this.getFromFldIdx(isCurrRec);\r\n    size = this.getSizeFld(isCurrRec);\r\n\r\n    // QCR 479686: send FLAG_CRSR_MOD from the history, thus let the server know if a field\r\n    // was updated since the last time we sent it to IT (hence, a DBMS action is needed).\r\n    for (i = from; i < from + size; i++) {\r\n      aFlag = this._flagsHistory[i];\r\n      aFlag = aFlag & Record.FLAG_CRSR_MODIFIED;\r\n      aFlag = aFlag | this._flags[i];\r\n\r\n      // Each flag will appear in the xml in 2 chars representing hex value (\"42\" for 0x42).\r\n      hexFlag = NNumber.ToString(aFlag, \"X2\");\r\n      recFlags.Append(hexFlag);\r\n\r\n      // clear the shrink flag\r\n      if (isCurrRec)\r\n        this._flags[i] = <number>(this._flags[i] & ~Record.FLAG_VALUE_NOT_PASSED);\r\n    }\r\n\r\n    message.Append(\" \" + ConstInterface.MG_ATTR_FLAGS + \"=\\\"\" + recFlags.ToString() + \"\\\"\");\r\n\r\n    if (isCurrRec) {\r\n\r\n      message.Append(\" \" + ConstInterface.MG_ATTR_CURR_REC + \"=\\\"1\\\"\");\r\n\r\n      if (this.Modified)\r\n        message.Append(\" \" + ConstInterface.MG_ATTR_MODIFIED + \"=\\\"1\\\"\");\r\n    }\r\n    if (this._linksFldsPos != null)\r\n      message.Append(\" \" + ConstInterface.MG_ATTR_DBPOS + \"=\\\"\" + XmlParser.escape(this._linksFldsPos) + \"\\\" \");\r\n\r\n    message.Append(XMLConstants.TAG_TERM);\r\n  }\r\n\r\n/// <summary>\r\n  ///   scan the record and compare fields with parallel server curr rec,\r\n  ///   set shrink flag on if fields are equal.\r\n  /// </summary>\r\n\r\n  protected setShrinkFlags(): void {\r\n    let i: number;\r\n    let size: number = this.getSizeFld(true);\r\n\r\n    let serverCurrRec: Record = this._dataview.getServerCurrRec();\r\n    // cannot shrink if we do not know what curr rec the server holds.\r\n    if (serverCurrRec == null)\r\n      return;\r\n    for (i = 0; i < size; i++) {\r\n      if (this.fldValsEqual(serverCurrRec, i) || (Record.FLAG_NULL === (this._flags[i] & Record.FLAG_NULL))) {\r\n        this._flags[i] = this._flags[i] | Record.FLAG_VALUE_NOT_PASSED;\r\n      }\r\n    }\r\n  }\r\n\r\n/// <summary>\r\n  /// set shrink flag for specific field\r\n  /// </summary>\r\n  /// <param name=\"fldIdx\"></param>\r\n  setShrinkFlag(fldIdx: number): void {\r\n    this._flags[fldIdx] |= Record.FLAG_VALUE_NOT_PASSED;\r\n  }\r\n\r\n  /// <summary>\r\n  /// sets field value to its original value from record\r\n  /// </summary>\r\n  /// <param name=\"idx\"></param>\r\n  /// <param name=\"value\"></param>\r\n  SetFieldValue(idx: number, isNull: boolean, value: string): void {\r\n    let field: Field = <Field>this.getFieldsTab().getField(idx);\r\n    field.UpdateNull(isNull, this);\r\n\r\n    value = this.CheckMgValue(value, isNull, field);\r\n    this._fieldsData[idx] = value;\r\n    field.takeValFromRec();\r\n    this.clearFlag(field.getId(), Record.FLAG_INVALID);\r\n    field.invalidate(true, false);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set field value\r\n  /// </summary>\r\n  /// <param name = \"fldIdx\">the field index</param>\r\n  /// <param name = \"mgVal\">the new value of the field. must be in the internal storage format</param>\r\n  /// <param name = \"setRecordUpdated\">tells whether to define this record as updated</param>\r\n  setFieldValue(fldIdx: number, mgVal: string, setRecordUpdated: boolean): void {\r\n    let fld: Field = <Field>this.getFieldsTab().getField(fldIdx);\r\n\r\n    // don't change value when references are equal or if the task mode is Query\r\n    if (fld.PrevIsNull() === fld.isNull() && mgVal === this.GetFieldValue(fldIdx))\r\n      return;\r\n\r\n\r\n    mgVal = this.CheckMgValue(mgVal, fld.isNull(), fld);\r\n\r\n    if (fldIdx >= 0 && fldIdx < this.getFieldsTab().getSize()) {\r\n      this._fieldsData[fldIdx] = mgVal;\r\n\r\n      // QCR #986715: The following setFlag() call was removed to solve the bug.\r\n      // it caused marking a variable as modified even if the change is due to the\r\n      // compute of the record. The FLAG_MODIFIED flag is set correctly in the\r\n      // Field.setValue() method.\r\n      // setFlag(fldIdx, FLAG_MODIFIED);\r\n      if (setRecordUpdated) {\r\n        // set modify only if the field is part of the dataview.\r\n        if (fld.PartOfDataview)\r\n          this._modified = true;\r\n\r\n        // If we are here due to task closing , and found that the current rec's fld is updated\r\n        // then set RemoteCommandsProcessor.GetInstance().DelayCommandExecution = false\r\n\t\t// So that commit transaction should be executed separately at server side.\r\n        if (RemoteCommandsProcessor.GetInstance().DelayCommandExecution) {\r\n          RemoteCommandsProcessor.GetInstance().DelayCommandExecution = false;\r\n          (<Task>this._dataview.getTask()).DelayCommandExecution = true;\r\n        }\r\n        this._dataview.setChanged(true);\r\n        this.setMode(DataModificationTypes.Update);\r\n      }\r\n    }\r\n    else\r\n      Logger.Instance.WriteExceptionToLogWithMsg(\"in Record.setFieldValue() illegal field index: \" + fldIdx);\r\n\r\n  }\r\n\r\n  /// <summary>\r\n  /// check mgvalue\r\n  /// </summary>\r\n  /// <param name=\"mgVal\"></param>\r\n  /// <param name=\"isNull\"></param>\r\n  /// <param name=\"fld\"></param>\r\n  /// <returns></returns>\r\n  CheckMgValue(mgVal: string, isNull: boolean, fld: Field): string {\r\n    if (mgVal === null || isNull) {\r\n      mgVal = fld.getNullValue();\r\n      if (mgVal === null)\r\n        mgVal = fld.getMagicDefaultValue();\r\n\r\n    }\r\n    let size: number = fld.getSize();\r\n\r\n    // truncate values that are longer than the storage size\r\n    if (UtilStrByteMode.isLocaleDefLangDBCS() && fld.getType() !== StorageAttribute.UNICODE) {\r\n      // count the number of bytes, not characters (JPN: DBCS support)\r\n      if (mgVal !== null && UtilStrByteMode.lenB(mgVal) > size)\r\n        mgVal = UtilStrByteMode.leftB(mgVal, size);\r\n    }\r\n    else {\r\n      if (mgVal !== null && mgVal.length > size)\r\n        mgVal = mgVal.substr(0, size);\r\n    }\r\n    return mgVal;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the \"modified\" flag\r\n  /// </summary>\r\n  setModified(): void {\r\n    this._modified = true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   reset the \"modified\" flag\r\n  /// </summary>\r\n  resetModified(): void {\r\n    this._modified = false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the \"updated\" flag\r\n  /// </summary>\r\n  setUpdated(): void {\r\n    this._updated = true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   reset the \"modified\" flag\r\n  /// </summary>\r\n  resetUpdated(): void {\r\n    this._updated = false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get a field value\r\n  /// </summary>\r\n  /// <param name = \"fldIdx\">the field index</param>\r\n  /// <returns> String the field value</returns>\r\n  GetFieldValue(fldIdx: number): string {\r\n    let val: String = null;\r\n\r\n    if (fldIdx >= 0 && fldIdx < this._fieldsData.length)\r\n      val = this._fieldsData[fldIdx];\r\n    return val.toString();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns a copy of this record\r\n  /// </summary>\r\n  replicate(): Record {\r\n    let record: Record = new Record(this);\r\n    record._fieldsData = this._fieldsData.slice();\r\n    record._flags = this._flags.subarray(0);\r\n    record._flagsHistory = this._flagsHistory.subarray(0);\r\n    record._dcRefs = this._dcRefs.Clone();\r\n    return record;\r\n  }\r\n\r\n  setSameAs(rec: Record, realOnly: boolean, rId: number): void;\r\n  setSameAs(rec: Record, realOnly: boolean): void;\r\n  setSameAs(rec: Record, realOnly: boolean, rId?: number): void {\r\n    if (arguments.length === 3)\r\n      this.setSameAs_0(rec, realOnly, rId);\r\n    else\r\n      this.setSameAs_1(rec, realOnly);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the value of the member variables of this record to be the same as those\r\n  ///   of the given record\r\n  /// </summary>\r\n  /// <param name = \"rec\">the source record</param>\r\n  /// <param name = \"rId\">the new Id of the record</param>\r\n  private setSameAs_0(rec: Record, realOnly: boolean, rId: number): void {\r\n    this.setSameAs(rec, realOnly);\r\n    this.setId(rId);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the value of the member variables of this record to be the same as those\r\n  ///   of the given record\r\n  /// </summary>\r\n  /// <param name = \"rec\">the source record</param>\r\n  private setSameAs_1(rec: Record, realOnly: boolean): void {\r\n    this._id = rec._id;\r\n    this._hashKey = rec._hashKey;\r\n\r\n    if (!this._dataview.getTask().transactionFailed(ConstInterface.TRANS_RECORD_PREFIX)/*'P'*/)\r\n      this.setMode(rec._mode);\r\n\r\n    this._addAfter = rec._addAfter;\r\n\r\n    if (realOnly) {\r\n      for (let i: number = 0; i < this.getFieldsTab().getSize(); i = i + 1) {\r\n        let afield: Field = <Field>rec.getFieldsTab().getField(i);\r\n        if (!afield.IsVirtual) {\r\n          this._fieldsData[i] = rec._fieldsData[i];\r\n          this._flags[i] = rec._flags[i];\r\n          this._flagsHistory[i] = rec._flagsHistory[i];\r\n        }\r\n      }\r\n    }\r\n    else {\r\n      this._fieldsData = rec._fieldsData;\r\n      this._flags = rec._flags;\r\n      this._flagsHistory = rec._flagsHistory;\r\n    }\r\n    this._modified = rec._modified;\r\n    this._dataview = rec._dataview;\r\n    this._computed = rec._computed;\r\n    this._updated = rec._updated;\r\n    this.setDcRefs(rec._dcRefs);\r\n\r\n    // QCR #423552: partial fix - we need to go over all the rec.next/prev and make sure this record does not appear\r\n    if (rec._next !== this) {\r\n      this._next = rec._next;\r\n    }\r\n    if (rec._prev !== this) {\r\n      this._prev = rec._prev;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if a field has a null value\r\n  /// </summary>\r\n  /// <param name = \"fldIdx\">the index of the field to check</param>\r\n  IsNull(fldIdx: number): boolean {\r\n    this.checkFlags(fldIdx);\r\n    return ((this._flags[fldIdx] & Record.FLAG_NULL) === Record.FLAG_NULL);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if a field has a null value\r\n  /// </summary>\r\n  /// <param name = \"fldIdx\">the index of the field to check</param>\r\n  isLinkInvalid(fldIdx: number): boolean {\r\n    this.checkFlags(fldIdx);\r\n    return ((this._flags[fldIdx] & Record.FLAG_INVALID) === Record.FLAG_INVALID);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if a field has modified\r\n  /// </summary>\r\n  /// <param name = \"fldIdx\">the index of the field to check</param>\r\n  isFldModified(fldIdx: number): boolean {\r\n    this.checkFlags(fldIdx);\r\n    return ((this._flags[fldIdx] & Record.FLAG_MODIFIED) === Record.FLAG_MODIFIED);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if a field has modified at least once\r\n  /// </summary>\r\n  /// <param name = \"fldIdx\">the index of the field to check</param>\r\n  IsFldModifiedAtLeastOnce(fldIdx: number): boolean {\r\n    this.checkFlags(fldIdx);\r\n    return ((this._flags[fldIdx] & Record.FLAG_MODIFIED_ATLEAST_ONCE) === Record.FLAG_MODIFIED_ATLEAST_ONCE);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if a field has modified\r\n  /// </summary>\r\n  /// <param name = \"fldIdx\">the index of the field to check</param>\r\n  isFldUpdated(fldIdx: number): boolean {\r\n    this.checkFlags(fldIdx);\r\n    return ((this._flags[fldIdx] & Record.FLAG_UPDATED) === Record.FLAG_UPDATED);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set a field to have a null value\r\n  /// </summary>\r\n  /// <param name = \"fldIdx\">the index of the field</param>\r\n  public setFlag(fldIdx: number, aFlag: number): void {\r\n    this.checkFlags(fldIdx);\r\n    this._flags[fldIdx] = this._flags[fldIdx] | aFlag;\r\n    // Note: we only set the history flags. We dont clear them here. We only clear them after XML was dumped.\r\n    if (aFlag === Record.FLAG_CRSR_MODIFIED)\r\n      this._flagsHistory[fldIdx] = this._flagsHistory[fldIdx] | aFlag;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set a field to have a non-null value\r\n  /// </summary>\r\n  /// <param name = \"fldIdx\">the index of the field</param>\r\n  clearFlag(fldIdx: number, aFlags: number): void {\r\n    this.checkFlags(fldIdx);\r\n    this._flags[fldIdx] = this._flags[fldIdx] & ~aFlags;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   clear the flags history. This should only be done after a commit.\r\n  /// </summary>\r\n  clearFlagsHistory(): void {\r\n    for (let i: number = 0; i < this._flags.length; i = i + 1)\r\n      this._flagsHistory[i] = 0;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   clear flag for all fields\r\n  /// </summary>\r\n  clearFlags(aFlags: number): void {\r\n    for (let i: number = 0; i < this._flags.length; i = i + 1)\r\n      this.clearFlag(i, aFlags);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   clear flag for all real fields\r\n  /// </summary>\r\n  clearFlagsForRealOnly(aFlags: number): void {\r\n    for (let i: number = 0; i < this._flags.length; i = i + 1) {\r\n      let field: Field = <Field>this.getFieldsTab().getField(i);\r\n      if (!field.IsVirtual) {\r\n        this.clearFlag(i, aFlags);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   clear a specific field flag from the history\r\n  /// </summary>\r\n  clearHistoryFlag(fldIdx: number): void {\r\n    if (this._flagsHistory !== null && fldIdx < this.getFieldsTab().getSize() && fldIdx >= 0) {\r\n      this._flagsHistory[fldIdx] = 0;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   check the existence of the flags and the validity of the field index\r\n  ///   throws an error in case of a failure\r\n  /// </summary>\r\n  /// <param name = \"fldIdx\">the index of the field</param>\r\n  checkFlags(fldIdx: number): void {\r\n    if (this._flags === null || fldIdx >= this.getFieldsTab().getSize() || fldIdx < 0) {\r\n      throw new ApplicationException(\"Cannot find flags\");\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   restart the record's settings. This might be needed after a server's rollback\r\n  ///   or restart\r\n  /// </summary>\r\n  /// <param name = \"oldMode\">the old record mode</param>\r\n  restart(oldMode: DataModificationTypes): void {\r\n    let task: Task = <Task>this._dataview.getTask();\r\n\r\n    if (oldMode === DataModificationTypes.None) {\r\n      let rec: Record = this._dataview.getCurrRec();\r\n      let isCurrRec: boolean = (rec != null && rec.getId() === this._id);\r\n\r\n      if ((this._dataview.getTask()).getMode() === Constants.TASK_MODE_CREATE)\r\n        if (isCurrRec && !task.getAfterRetry() && task.TryingToCommit && !this._dataview.inRollback())\r\n          oldMode = DataModificationTypes.Update;\r\n        else oldMode = DataModificationTypes.Insert;\r\n\r\n      else oldMode = DataModificationTypes.Update;\r\n    }\r\n    this.setMode(oldMode);\r\n    if (oldMode === DataModificationTypes.Insert)\r\n      this.setNewRec();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   sets the value of lateCompute flag\r\n  /// </summary>\r\n  /// <param name = \"val\">the new value of the flag</param>\r\n  setLateCompute(val: boolean): void {\r\n    this._lateCompute = val;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the value of the \"lateCompute\" flag\r\n  /// </summary>\r\n  lateCompute(): boolean {\r\n    return this._lateCompute;\r\n  }\r\n\r\n  /// <summary>\r\n  /// \"in delete process\" flag\r\n  /// </summary>\r\n  /// <param name=\"val\"></param>\r\n  setInDeleteProcess(val: boolean): void {\r\n    this._inDeleteProcess = val;\r\n  }\r\n\r\n  inDeleteProcess(): boolean {\r\n    return this._inDeleteProcess;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   call this function when removing the record, it will decrease the reference count\r\n  ///   of its data controls to their dcValues\r\n  /// </summary>\r\n  removeRecFromDc(): void {\r\n    if (this._dcRefs !== null) {\r\n      this._dcRefs.Dispose();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   compare the data of this record with the data of a different record\r\n  /// </summary>\r\n  /// <param name = \"rec\">the other record</param>\r\n  /// <param name = \"currRec\">TRUE if we are comparing two 'current records' otherwise should be false.</param>\r\n  /// <param name = \"checkOnlyParetOfDataview\">FALSE if we want to check all the fields , including those that are not part of data view.</param>\r\n  isSameRecData(rec: Record, currRec: boolean, checkOnlyParetOfDataview: boolean): boolean {\r\n    let size: number = this.getSizeFld(currRec);\r\n    let start: number = this.getFromFldIdx(currRec);\r\n    let i: number;\r\n    let field: Field;\r\n\r\n    // compare references\r\n    if (this === rec)\r\n      return true;\r\n\r\n    try {\r\n      if (rec.getSizeFld(currRec) !== size)\r\n        return false;\r\n\r\n      if (rec.getFromFldIdx(currRec) !== start)\r\n        return false;\r\n\r\n      for (i = 0; i < start + size; i++) {\r\n        field = <Field>this.getFieldsTab().getField(i);\r\n\r\n        if (checkOnlyParetOfDataview && !field.PartOfDataview)\r\n          continue;\r\n\r\n        if (!this.fldValsEqual(rec, i))\r\n          return false;\r\n      }\r\n    }\r\n    catch (err) {\r\n      if (err instanceof ApplicationException)\r\n        return false;\r\n      throw  err;\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   compare two field values between this record and the given record\r\n  /// </summary>\r\n  /// <param name = \"rec\">the record to compare with</param>\r\n  /// <param name = \"fldIdx\">the index of the field to compare</param>\r\n  fldValsEqual(rec: Record, fldIdx: number): boolean {\r\n    let type: StorageAttribute = this.getFieldsTab().getField(fldIdx).getType();\r\n    return ExpressionEvaluator.mgValsEqual(this.GetFieldValue(fldIdx), this.IsNull(fldIdx), type, rec.GetFieldValue(fldIdx), rec.IsNull(fldIdx), type);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns hash key object of this record\r\n  /// </summary>\r\n  getHashKey(): number {\r\n    return this._hashKey;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   sets the reference to the records after this one, in a list of recs.\r\n  /// </summary>\r\n  /// <param name = \"nextRec\">is the next record (or null for the last record)</param>\r\n  setNextRec(nextRec: Record): void {\r\n    this._next = nextRec;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   sets the reference to the records before this one, in a list of recs.\r\n  /// </summary>\r\n  /// <param name = \"prevRec\">is the previous record (or null for the first record)</param>\r\n  setPrevRec(prevRec: Record): void {\r\n    this._prev = prevRec;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the record whose location is before this one\r\n  /// </summary>\r\n  getPrevRec(): Record {\r\n    return this._prev;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the record which follows this one\r\n  /// </summary>\r\n  getNextRec(): Record {\r\n    return this._next;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return DcRefs\r\n  /// </summary>\r\n  getDcRefs(): ObjectReferencesCollection {\r\n    return this._dcRefs.Clone();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set DcRefs\r\n  /// </summary>\r\n  setDcRefs(newDcRefs: ObjectReferencesCollection): void {\r\n    this.removeRecFromDc();\r\n    this._dcRefs = newDcRefs.Clone();\r\n    this.SetDcValueId();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if one of the real variables was modified\r\n  /// </summary>\r\n  realModified(): boolean {\r\n    let bRc: boolean = false;\r\n    let tabSize: number = this.getFieldsTab().getSize();\r\n    let j: number;\r\n\r\n    for (j = 0; j < tabSize; j++) {\r\n      // for every modified field check if it is a real field\r\n      if ((this._flags[j] & Record.FLAG_MODIFIED) === Record.FLAG_MODIFIED) {\r\n        if (!((<Field>this.getFieldsTab().getField(j)).IsVirtual)) {\r\n          bRc = true; // if a real modified field was found, return with true\r\n          break;\r\n        }\r\n      }\r\n    }\r\n    return bRc;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the xml representation of the record - this method is defined so we\r\n  ///   can use the record reference in a string concatenation operations and print calls\r\n  /// </summary>\r\n  ToString(): string {\r\n    let str: StringBuilder = new StringBuilder();\r\n    this.buildXML(str, (this._dataview.getCurrRec()).getId() === this._id, true);\r\n    return str.ToString();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the value of the sendToServer flag\r\n  /// </summary>\r\n  setSendToServer(val: boolean): void {\r\n    this._sendToServer = val;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the size in kb of the records e.i. the sum of all fields in the record\r\n  /// </summary>\r\n  getRecSize(): number {\r\n    let sum: number = 0;\r\n\r\n    for (let i: number = 0; i < this.getFieldsTab().getSize(); i = i + 1) {\r\n      let field: Field = <Field>this.getFieldsTab().getField(i);\r\n      sum = sum + field.getSize();\r\n    }\r\n    return sum;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   copy the modified crsr flags from a given rec.\r\n  /// </summary>\r\n  /// <param name = \"rec\">the source record</param>\r\n  copyCrsrModifiedFlags(rec: Record): void {\r\n    let tabSize: number = this.getFieldsTab().getSize();\r\n    let j: number;\r\n\r\n    for (j = 0; j < tabSize; j++) {\r\n      this._flags[j] = rec._flags[j];\r\n      this._flags[j] = this._flags[j] & Record.FLAG_CRSR_MODIFIED;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   for a table cache record returns the record's db_pos value as a base64 string\r\n  /// </summary>\r\n  getDbPosVal(): string {\r\n    return this._dbPosBase64Val;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   build the string that represent the current links fields db_pos values\r\n  /// </summary>\r\n  buildLinksPosStr(): void {\r\n    let tbl: DataviewHeaders = (<Task>this._dataview.getTask()).getDataviewHeaders();\r\n    if (tbl !== null) {\r\n      this._linksFldsPos = tbl.buildDbPosString();\r\n    }\r\n  }\r\n\r\n  setForceSaveOrg(val: boolean): void {\r\n    this._forceSaveOrg = val;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the relinked flag\r\n  /// </summary>\r\n  getForceSaveOrg(): boolean {\r\n    return this._forceSaveOrg;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   true, if exit from this record will cause invalidation of the table due to vitrual recompute\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  isCauseInvalidation(): boolean {\r\n    return this._causeInvalidation;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   if causeInvalidation is true,  exit from this record will cause invalidation of the table due to vitrual recompute\r\n  /// </summary>\r\n  /// <param name = \"causeInvalidation\"></param>\r\n  setCauseInvalidation(causeInvalidation: boolean): void {\r\n    this._causeInvalidation = causeInvalidation;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the value of the \"computed\" flag\r\n  /// </summary>\r\n  isComputed(): boolean {\r\n    return this._computed;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the value of the \"computed\" flag\r\n  /// </summary>\r\n  /// <param name = \"val\">the new value of the flag</param>\r\n  setComputed(val: boolean): void {\r\n    this._computed = val;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the value of the \"in compute\" flag\r\n  /// </summary>\r\n  /// <param name = \"val\">the new value of the flag</param>\r\n  setInCompute(val: boolean): void {\r\n    if (!val)\r\n      this.setComputed(true);\r\n    this._inCompute = val;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the value of the \"in recompute\" flag\r\n  /// </summary>\r\n  /// <param name = \"val\">the new value of the flag</param>\r\n  setInRecompute(val: boolean): void {\r\n    this._inRecompute = val;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the mode\r\n  /// </summary>\r\n  /// <param name = \"newMode\">the new mode: Created, Modified, Deleted</param>\r\n  setMode(newMode: DataModificationTypes): void {\r\n    switch (newMode) {\r\n      case DataModificationTypes.None:\r\n      case DataModificationTypes.Insert:\r\n      case DataModificationTypes.Update:\r\n      case DataModificationTypes.Delete:\r\n        if (this._mode === DataModificationTypes.None ||\r\n          this._mode === DataModificationTypes.Update && newMode === DataModificationTypes.Delete)\r\n          this._mode = newMode;\r\n        break;\r\n      default:\r\n        Logger.Instance.WriteExceptionToLogWithMsg(\"in Record.setMode(): illegal mode: \" + newMode);\r\n        break;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the record mode to \"none\"\r\n  /// </summary>\r\n  clearMode(): void {\r\n    this._mode = DataModificationTypes.None;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   switch off the newRec flag\r\n  /// </summary>\r\n  setOldRec(): void {\r\n    this._newRec = false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   switch on the newRec flag\r\n  /// </summary>\r\n  setNewRec(): void {\r\n    this._newRec = true;\r\n  }\r\n\r\n\r\n\r\n  /// <summary>\r\n  ///   serialize an item (field/global param/...).\r\n  /// </summary>\r\n  /// <param name = \"val\">item's value</param>\r\n  /// <param name = \"itemAttr\">item's attribute</param>\r\n  /// <param name = \"cellAttr\">cell's attribute - relevant only if 'itemAttr' is vector</param>\r\n  /// <param name = \"ToBase64\">>decide Base64 encoding is to be done</param>\r\n  /// <returns>serialized itemVal </returns>\r\n  static serializeItemVal(itemVal: string, itemAttr: StorageAttribute, cellAttr: StorageAttribute, ToBase64: boolean): string {\r\n    return RecordUtils.serializeItemVal(itemVal, itemAttr, cellAttr, ToBase64);\r\n  }\r\n\r\n  /// <summary>\r\n  /// sets DCVal Id into MgControls\r\n  /// </summary>\r\n  SetDcValueId(): void {\r\n    let form: MgForm = <MgForm>this._dataview.getTask().getForm();\r\n    let mgControl: MgControl = null;\r\n\r\n    // if the form doesn't have any selection control, dcRefs would be null\r\n    if (form != null && this._dcRefs != null) {\r\n\r\n      this._dcRefs.Refs.forEach((dcRef: DcValuesReference) => {\r\n        mgControl = <MgControl>form.getCtrl(dcRef.ditIdx);\r\n        if (mgControl != null)\r\n          mgControl.setDcValId(dcRef.DcValues.getId());\r\n      });\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// reset the DCVal Id in MgControls\r\n  /// </summary>\r\n  resetDcValueId(): void {\r\n    let form: MgForm = <MgForm>this._dataview.getTask().getForm();\r\n    let mgControl: MgControl = null;\r\n\r\n    // if the form doesn't have any selection control, dcRefs would be null\r\n    if (form != null && this._dcRefs != null) {\r\n      this._dcRefs.Refs.forEach(function (dcRef: DcValuesReference) {\r\n        mgControl = <MgControl>form.getCtrl(dcRef.ditIdx);\r\n        if (mgControl != null)\r\n          mgControl.setDcValId(EMPTY_DCREF);\r\n      });\r\n    }\r\n  }\r\n\r\n  AddDcValuesReference(controlId: number, dcValuesId: number): void {\r\n    let dcValues: DcValues = this._dataview.getDcValues(dcValuesId);\r\n    let dcRef: DcValuesReference = new DcValuesReference(controlId, dcValues);\r\n    if (this._dcRefs === null) {\r\n      this._dcRefs = new ObjectReferencesCollection();\r\n    }\r\n    this._dcRefs.Add(dcRef);\r\n  }\r\n}\r\n\r\n/// <summary>\r\n/// This class represents a link between a data control and its DcValues object.\r\n/// </summary>\r\nexport class DcValuesReference extends ObjectReferenceBase {\r\n  ditIdx: number = 0;\r\n\r\n\r\n  /// <summary>\r\n  /// Gets the referenced DcValues.\r\n  /// </summary>\r\n  get DcValues(): DcValues {\r\n    return <DcValues>this.Referent;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   CTOR\r\n  /// </summary>\r\n  /// <param name = \"couple\">a string that represents the ditIdx & dcId separated by a comma</param>\r\n  constructor(controlId: number, referencedDcValues: DcValues) {\r\n    super(referencedDcValues);\r\n    this.ditIdx = controlId;\r\n  }\r\n\r\n  Clone(): ObjectReferenceBase {\r\n    return new DcValuesReference(this.ditIdx, <DcValues>this.Referent);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Creates a new DcValuesReference from a string containing two integers, where the\r\n  /// first is the index of the control in the form (dit index) and the second is the\r\n  /// DcValues object identifier.\r\n  /// </summary>\r\n  /// <param name=\"couple\"></param>\r\n  /// <param name=\"dcValuesOwner\"></param>\r\n  /// <returns></returns>\r\n  static Parse(couple: string, dcValuesOwner: DataViewBase): DcValuesReference {\r\n    let commaPos: number = couple.indexOf(\",\");\r\n\r\n    let controlId: number = NNumber.Parse(couple.substr(0, commaPos));\r\n    let dcId: number = NNumber.Parse(couple.substr(commaPos + 1));\r\n\r\n    return new DcValuesReference(controlId, dcValuesOwner.getDcValues(dcId));\r\n  }\r\n}\r\n"]}