@magic-xpa/gui 4.1100.0-dev4110.25 → 4.1100.0-dev4110.252

package/esm2022/src/management/data/VectorType.mjs

@@ -0,0 +1,612 @@
+import { ApplicationException, Encoding, ISO_8859_1_Encoding, List, NNumber, NString, StringBuilder } from '@magic-xpa/mscorelib';
+import { BlobType } from './BlobType';
+import { StorageAttribute, StorageAttributeCheck, StrUtil, UtilStrByteMode } from '@magic-xpa/utils';
+import { DisplayConvertor } from '../gui/DisplayConvertor';
+import { RecordUtils } from './RecordUtils';
+import { GuiConstants } from '../../GuiConstants';
+import { GuiEnvironment } from '../../GuiEnvironment';
+import { VectorTypeBase } from './VectorTypeBase';
+export class VectorType extends VectorTypeBase {
+    static VERSION = 5;
+    static EMPTY_BLOB_PREFIX_LEN = 7;
+    static BLOB_TYPE_STRUCT_SIZE = 28;
+    _cells = null;
+    _encoding = null;
+    _allowNull = false;
+    _cellContentType = null;
+    _cellSize = 0;
+    _cellsAttr = null;
+    _cellsDefaultVal = null;
+    _cellsIsNullDefault = false;
+    _dataBuf = null;
+    _initialized = false;
+    _nullBuf = null;
+    _originalflatData = null;
+    constructor(cellsTypeOrBlobStringOrFld, contentType, defualt, isDefNull, nullAlowed, length) {
+        super();
+        if (arguments.length === 6)
+            this.constructor_0(cellsTypeOrBlobStringOrFld, contentType, defualt, isDefNull, nullAlowed, length);
+        else if (arguments.length === 1 && (cellsTypeOrBlobStringOrFld === null || cellsTypeOrBlobStringOrFld.constructor === String))
+            this.constructor_1(cellsTypeOrBlobStringOrFld);
+        else
+            this.constructor_2(cellsTypeOrBlobStringOrFld);
+    }
+    constructor_0(cellsType, contentType, defualt, isDefNull, nullAlowed, length) {
+        this._cells = new List();
+        this._cellsAttr = cellsType;
+        this._cellContentType = contentType;
+        this._cellsDefaultVal = defualt;
+        this._cellsIsNullDefault = isDefNull;
+        this._cellSize = ((this._cellsAttr === StorageAttribute.UNICODE) ? (length * 2) : length);
+        this._initialized = true;
+        this._allowNull = nullAlowed;
+        this._nullBuf = new StringBuilder();
+        this._dataBuf = new StringBuilder();
+        this._originalflatData = this.toString();
+        this._encoding = GuiEnvironment.Environment.GetEncoding();
+    }
+    constructor_1(blobString) {
+        this._cells = new List();
+        this._initialized = false;
+        this._originalflatData = blobString;
+        this._encoding = GuiEnvironment.Environment.GetEncoding();
+    }
+    constructor_2(fld) {
+        this._cells = new List();
+        this._cellsAttr = fld.getCellsType();
+        this._cellContentType = fld.getVecCellsContentType();
+        this._cellsDefaultVal = fld.getCellDefualtValue();
+        this._cellsIsNullDefault = fld.isNullDefault();
+        this._cellSize = ((this._cellsAttr === StorageAttribute.UNICODE) ? (fld.getVecCellsSize() * 2) : fld.getVecCellsSize());
+        this._initialized = true;
+        this._allowNull = fld.NullAllowed;
+        this._nullBuf = new StringBuilder();
+        this._dataBuf = new StringBuilder();
+        this._originalflatData = this.toString();
+        this._encoding = GuiEnvironment.Environment.GetEncoding();
+    }
+    init() {
+        let tokens = null;
+        let tokenIdx = 0;
+        let currentToken = null;
+        let isFlatDataTranslated = this.isUnicode(this._originalflatData);
+        let isDbcsAlpha = false;
+        let pos = BlobType.blobPrefixLength(this._originalflatData);
+        tokens = StrUtil.tokenize(this._originalflatData.substr(pos), ",");
+        let vecSize = 0;
+        if (!this._initialized) {
+            if (VectorType.validateBlobContents(this._originalflatData)) {
+                let blobPrefix = BlobType.getPrefix(this._originalflatData);
+                this._cellContentType = BlobType.getContentType(blobPrefix);
+                pos = (pos + 4 + 5 + 1);
+                tokenIdx++;
+                currentToken = tokens[tokenIdx];
+                pos = pos + (currentToken.length + 1);
+                tokenIdx++;
+                currentToken = tokens[tokenIdx];
+                pos = pos + (currentToken.length + 1);
+                tokenIdx++;
+                currentToken = tokens[tokenIdx];
+                this._cellsAttr = currentToken.charAt(0);
+                pos = pos + 2;
+                tokenIdx++;
+                currentToken = tokens[tokenIdx];
+                this._cellSize = NNumber.Parse(currentToken);
+                pos = pos + (currentToken.length + 1);
+                if (this._cellsAttr === StorageAttribute.NUMERIC || this._cellsAttr === StorageAttribute.DATE || this._cellsAttr === StorageAttribute.TIME)
+                    this._cellsDefaultVal = StrUtil.stringToHexaDump(this._originalflatData.substr(pos, this._cellSize), 2);
+                else if (this._cellsAttr === StorageAttribute.ALPHA || this._cellsAttr === StorageAttribute.MEMO) {
+                    if (UtilStrByteMode.isLocaleDefLangDBCS()) {
+                        isDbcsAlpha = true;
+                        isFlatDataTranslated = true;
+                        this._cellsDefaultVal = UtilStrByteMode.leftB(this._originalflatData.substr(pos), this._cellSize);
+                    }
+                    else
+                        this._cellsDefaultVal = this._originalflatData.substr(pos, this._cellSize);
+                    if (this._encoding !== null && !isFlatDataTranslated) {
+                        try {
+                            let ba = ISO_8859_1_Encoding.ISO_8859_1.GetBytes(this._cellsDefaultVal);
+                            this._cellsDefaultVal = this._encoding.GetString(ba, 0, ba.length);
+                        }
+                        catch (Exception) {
+                        }
+                    }
+                }
+                else if (this._cellsAttr === StorageAttribute.UNICODE) {
+                    this._cellsDefaultVal = this._originalflatData.substr(pos, this._cellSize);
+                    try {
+                        let ba = ISO_8859_1_Encoding.ISO_8859_1.GetBytes(this._cellsDefaultVal);
+                        this._cellsDefaultVal = Encoding.Unicode.GetString(ba, 0, ba.length);
+                    }
+                    catch (Exception) {
+                    }
+                }
+                else
+                    this._cellsDefaultVal = this._originalflatData.substr(pos, this._cellSize);
+                if (isDbcsAlpha)
+                    pos = pos + this._cellsDefaultVal.length + 1;
+                else
+                    pos = (pos + this._cellSize + 1);
+                tokens = StrUtil.tokenize(this._originalflatData.substr(pos), ",");
+                tokenIdx = 0;
+                currentToken = tokens[tokenIdx];
+                this._cellsIsNullDefault = DisplayConvertor.toBoolean(currentToken);
+                pos = pos + (currentToken.length + 1);
+                tokenIdx++;
+                currentToken = tokens[tokenIdx];
+                this._allowNull = DisplayConvertor.toBoolean(currentToken);
+                pos = pos + (currentToken.length + 1);
+                tokenIdx++;
+                currentToken = tokens[tokenIdx];
+                pos = pos + (currentToken.length + 1);
+                tokenIdx++;
+                currentToken = tokens[tokenIdx];
+                vecSize = NNumber.Parse(currentToken);
+                pos = pos + (currentToken.length + 1);
+                tokenIdx++;
+                currentToken = tokens[tokenIdx];
+                pos = pos + (currentToken.length + 1);
+                if (this._cellsAttr === StorageAttribute.BLOB || this._cellsAttr === StorageAttribute.BLOB_VECTOR) {
+                    tokenIdx++;
+                    currentToken = tokens[tokenIdx];
+                    pos = pos + (currentToken.length + 1);
+                }
+                let data;
+                if (isDbcsAlpha) {
+                    data = UtilStrByteMode.leftB(this._originalflatData.substr(pos), (vecSize * this._cellSize));
+                    pos = pos + data.length + 1;
+                }
+                else {
+                    data = this._originalflatData.substr(pos, (vecSize * this._cellSize));
+                    pos = (pos + vecSize * this._cellSize + 1);
+                }
+                this._dataBuf = new StringBuilder(data.length);
+                if (this._cellsAttr !== StorageAttribute.ALPHA && this._cellsAttr !== StorageAttribute.MEMO && this._cellsAttr !== StorageAttribute.UNICODE)
+                    this._dataBuf.Append(data);
+                let nullBuf = this._originalflatData.substr(pos, vecSize);
+                pos = (pos + vecSize + 1);
+                this._nullBuf = new StringBuilder(nullBuf);
+                if (this._cellsAttr !== StorageAttribute.BLOB && this._cellsAttr !== StorageAttribute.BLOB_VECTOR) {
+                    for (let i = 0; i < vecSize; i++) {
+                        let isNull = nullBuf.charAt(i) > '\0';
+                        if (this._cellsAttr === StorageAttribute.NUMERIC || this._cellsAttr === StorageAttribute.DATE || this._cellsAttr === StorageAttribute.TIME)
+                            this._cells.push(new CellElement(StrUtil.stringToHexaDump(data.substr((i * this._cellSize), this._cellSize), 2), isNull));
+                        else if (this._cellsAttr === StorageAttribute.ALPHA || this._cellsAttr === StorageAttribute.MEMO) {
+                            let cellData;
+                            if (isDbcsAlpha)
+                                cellData = UtilStrByteMode.midB(data, (i * this._cellSize), this._cellSize);
+                            else
+                                cellData = data.substr((i * this._cellSize), this._cellSize);
+                            if (this._encoding !== null && !isFlatDataTranslated) {
+                                try {
+                                    let ba = ISO_8859_1_Encoding.ISO_8859_1.GetBytes(cellData);
+                                    cellData = this._encoding.GetString(ba, 0, ba.length);
+                                }
+                                catch (SystemException) {
+                                }
+                            }
+                            this._dataBuf.Append(cellData);
+                            this._cells.push(new CellElement(cellData, isNull));
+                        }
+                        else if (this._cellsAttr === StorageAttribute.UNICODE) {
+                            let cellData = data.substr((i * this._cellSize), this._cellSize);
+                            try {
+                                let ba = ISO_8859_1_Encoding.ISO_8859_1.GetBytes(cellData);
+                                cellData = Encoding.Unicode.GetString(ba, 0, ba.length);
+                            }
+                            catch (SystemException) {
+                            }
+                            this._dataBuf.Append(cellData);
+                            this._cells.push(new CellElement(cellData, isNull));
+                        }
+                        else
+                            this._cells.push(new CellElement(data.substr((i * this._cellSize), this._cellSize), isNull));
+                    }
+                }
+                else {
+                    for (let i = 0; i < vecSize; i++) {
+                        tokens = StrUtil.tokenize(this._originalflatData.substr(pos), ",");
+                        tokenIdx = 0;
+                        tokenIdx++;
+                        currentToken = tokens[tokenIdx];
+                        let size = NNumber.Parse(currentToken);
+                        pos = pos + (currentToken.length + 1);
+                        let blobHeader = "";
+                        for (let j = 0; j < GuiConstants.BLOB_PREFIX_ELEMENTS_COUNT; j++) {
+                            tokenIdx++;
+                            currentToken = tokens[tokenIdx];
+                            blobHeader = blobHeader + currentToken;
+                            pos = pos + (currentToken.length + 1);
+                            if (j !== GuiConstants.BLOB_PREFIX_ELEMENTS_COUNT - 1) {
+                                blobHeader = blobHeader + ",";
+                            }
+                        }
+                        let cellData = this._originalflatData.substr(pos, size);
+                        let isNull = nullBuf.charAt(i) > '\0';
+                        this._cells.push(new CellElement(cellData, isNull, blobHeader));
+                        pos = (pos + size + 1);
+                    }
+                }
+                if (this._dataBuf.Length === 0)
+                    this._dataBuf = new StringBuilder(data.length);
+                this._initialized = true;
+            }
+            else
+                throw new ApplicationException("in VectorType.init wrong vector format");
+        }
+    }
+    toString() {
+        let res = "";
+        if (this._initialized) {
+            res = res + 0 + "," + 0 + "," + "0" + "," + this._cellsAttr + "," + this._cellContentType + ";";
+            res = res + this.buildHeadersString();
+            if (this._cellsAttr === StorageAttribute.UNICODE) {
+                let dataBufCharArry = new Array(this._dataBuf.Length * 2);
+                for (let i = 0; i < this._dataBuf.Length; i = i + 1) {
+                    dataBufCharArry[i * 2] = String.fromCharCode((this._dataBuf.get_Item(i).charCodeAt(0)) % 256);
+                    dataBufCharArry[i * 2 + 1] = String.fromCharCode((this._dataBuf.get_Item(i).charCodeAt(0)) / 256);
+                }
+                res = res + NString.FromChars(dataBufCharArry) + ",";
+            }
+            else
+                res = res + this._dataBuf + ",";
+            res = res + this._nullBuf + ",";
+            if (this._cellsAttr === StorageAttribute.BLOB || this._cellsAttr === StorageAttribute.BLOB_VECTOR)
+                res = res + this.getBlobsBuf();
+            res = res + VectorType.BLOB_TABLE_STR;
+        }
+        else
+            res = this._originalflatData;
+        return res;
+    }
+    getCellsAttr() {
+        if (!this._initialized)
+            return VectorType.getCellsAttr(this._originalflatData);
+        else
+            return this._cellsAttr;
+    }
+    getCellSize() {
+        let retVal;
+        if (!this._initialized)
+            retVal = VectorType.getCellSize(this._originalflatData);
+        else
+            retVal = this._cellSize;
+        if (this.getCellsAttr() === StorageAttribute.UNICODE)
+            retVal = Math.floor(retVal / 2);
+        return retVal;
+    }
+    getVecSize() {
+        if (!this._initialized)
+            return VectorType.getVecSize(this._originalflatData);
+        else
+            return this._cells.length;
+    }
+    getVecCell(idx) {
+        let retVal = null;
+        if (idx > 0) {
+            this.init();
+            if (idx <= this.getVecSize()) {
+                retVal = this._cells.get_Item(idx - 1).data;
+                if (this._cellsAttr === StorageAttribute.BLOB || this._cellsAttr === StorageAttribute.BLOB_VECTOR)
+                    retVal = this._cells.get_Item(idx - 1).blobFieldPrefix + ";" + retVal;
+                if (StorageAttributeCheck.isTypeLogical(this._cellsAttr))
+                    retVal = ((retVal.charAt(0) === '\0') ? "0" : "1");
+                if (this._cells.get_Item(idx - 1).isNull)
+                    retVal = null;
+            }
+            else if (!this._cellsIsNullDefault)
+                retVal = this._cellsDefaultVal;
+        }
+        return retVal;
+    }
+    GetCellValues() {
+        let retVal = null;
+        let cellValues = null;
+        this.init();
+        if (this.getVecSize() > 0) {
+            cellValues = new Array(this.getVecSize());
+            for (let idx = 0; idx < this.getVecSize(); idx++) {
+                retVal = this._cells.get_Item(idx).data;
+                if (this._cellsAttr === StorageAttribute.BLOB || this._cellsAttr === StorageAttribute.BLOB_VECTOR)
+                    retVal = this._cells.get_Item(idx).blobFieldPrefix + ";" + retVal;
+                if (StorageAttributeCheck.isTypeLogical(this._cellsAttr))
+                    retVal = ((retVal.charAt(0) === '\0') ? "0" : "1");
+                if (this._cells.get_Item(idx).isNull)
+                    retVal = null;
+                cellValues[idx] = retVal;
+            }
+        }
+        else if (!this._cellsIsNullDefault) {
+            cellValues = [
+                this._cellsDefaultVal
+            ];
+        }
+        return cellValues;
+    }
+    setVecCell(idx, newValue, isNull) {
+        let res = false;
+        let createBufferValForNumType = true;
+        try {
+            if (idx > 0) {
+                this.init();
+                let localCellSize = (this._cellsAttr === StorageAttribute.UNICODE) ? Math.floor(this._cellSize / 2) : this._cellSize;
+                if (isNull && !this._allowNull) {
+                    isNull = false;
+                    newValue = this._cellsDefaultVal;
+                }
+                if (idx <= this._cells.length) {
+                    let curr = this._cells.get_Item(idx - 1);
+                    if (!isNull) {
+                        if (this._cellsAttr === StorageAttribute.BLOB || this._cellsAttr === StorageAttribute.BLOB_VECTOR) {
+                            let blobPrefixLength = BlobType.blobPrefixLength(newValue);
+                            curr.blobFieldPrefix = newValue.substr(0, blobPrefixLength - 1);
+                            if (newValue.length > blobPrefixLength)
+                                curr.data = newValue.substr(blobPrefixLength);
+                            else
+                                curr.data = "";
+                        }
+                        else {
+                            if (StorageAttributeCheck.isTypeLogical(this._cellsAttr)) {
+                                curr.data = (DisplayConvertor.toBoolean(newValue) ? new StringBuilder().Append(1).ToString() : new StringBuilder().Append('\0').ToString());
+                                newValue = curr.data;
+                            }
+                            else
+                                curr.data = newValue;
+                            let dataBufVal = newValue;
+                            if (this._cellsAttr === StorageAttribute.NUMERIC || this._cellsAttr === StorageAttribute.DATE || this._cellsAttr === StorageAttribute.TIME)
+                                dataBufVal = RecordUtils.byteStreamToString(dataBufVal);
+                            if (UtilStrByteMode.isLocaleDefLangDBCS() && (this._cellsAttr === StorageAttribute.ALPHA || this._cellsAttr === StorageAttribute.MEMO)) {
+                                let baDataBuf = this._encoding.GetBytes(this._dataBuf.ToString());
+                                let baDataBufVal = this._encoding.GetBytes(dataBufVal);
+                                for (let i = 0; i < baDataBufVal.length && i < localCellSize; i++)
+                                    baDataBuf[((idx - 1) * localCellSize) + i] = baDataBufVal[i];
+                                for (let i = baDataBufVal.length; i < localCellSize; i++)
+                                    baDataBuf[((idx - 1) * localCellSize) + i] = ((this._cellsAttr === StorageAttribute.ALPHA) ? 32 : 0);
+                                this._dataBuf = new StringBuilder(this._encoding.GetString(baDataBuf, 0, baDataBuf.length));
+                                curr.data = this._encoding.GetString(baDataBuf, ((idx - 1) * localCellSize), localCellSize);
+                            }
+                            else {
+                                for (let i = 0; i < dataBufVal.length && i < localCellSize; i++)
+                                    this._dataBuf.set_Item(((idx - 1) * localCellSize) + i, dataBufVal.charAt(i));
+                                for (let i = dataBufVal.length; i < localCellSize; i++)
+                                    this._dataBuf.set_Item(((idx - 1) * localCellSize) + i, (this._cellsAttr === StorageAttribute.ALPHA || this._cellsAttr === StorageAttribute.UNICODE) ? ' ' : '\0');
+                                if (this._cellsAttr === StorageAttribute.ALPHA || this._cellsAttr === StorageAttribute.UNICODE || this._cellsAttr === StorageAttribute.MEMO)
+                                    curr.data = this._dataBuf.ToString().substr(((idx - 1) * localCellSize), localCellSize);
+                            }
+                        }
+                        this._nullBuf.set_Item(idx - 1, '\0');
+                        curr.isNull = false;
+                    }
+                    else {
+                        curr.data = null;
+                        if (this._cellsAttr === StorageAttribute.BLOB_VECTOR)
+                            curr.blobFieldPrefix = BlobType.getEmptyBlobPrefix('\u0001');
+                        else
+                            curr.blobFieldPrefix = BlobType.getEmptyBlobPrefix('\0');
+                        curr.isNull = true;
+                        this._nullBuf.set_Item(idx - 1, '\u0001');
+                        for (let i = 0; i < localCellSize; i++)
+                            this._dataBuf.set_Item(((idx - 1) * localCellSize) + i, '\0');
+                        this._nullBuf.set_Item(idx - 1, '\u0001');
+                    }
+                    res = true;
+                }
+                else {
+                    let insertVal;
+                    if (this._cellsAttr === StorageAttribute.BLOB || this._cellsAttr === StorageAttribute.BLOB_VECTOR) {
+                        if (this._cellsAttr === StorageAttribute.BLOB_VECTOR)
+                            insertVal = BlobType.getEmptyBlobPrefix('\u0001');
+                        else
+                            insertVal = BlobType.getEmptyBlobPrefix('\0');
+                        if (!this._cellsIsNullDefault)
+                            insertVal = insertVal + this._cellsDefaultVal;
+                    }
+                    else if (this._cellsIsNullDefault)
+                        insertVal = null;
+                    else
+                        insertVal = this._cellsDefaultVal;
+                    if (insertVal !== null && StorageAttributeCheck.isTypeLogical(this._cellsAttr))
+                        insertVal = (DisplayConvertor.toBoolean(insertVal) ? new StringBuilder().Append('\u0001').ToString() : new StringBuilder().Append('\0').ToString());
+                    let dataBufVal = insertVal;
+                    while (this._cells.length < idx) {
+                        if (this._cellsAttr === StorageAttribute.BLOB || this._cellsAttr === StorageAttribute.BLOB_VECTOR) {
+                            this._cells.push(new CellElement(insertVal.substr(VectorType.EMPTY_BLOB_PREFIX_LEN), this._cellsIsNullDefault, insertVal.substr(0, VectorType.EMPTY_BLOB_PREFIX_LEN)));
+                            this._dataBuf.Append(this.getNullString(VectorType.BLOB_TYPE_STRUCT_SIZE));
+                        }
+                        else {
+                            this._cells.push(new CellElement(insertVal, this._cellsIsNullDefault));
+                            if (insertVal !== null) {
+                                if (this._cellsAttr === StorageAttribute.NUMERIC || this._cellsAttr === StorageAttribute.DATE || this._cellsAttr === StorageAttribute.TIME) {
+                                    if (createBufferValForNumType) {
+                                        createBufferValForNumType = false;
+                                        dataBufVal = RecordUtils.byteStreamToString(insertVal);
+                                    }
+                                }
+                                this._dataBuf.Append(dataBufVal);
+                                let valLen;
+                                if (UtilStrByteMode.isLocaleDefLangDBCS() && (this._cellsAttr === StorageAttribute.ALPHA || this._cellsAttr === StorageAttribute.MEMO))
+                                    valLen = UtilStrByteMode.lenB(dataBufVal);
+                                else
+                                    valLen = dataBufVal.length;
+                                for (let i = valLen; i < localCellSize; i++)
+                                    this._dataBuf.Append((this._cellsAttr === StorageAttribute.ALPHA || this._cellsAttr === StorageAttribute.UNICODE) ? ' ' : '\0');
+                            }
+                            else
+                                this._dataBuf.Append(this.getNullString(localCellSize));
+                        }
+                        this._nullBuf.Insert(this._cells.length - 1, this._cellsIsNullDefault ? '\u0001' : '\0');
+                    }
+                    res = this.setVecCell(idx, newValue, isNull);
+                }
+            }
+        }
+        catch (ApplicationException) {
+            res = false;
+        }
+        return res;
+    }
+    adjustToFit(field) {
+        if (field.getType() === StorageAttribute.BLOB_VECTOR) {
+            let srcAttr = this.getCellsAttr();
+            let dstAttr = field.getCellsType();
+            if (StorageAttributeCheck.isTheSameType(srcAttr, dstAttr)) {
+                this.init();
+                if (StorageAttributeCheck.IsTypeAlphaOrUnicode(srcAttr) && StorageAttributeCheck.IsTypeAlphaOrUnicode(dstAttr)) {
+                    let dstSizeInChars = field.getVecCellsSize();
+                    let srcSizeInChars = ((this._cellsAttr === StorageAttribute.UNICODE) ? Math.floor(this._cellSize / 2) : this._cellSize);
+                    let isByteMode = UtilStrByteMode.isLocaleDefLangDBCS() && StorageAttributeCheck.isTypeAlpha(dstAttr);
+                    if (srcSizeInChars !== dstSizeInChars) {
+                        let adjData = new StringBuilder();
+                        for (let i = 0; i < dstSizeInChars; i = i + 1) {
+                            let curr = this._cells.get_Item(i);
+                            if (!curr.isNull) {
+                                if (srcSizeInChars > dstSizeInChars) {
+                                    if (isByteMode)
+                                        curr.data = UtilStrByteMode.leftB(curr.data, dstSizeInChars);
+                                    else
+                                        curr.data = curr.data.substr(0, dstSizeInChars);
+                                    adjData.Append(curr.data);
+                                }
+                                else {
+                                    let tmpData = new StringBuilder();
+                                    tmpData.Append(curr.data);
+                                    let dataLen = isByteMode ? UtilStrByteMode.lenB(curr.data) : curr.data.length;
+                                    for (let j = dataLen; j < dstSizeInChars; j = j + 1)
+                                        tmpData.Append(' ');
+                                    adjData.Append(tmpData.ToString());
+                                    curr.data = tmpData.ToString();
+                                }
+                            }
+                            else {
+                                let tmpData = new StringBuilder();
+                                for (let j = 0; j < dstSizeInChars; j = j + 1)
+                                    tmpData.Append('\0');
+                                adjData.Append(tmpData.ToString());
+                                curr.data = tmpData.ToString();
+                            }
+                        }
+                        this._dataBuf = adjData;
+                    }
+                }
+                let newSize = field.getVecCellsSize();
+                this._cellsAttr = field.getCellsType();
+                this._cellSize = ((this._cellsAttr === StorageAttribute.UNICODE) ? (newSize * 2) : newSize);
+                this._cellsDefaultVal = field.getCellDefualtValue();
+                this._cellsIsNullDefault = field.isNullDefault();
+                this._allowNull = field.NullAllowed;
+                this._originalflatData = this.toString();
+                return;
+            }
+            else
+                throw new ApplicationException("in VectorType.adjustToFit vector basic types does not agree");
+        }
+        else
+            throw new ApplicationException("in  VectorType.adjustToFit " + field.getName() + " is not of type vector");
+    }
+    buildHeadersString() {
+        let res = VectorType.BLOB_TABLE_STR + VectorType.VECTOR_STR + "," + VectorType.VERSION + "," + 1 + "," + this._cellsAttr + ",";
+        res = res + this._cellSize + ",";
+        let def = "";
+        if (this._cellsDefaultVal !== null)
+            if (this._cellsAttr === StorageAttribute.NUMERIC || this._cellsAttr === StorageAttribute.DATE || this._cellsAttr === StorageAttribute.TIME)
+                def = RecordUtils.byteStreamToString(this._cellsDefaultVal);
+            else
+                def = this._cellsDefaultVal;
+        if (UtilStrByteMode.isLocaleDefLangDBCS() && (this._cellsAttr === StorageAttribute.ALPHA || this._cellsAttr === StorageAttribute.MEMO))
+            def = def + this.getEmptyString(this._cellSize - UtilStrByteMode.lenB(def));
+        else
+            def = def + this.getEmptyString(this._cellSize - def.length);
+        res = res + def + "," + (this._cellsIsNullDefault ? "1" : "0") + ",";
+        res = res + (this._allowNull ? "1" : "0") + "," + this._cellSize + "," + this._cells.length + ",";
+        res = res + ((this._cellsAttr === StorageAttribute.BLOB || this._cellsAttr === StorageAttribute.BLOB_VECTOR) ? "1" : "0") + ",";
+        if (this._cellsAttr === StorageAttribute.BLOB || this._cellsAttr === StorageAttribute.BLOB_VECTOR)
+            res = res + "0,";
+        return res;
+    }
+    getNullString(size) {
+        let res = new StringBuilder();
+        for (let i = 0; i < size; i = i + 1)
+            res.Append('\0');
+        return res.ToString();
+    }
+    getEmptyString(size) {
+        let res = new StringBuilder();
+        for (let i = 0; i < size; i = i + 1)
+            res.Append(' ');
+        return res.ToString();
+    }
+    getBlobsBuf() {
+        let res = new StringBuilder();
+        for (let i = 0; i < this._cells.length; i = i + 1) {
+            let data = "";
+            let blobSize = 0;
+            let curr = this._cells.get_Item(i);
+            if (curr.data !== null) {
+                data = curr.data;
+                blobSize = data.length;
+            }
+            res.Append(blobSize);
+            res.Append("," + curr.blobFieldPrefix + "," + data + ";");
+        }
+        return (res + ",");
+    }
+    static getCellsAttr(blob) {
+        if (VectorType.validateBlobContents(blob)) {
+            let tokens = StrUtil.tokenize(blob.substr(BlobType.blobPrefixLength(blob)), ",");
+            return tokens[3].charAt(0);
+        }
+        else
+            throw new ApplicationException("in static getCellsAttr the blob is in the wrong format");
+    }
+    static getCellSize(blob) {
+        let cellsType = VectorType.getCellsAttr(blob);
+        if (cellsType !== StorageAttribute.BLOB && cellsType !== StorageAttribute.BLOB_VECTOR) {
+            let tokens = StrUtil.tokenize(blob.substr(BlobType.blobPrefixLength(blob)), ",");
+            return NNumber.Parse(tokens[4]);
+        }
+        else {
+            return 2147483647;
+        }
+    }
+    static getVecSize(blob) {
+        if (VectorType.validateBlobContents(blob)) {
+            let pos = BlobType.blobPrefixLength(blob);
+            let tokens = StrUtil.tokenize(blob.substr(pos), ",");
+            pos = pos + (tokens[0].length + 1);
+            pos = pos + (tokens[1].length + 1);
+            pos = pos + (tokens[2].length + 1);
+            pos = pos + (tokens[3].length + 1);
+            let cellsSize = tokens[4];
+            pos = pos + (cellsSize.length + 1);
+            pos = pos + (NNumber.Parse(cellsSize) + 1);
+            tokens = StrUtil.tokenize(blob.substr(pos), ",");
+            return NNumber.Parse(tokens[3]);
+        }
+        throw new ApplicationException("in static getVecSize the blob is in the wrong format");
+    }
+    isUnicode(flatData) {
+        let start = BlobType.blobPrefixLength(flatData);
+        let catcher = flatData.substr(start, VectorType.BLOB_TABLE_STR_LEN);
+        return (catcher === VectorType.BLOB_TABLE_STR);
+    }
+}
+export class CellElement {
+    blobFieldPrefix = null;
+    data = null;
+    isNull = false;
+    constructor(val, is_null, ctrlData) {
+        if (arguments.length === 2)
+            this.constructor_0(val, is_null);
+        this.constructor_1(val, is_null, ctrlData);
+    }
+    constructor_0(val, is_null) {
+        this.data = val;
+        this.isNull = is_null;
+    }
+    constructor_1(val, is_null, ctrlData) {
+        this.data = val;
+        this.isNull = is_null;
+        this.blobFieldPrefix = ctrlData;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"VectorType.js","sourceRoot":"","sources":["../../../../../../../projects/gui/src/management/data/VectorType.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ApplicationException,\r\n  Encoding,\r\n  ISO_8859_1_Encoding,\r\n  List,\r\n  NNumber,\r\n  NString,\r\n  StringBuilder\r\n} from '@magic-xpa/mscorelib';\r\nimport { FieldDef } from './FieldDef';\r\nimport { BlobType } from './BlobType';\r\nimport { StorageAttribute, StorageAttributeCheck, StrUtil, UtilStrByteMode } from '@magic-xpa/utils';\r\nimport { DisplayConvertor } from '../gui/DisplayConvertor';\r\nimport { RecordUtils } from './RecordUtils';\r\nimport { GuiConstants } from '../../GuiConstants';\r\nimport { GuiEnvironment } from '../../GuiEnvironment';\r\nimport { VectorTypeBase } from './VectorTypeBase';\r\n\r\n\r\n/// <summary>\r\n///   represents the magic vector type\r\n/// </summary>\r\nexport class VectorType extends VectorTypeBase {\r\n\r\n  static VERSION: number = 5; // version no 5 includes the content field\r\n  static EMPTY_BLOB_PREFIX_LEN: number = 7;\r\n\r\n  // FOR EXPLANATIONS REGARDING THIS NUMBER PLEAS SEE DOCUMENTATION INSIDE init METHOD\r\n  static BLOB_TYPE_STRUCT_SIZE: number = 28;\r\n\r\n  private _cells: List<CellElement> = null; // a vector containing CellElements\r\n  private _encoding: Encoding = null; // to be used only with alpha or memo\r\n  private _allowNull: boolean = false;\r\n  private _cellContentType: string = null;\r\n  private _cellSize: number = 0;\r\n  private _cellsAttr: StorageAttribute = null; // all cells in the vector must be of the same type\r\n  private _cellsDefaultVal: string = null; // all cells in the magic vector has the same default value\r\n  private _cellsIsNullDefault: boolean = false; // null default definition for all cells in the magic vector\r\n\r\n  // data buffers that we change Dynamically to facilitate\r\n  // the creation of a string representation of the vector\r\n  private _dataBuf: StringBuilder = null;\r\n  private _initialized: boolean = false; // marks whether the vector was initialized if it was not that it is an invalid vector\r\n  private _nullBuf: StringBuilder = null;\r\n  private _originalflatData: string = null;\r\n\r\n  constructor(cellsType: StorageAttribute, contentType: string, defualt: string, isDefNull: boolean, nullAlowed: boolean, length: number);\r\n  constructor(blobString: string);\r\n  constructor(fld: FieldDef);\r\n  constructor(cellsTypeOrBlobStringOrFld: any, contentType?: string, defualt?: string, isDefNull?: boolean, nullAlowed?: boolean, length?: number) {\r\n    super();\r\n    if (arguments.length === 6)\r\n      this.constructor_0(cellsTypeOrBlobStringOrFld, contentType, defualt, isDefNull, nullAlowed, length);\r\n\r\n    else if (arguments.length === 1 && (cellsTypeOrBlobStringOrFld === null || cellsTypeOrBlobStringOrFld.constructor === String))\r\n      this.constructor_1(cellsTypeOrBlobStringOrFld);\r\n\r\n    else\r\n      this.constructor_2(cellsTypeOrBlobStringOrFld);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   construct the object but does not fill it with data in order to initialize the Vector we must invoke on\r\n  ///   it the its init method a VectorType which was not initialized is an unvalid vector.\r\n  /// </summary>\r\n  private constructor_0(cellsType: StorageAttribute, contentType: string, defualt: string, isDefNull: boolean, nullAlowed: boolean, length: number): void {\r\n    this._cells = new List<CellElement>();\r\n    this._cellsAttr = cellsType;\r\n    this._cellContentType = contentType;\r\n    this._cellsDefaultVal = defualt;\r\n    this._cellsIsNullDefault = isDefNull;\r\n    this._cellSize = ((this._cellsAttr === StorageAttribute.UNICODE) ? (length * 2) : length);\r\n    this._initialized = true;\r\n    this._allowNull = nullAlowed;\r\n    this._nullBuf = new StringBuilder();\r\n    this._dataBuf = new StringBuilder();\r\n    this._originalflatData = this.toString();\r\n    this._encoding = GuiEnvironment.Environment.GetEncoding();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   construct the object but does not fill it with data in order to initialize the Vector we must invoke on\r\n  ///   it the its init method a VectorType which was not initialized is an invalid vector.\r\n  /// </summary>\r\n  /// <param name = \"blobString\">a string representation of the blob's data bytes</param>\r\n  private constructor_1(blobString: string): void {\r\n    this._cells = new List<CellElement>();\r\n    this._initialized = false;\r\n    this._originalflatData = blobString;\r\n    this._encoding = GuiEnvironment.Environment.GetEncoding();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   construct the object with a field\r\n  /// </summary>\r\n  /// <param name = \"fld\"></param>\r\n  /// <param name = \"chars\"></param>\r\n  private constructor_2(fld: FieldDef): void {\r\n    this._cells = new List<CellElement>();\r\n    this._cellsAttr = fld.getCellsType();\r\n    this._cellContentType = fld.getVecCellsContentType();\r\n    this._cellsDefaultVal = fld.getCellDefualtValue();\r\n    this._cellsIsNullDefault = fld.isNullDefault();\r\n    this._cellSize = <number>((this._cellsAttr === StorageAttribute.UNICODE) ? (fld.getVecCellsSize() * 2) : fld.getVecCellsSize());\r\n    this._initialized = true;\r\n    this._allowNull = fld.NullAllowed;\r\n    this._nullBuf = new StringBuilder();\r\n    this._dataBuf = new StringBuilder();\r\n    this._originalflatData = this.toString();\r\n    this._encoding = GuiEnvironment.Environment.GetEncoding();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   builds a VectorType from its flattened blob representation\r\n  /// </summary>\r\n  /// <param name = \"blobString\">a string representation of the blob's data bytes</param>\r\n  /// <returns> false is the given blob is not a vector (the flatten format is wrong)</returns>\r\n  private init(): void {\r\n    let tokens: string[] = null;\r\n    let tokenIdx: number = 0;\r\n    let currentToken: string = null; // the current token we are paring\r\n    let isFlatDataTranslated: boolean = this.isUnicode(this._originalflatData);\r\n    let isDbcsAlpha: boolean = false; // JPN: DBCS support\r\n\r\n    // pos is position in the originalflatData string\r\n    let pos: number = BlobType.blobPrefixLength(this._originalflatData);\r\n    // blob\r\n    tokens = StrUtil.tokenize(this._originalflatData.substr(pos), \",\");\r\n    let vecSize: number = 0;\r\n\r\n    if (!this._initialized) {\r\n      if (VectorType.validateBlobContents(this._originalflatData)) {\r\n        let blobPrefix: string = BlobType.getPrefix(this._originalflatData);\r\n        this._cellContentType = BlobType.getContentType(blobPrefix);\r\n\r\n        // skip the the headers of the table and the vector and the first ',';\r\n        pos = <number>(<number>pos + 4 + 5 + 1);\r\n\r\n        // skip the version\r\n        tokenIdx++;\r\n        currentToken = tokens[tokenIdx];\r\n        pos = pos + (currentToken.length + 1);\r\n\r\n        // skip the ColumnsCount_ in vectors always contain value of 1\r\n        tokenIdx++;\r\n        currentToken = tokens[tokenIdx];\r\n        pos = pos + (currentToken.length + 1);\r\n\r\n        // parse the cell attribute in vector there is only one attribute fo the entire vector\r\n        tokenIdx++;\r\n        currentToken = tokens[tokenIdx];\r\n        this._cellsAttr = <StorageAttribute>currentToken.charAt(0);\r\n        pos = pos + 2;\r\n\r\n        // parse the ColumnsLen_ that contains the number of cells in the vector\r\n        // since there is only one column we increase pos by currentToken.length()\r\n        // this number is same as the ColumnsTotalLen_ for vectors\r\n        tokenIdx++;\r\n        currentToken = tokens[tokenIdx];\r\n        this._cellSize = <number>NNumber.Parse(currentToken);\r\n        pos = pos + (currentToken.length + 1);\r\n\r\n        // parse the cell default value is it is numeric it is sent as NUM_TYPE\r\n        // since the default value may contain as value charcters as the delimeter\r\n        // we can not use the StringTokenizer.\r\n        if (this._cellsAttr === StorageAttribute.NUMERIC || this._cellsAttr === StorageAttribute.DATE || this._cellsAttr === StorageAttribute.TIME)\r\n          this._cellsDefaultVal = StrUtil.stringToHexaDump(this._originalflatData.substr(pos, <number>this._cellSize), 2);\r\n        else if (this._cellsAttr === StorageAttribute.ALPHA || this._cellsAttr === StorageAttribute.MEMO) {\r\n          // QCR 429445 since the vector is encoded to base64/hex when it is recived from the server\r\n          // we must use the correct char-set when reciving vector of alpha or memo from the server\r\n          // in vectors we must concider the char set since when we got it from the server it was encoded\r\n          if (UtilStrByteMode.isLocaleDefLangDBCS()) {\r\n            isDbcsAlpha = true;\r\n            isFlatDataTranslated = true;\r\n            this._cellsDefaultVal = UtilStrByteMode.leftB(this._originalflatData.substr(pos), <number>this._cellSize);\r\n          }\r\n          else\r\n            this._cellsDefaultVal = this._originalflatData.substr(pos, <number>this._cellSize);\r\n          if (this._encoding !== null && !isFlatDataTranslated) {\r\n            try {\r\n              let ba: Uint8Array = ISO_8859_1_Encoding.ISO_8859_1.GetBytes(this._cellsDefaultVal);\r\n              this._cellsDefaultVal = this._encoding.GetString(ba, 0, ba.length);\r\n            }\r\n            catch (Exception) {\r\n            }\r\n          }\r\n        }\r\n        else if (this._cellsAttr === StorageAttribute.UNICODE) {\r\n          this._cellsDefaultVal = this._originalflatData.substr(pos, <number>this._cellSize);\r\n\r\n          try {\r\n            let ba: Uint8Array = ISO_8859_1_Encoding.ISO_8859_1.GetBytes(this._cellsDefaultVal);\r\n            this._cellsDefaultVal = Encoding.Unicode.GetString(ba, 0, ba.length);\r\n          }\r\n          catch (Exception) {\r\n          }\r\n        }\r\n        else\r\n          this._cellsDefaultVal = this._originalflatData.substr(pos, <number>this._cellSize);\r\n        if (isDbcsAlpha)\r\n          pos = pos + this._cellsDefaultVal.length + 1;\r\n        else\r\n          pos = <number>(<number>pos + this._cellSize + 1); // sikp the ending ','\r\n\r\n        // inrorder to continue using the tokenizer for the rest of the headers parsing\r\n        // reinit it\r\n        tokens = StrUtil.tokenize(this._originalflatData.substr(pos), \",\");\r\n        tokenIdx = 0;\r\n\r\n        // parse the cells null default flag\r\n        currentToken = tokens[tokenIdx];\r\n        this._cellsIsNullDefault = DisplayConvertor.toBoolean(currentToken);\r\n        pos = pos + (currentToken.length + 1);\r\n\r\n        // parse the cells null allowed flag\r\n        tokenIdx++;\r\n        currentToken = tokens[tokenIdx];\r\n        this._allowNull = DisplayConvertor.toBoolean(currentToken);\r\n        pos = pos + (currentToken.length + 1);\r\n\r\n        // skip the parsing of ColumnsTotalLen_\r\n        tokenIdx++;\r\n        currentToken = tokens[tokenIdx];\r\n        pos = pos + (currentToken.length + 1);\r\n\r\n        // parse the size of the vector ( RecordsCount_)\r\n        tokenIdx++;\r\n        currentToken = tokens[tokenIdx];\r\n        vecSize = <number>NNumber.Parse(currentToken);\r\n        pos = pos + (currentToken.length + 1);\r\n\r\n        // the blobs_ will always contain value of 1 sine we have in vectors only one colmn\r\n        tokenIdx++;\r\n        currentToken = tokens[tokenIdx];\r\n        pos = pos + (currentToken.length + 1);\r\n\r\n        // blobs offset table in the vector case will alway contain only one value equals to 0\r\n        // since there is only one colms in the vector\r\n        if (this._cellsAttr === StorageAttribute.BLOB || this._cellsAttr === StorageAttribute.BLOB_VECTOR) {\r\n          tokenIdx++;\r\n          currentToken = tokens[tokenIdx];\r\n          pos = pos + (currentToken.length + 1);\r\n        }\r\n\r\n        // parse the data array\r\n        let data: string;\r\n        if (isDbcsAlpha) {\r\n          data = UtilStrByteMode.leftB(this._originalflatData.substr(pos), <number>(vecSize * this._cellSize));\r\n          pos = pos + data.length + 1;\r\n        }\r\n        else {\r\n          data = this._originalflatData.substr(pos, <number>(vecSize * this._cellSize));\r\n          pos = <number>(<number>pos + vecSize * this._cellSize + 1);\r\n        }\r\n\r\n        // allocate the dataBuf\r\n        this._dataBuf = new StringBuilder(data.length);\r\n\r\n        if (this._cellsAttr !== StorageAttribute.ALPHA && this._cellsAttr !== StorageAttribute.MEMO && this._cellsAttr !== StorageAttribute.UNICODE)\r\n          this._dataBuf.Append(data);\r\n\r\n        // parse the null buf\r\n        let nullBuf: string = this._originalflatData.substr(pos, <number>vecSize);\r\n        pos = <number>(<number>pos + vecSize + 1);\r\n\r\n        // save the nullBuf\r\n        this._nullBuf = new StringBuilder(nullBuf);\r\n\r\n        // check the type of the cells\r\n        if (this._cellsAttr !== StorageAttribute.BLOB && this._cellsAttr !== StorageAttribute.BLOB_VECTOR) {\r\n          for (let i: number = 0; i < vecSize; i++) {\r\n            let isNull: boolean = nullBuf.charAt(i) > '\\0';\r\n            // numeric type are sent as NUM_TYPE so we translate them to hex\r\n            if (this._cellsAttr === StorageAttribute.NUMERIC || this._cellsAttr === StorageAttribute.DATE || this._cellsAttr === StorageAttribute.TIME)\r\n              this._cells.push(new CellElement(StrUtil.stringToHexaDump(data.substr(<number>(<number>i * this._cellSize), <number>this._cellSize), 2), isNull));\r\n            else if (this._cellsAttr === StorageAttribute.ALPHA || this._cellsAttr === StorageAttribute.MEMO) {\r\n              // QCR 429445 since the vector is encoded to base64/hex when it is recived from the\r\n              // server we must use the correct char-set when reciving vector of alpha or memo from the server\r\n              let cellData: string;\r\n              if (isDbcsAlpha)\r\n                cellData = UtilStrByteMode.midB(data, <number>(<number>i * this._cellSize), <number>this._cellSize);\r\n              else\r\n                cellData = data.substr(<number>(<number>i * this._cellSize), <number>this._cellSize);\r\n\r\n              if (this._encoding !== null && !isFlatDataTranslated) {\r\n                try {\r\n                  let ba: Uint8Array = ISO_8859_1_Encoding.ISO_8859_1.GetBytes(cellData);\r\n                  cellData = this._encoding.GetString(ba, 0, ba.length);\r\n                }\r\n                catch (SystemException) {\r\n                }\r\n              }\r\n              this._dataBuf.Append(cellData);\r\n              this._cells.push(new CellElement(cellData, isNull));\r\n            }\r\n            else if (this._cellsAttr === StorageAttribute.UNICODE) {\r\n              let cellData: string = data.substr(<number>(<number>i * this._cellSize), <number>this._cellSize);\r\n              try {\r\n                let ba: Uint8Array = ISO_8859_1_Encoding.ISO_8859_1.GetBytes(cellData);\r\n                cellData = Encoding.Unicode.GetString(ba, 0, ba.length);\r\n              }\r\n              catch (SystemException) {\r\n              }\r\n              this._dataBuf.Append(cellData);\r\n              this._cells.push(new CellElement(cellData, isNull));\r\n            }\r\n            else\r\n              this._cells.push(new CellElement(data.substr(<number>(<number>i * this._cellSize), <number>this._cellSize), isNull));\r\n          }\r\n        }\r\n        else {\r\n          // in case of vectors orf vectors or vectors of blobs we need to treat them differentlly\r\n          // each blob or vector is \"flattened in the end of the null buff\r\n          // as a string in the following format:\r\n          // Blob_Size,ObjHandle,VariantIdx,Type,VecCellAttr,....data....;next_blob;\r\n          // we need to remember that er a blob come to the client noy via vector its format is:\r\n          // ObjHandle,VariantIdx,Type,VecCellAttr;data there for we need to make the adjustments\r\n          // in the parsing process and in vecGet and in toString\r\n          for (let i: number = 0; i < vecSize; i++) {\r\n            tokens = StrUtil.tokenize(this._originalflatData.substr(pos), \",\");\r\n            tokenIdx = 0;\r\n\r\n            // parse blob size\r\n            tokenIdx++;\r\n            currentToken = tokens[tokenIdx];\r\n            let size: number = <number>NNumber.Parse(currentToken);\r\n            pos = pos + (currentToken.length + 1);\r\n\r\n            // parse the rest of the blob header\r\n            let blobHeader: string = \"\";\r\n            for (let j: number = 0; j < GuiConstants.BLOB_PREFIX_ELEMENTS_COUNT; j++) {\r\n              tokenIdx++;\r\n              currentToken = tokens[tokenIdx];\r\n              blobHeader = blobHeader + currentToken;\r\n              pos = pos + (currentToken.length + 1);\r\n\r\n              if (j !== GuiConstants.BLOB_PREFIX_ELEMENTS_COUNT - 1) {\r\n                blobHeader = blobHeader + \",\";\r\n              }\r\n            }\r\n\r\n            let cellData: string = this._originalflatData.substr(pos, <number>size);\r\n\r\n            // add the cell to the vec\r\n            let isNull: boolean = nullBuf.charAt(i) > '\\0';\r\n            this._cells.push(new CellElement(cellData, isNull, blobHeader));\r\n            pos = <number>(<number>pos + size + 1);\r\n          }\r\n        }\r\n        // If dataBuf was not built during \"cells growth\" - allocate it right now, in one-shot.\r\n        if (this._dataBuf.Length === 0)\r\n          this._dataBuf = new StringBuilder(data.length);\r\n\r\n        this._initialized = true;\r\n      }\r\n      else\r\n        throw new ApplicationException(\"in VectorType.init wrong vector format\");\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return a flatten blob string representation we assume here that all changes are dynamically save into the\r\n  ///   buffs each time the vector changes\r\n  /// </summary>\r\n  toString(): string {\r\n    let res: string = \"\"; // take\r\n\r\n    // lazy evaluation if the vector was not initialized it wasn't changed so return the original\r\n    if (this._initialized) {\r\n      // build the headers\r\n      res = res + 0 + \",\" + 0 + \",\" + \"0\" + \",\" + <string>this._cellsAttr + \",\" + this._cellContentType + \";\";\r\n      // the blob header of this blob\r\n      res = res + this.buildHeadersString();\r\n      // + dataBuf.toString() + \",\" + nullBuf.toString() + \",\";\r\n\r\n      if (this._cellsAttr === StorageAttribute.UNICODE) {\r\n        let dataBufCharArry: string[] = new Array<string>(this._dataBuf.Length * 2);\r\n\r\n        for (let i: number = 0; i < this._dataBuf.Length; i = i + 1) {\r\n          dataBufCharArry[i * 2] = String.fromCharCode((this._dataBuf.get_Item(i).charCodeAt(0)) % 256);\r\n          dataBufCharArry[i * 2 + 1] = String.fromCharCode((this._dataBuf.get_Item(i).charCodeAt(0)) / 256);\r\n        }\r\n        res = res + NString.FromChars(dataBufCharArry) + \",\";\r\n      }\r\n      else\r\n        res = res + this._dataBuf + \",\";\r\n\r\n      res = res + this._nullBuf + \",\";\r\n\r\n      // in blobs and vector we do not update\r\n      if (this._cellsAttr === StorageAttribute.BLOB || this._cellsAttr === StorageAttribute.BLOB_VECTOR)\r\n        res = res + this.getBlobsBuf();\r\n\r\n      res = res + VectorType.BLOB_TABLE_STR;\r\n    }\r\n    else\r\n      res = this._originalflatData;\r\n\r\n    return res;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the cells attribute ( the sane for all cells in the vector)\r\n  /// </summary>\r\n  getCellsAttr(): StorageAttribute {\r\n    if (!this._initialized)\r\n      return VectorType.getCellsAttr(this._originalflatData);\r\n    else\r\n      return this._cellsAttr;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the cells size ( same size for all cells)\r\n  /// </summary>\r\n  getCellSize(): number {\r\n    let retVal: number;\r\n\r\n    if (!this._initialized)\r\n      retVal = VectorType.getCellSize(this._originalflatData);\r\n    else\r\n      retVal = this._cellSize;\r\n\r\n    // unicode cell size is saved internally as byte length since that is the way the server save it\r\n    if (this.getCellsAttr() === StorageAttribute.UNICODE)\r\n      retVal = Math.floor(retVal / 2);\r\n\r\n    return retVal;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the vector size\r\n  /// </summary>\r\n  getVecSize(): number {\r\n    if (!this._initialized)\r\n      return VectorType.getVecSize(this._originalflatData);\r\n    else\r\n      return <number>this._cells.length;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the value of a give cell cells indexes start from 1 wrong indexes or indexes the does not exist\r\n  ///   will return default value\r\n  /// </summary>\r\n  /// <param name = \"idx\">the cell index</param>\r\n  /// <returns> a string representation of the cell value TODO: yariv check with rina what we should do with\r\n  ///   blobs extra fields\r\n  /// </returns>\r\n  getVecCell(idx: number): string {\r\n    let retVal: string = null;\r\n    if (idx > 0) {\r\n      this.init();\r\n      if (<number>idx <= this.getVecSize()) {\r\n        retVal = this._cells.get_Item(idx - 1).data;\r\n\r\n        if (this._cellsAttr === StorageAttribute.BLOB || this._cellsAttr === StorageAttribute.BLOB_VECTOR)\r\n          retVal = this._cells.get_Item(idx - 1).blobFieldPrefix + \";\" + retVal;\r\n\r\n        // QCR 503691 the value of true or false in the server are the numeric values of 1 and 0\r\n        if (StorageAttributeCheck.isTypeLogical(this._cellsAttr))\r\n          retVal = ((retVal.charAt(0) === '\\0') ? \"0\" : \"1\");\r\n\r\n        if (this._cells.get_Item(idx - 1).isNull)\r\n          retVal = null;\r\n      }\r\n      else if (!this._cellsIsNullDefault)\r\n        retVal = this._cellsDefaultVal;\r\n    }\r\n    return retVal;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Returns the cell values of a vector in string array.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  GetCellValues(): string[] {\r\n    let retVal: string = null;\r\n    let cellValues: string[] = null;\r\n\r\n    this.init();\r\n\r\n    if (this.getVecSize() > 0)\r\n    {\r\n      cellValues = new Array<string>(this.getVecSize());\r\n\r\n      // Get the vector value\r\n      for (let idx: number = 0; idx < this.getVecSize(); idx++)\r\n      {\r\n        retVal = this._cells.get_Item(idx).data;\r\n\r\n        if (this._cellsAttr === StorageAttribute.BLOB || this._cellsAttr === StorageAttribute.BLOB_VECTOR)\r\n          retVal = this._cells.get_Item(idx).blobFieldPrefix + \";\" + retVal;\r\n\r\n        // QCR 503691 the value of true or false in the server are the numeric values of 1 and 0\r\n        if (StorageAttributeCheck.isTypeLogical(this._cellsAttr))\r\n          retVal = ((retVal.charAt(0) === '\\0') ? \"0\" : \"1\");\r\n\r\n        if (this._cells.get_Item(idx).isNull)\r\n          retVal = null;\r\n\r\n        cellValues[idx] = retVal;\r\n      }\r\n    }\r\n    else if (!this._cellsIsNullDefault)\r\n    {\r\n        cellValues = [\r\n          this._cellsDefaultVal\r\n        ];\r\n    }\r\n\r\n    return cellValues;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   inserts or changes a cells value\r\n  /// </summary>\r\n  /// <param name = \"idx\">the cell index if the index is not sequential creats empty cell till the index</param>\r\n  /// <param name = \"newValue\">the new value ( if it is a blob type or vector it contains the prefix of the control data</param>\r\n  /// <retuns>  false if the index is wrong or the vector illformed </retuns>\r\n  setVecCell(idx: number, newValue: string, isNull: boolean): boolean {\r\n    let res: boolean = false;\r\n    let createBufferValForNumType: boolean = true;\r\n    try {\r\n      if (idx > 0) {\r\n          this.init();\r\n          let localCellSize: number = (this._cellsAttr === StorageAttribute.UNICODE) ? Math.floor(this._cellSize / 2) : this._cellSize;\r\n        // trying to set null value when not allowed\r\n        if (isNull && !this._allowNull) {\r\n          isNull = false;\r\n          newValue = this._cellsDefaultVal;\r\n        }\r\n\r\n        if (idx <= this._cells.length) {\r\n          let curr: CellElement = this._cells.get_Item(idx - 1);\r\n          // if the value passed is not null\r\n          if (!isNull) {\r\n            // special treatment for blobs and vectors\r\n            if (this._cellsAttr === StorageAttribute.BLOB || this._cellsAttr === StorageAttribute.BLOB_VECTOR) {\r\n              // set the data in the cell\r\n              let blobPrefixLength: number = BlobType.blobPrefixLength(newValue);\r\n              curr.blobFieldPrefix = newValue.substr(0, blobPrefixLength - 1);\r\n\r\n              // treat empty blob\r\n              if (newValue.length > blobPrefixLength)\r\n                curr.data = newValue.substr(blobPrefixLength);\r\n              else\r\n                curr.data = \"\";\r\n            }\r\n            // simple type\r\n            else {\r\n              // QCR 503691 the value of true or false in the server are the numeric values of 1 and 0\r\n              if (StorageAttributeCheck.isTypeLogical(this._cellsAttr)) {\r\n                curr.data = (DisplayConvertor.toBoolean(newValue) ? new StringBuilder().Append(1).ToString() : new StringBuilder().Append('\\0').ToString());\r\n                newValue = curr.data;\r\n              }\r\n              else\r\n                curr.data = newValue;\r\n\r\n              // numeric types are represented in the data buf as num type so we\r\n              // translate them before inserting them to the buf\r\n              let dataBufVal: string = newValue;\r\n              if (this._cellsAttr === StorageAttribute.NUMERIC || this._cellsAttr === StorageAttribute.DATE || this._cellsAttr === StorageAttribute.TIME)\r\n                dataBufVal = RecordUtils.byteStreamToString(dataBufVal);\r\n\r\n              if (UtilStrByteMode.isLocaleDefLangDBCS() && (this._cellsAttr === StorageAttribute.ALPHA || this._cellsAttr === StorageAttribute.MEMO)) {\r\n                let baDataBuf: Uint8Array = this._encoding.GetBytes(this._dataBuf.ToString());\r\n                let baDataBufVal: Uint8Array = this._encoding.GetBytes(dataBufVal);\r\n\r\n                // update data buf\r\n                for (let i: number = 0; i < baDataBufVal.length && <number>i < localCellSize; i++)\r\n                  baDataBuf[<number>(<number>(idx - 1) * localCellSize) + i] = baDataBufVal[i];\r\n\r\n                // we do not keep the whole size of the alpha\r\n                for (let i: number = baDataBufVal.length; <number>i < localCellSize; i++)\r\n                  baDataBuf[<number>(<number>(idx - 1) * localCellSize) + i] = ((this._cellsAttr === StorageAttribute.ALPHA) ? 32 : 0);\r\n\r\n                this._dataBuf = new StringBuilder(this._encoding.GetString(baDataBuf, 0, baDataBuf.length));\r\n                curr.data = this._encoding.GetString(baDataBuf, <number>(<number>(idx - 1) * localCellSize), <number>localCellSize);\r\n              }\r\n              else {\r\n                // update data buf\r\n                // QCR 987943 trim the value if it is longer the the cell length\r\n                for (let i: number = 0; i < dataBufVal.length && <number>i < localCellSize; i++)\r\n                  this._dataBuf.set_Item(<number>(<number>(idx - 1) * localCellSize) + i, dataBufVal.charAt(i));\r\n\r\n                // in alpha and num type we do not keep the whole size of the alpha/NUM_TYPE\r\n                for (let i: number = dataBufVal.length; <number>i < localCellSize; i++)\r\n                  this._dataBuf.set_Item(<number>(<number>(idx - 1) * localCellSize) + i, (this._cellsAttr === StorageAttribute.ALPHA || this._cellsAttr === StorageAttribute.UNICODE) ? ' ' : '\\0');\r\n\r\n                // QCR 987943 trim the value if it is longer the the cell length\r\n                if (this._cellsAttr === StorageAttribute.ALPHA || this._cellsAttr === StorageAttribute.UNICODE || this._cellsAttr === StorageAttribute.MEMO)\r\n                  curr.data = this._dataBuf.ToString().substr(<number>(<number>(idx - 1) * localCellSize), <number>localCellSize);\r\n              }\r\n            }\r\n            // update the null buf\r\n            this._nullBuf.set_Item(idx - 1, '\\0');\r\n            curr.isNull = false;\r\n          }\r\n          // if the value passed is null\r\n          else {\r\n            curr.data = null;\r\n\r\n            // set the prefix flag that indicates whether the blob is vector or not\r\n            if (this._cellsAttr === StorageAttribute.BLOB_VECTOR)\r\n              curr.blobFieldPrefix = BlobType.getEmptyBlobPrefix('\\u0001');\r\n            else\r\n              curr.blobFieldPrefix = BlobType.getEmptyBlobPrefix('\\0');\r\n            curr.isNull = true;\r\n            this._nullBuf.set_Item(idx - 1, '\\u0001');\r\n\r\n            // relevant only for none blobs\r\n            for (let i: number = 0; <number>i < localCellSize; i++)\r\n              this._dataBuf.set_Item(<number>(<number>(idx - 1) * localCellSize) + i, '\\0');\r\n\r\n            // update the null buf\r\n            this._nullBuf.set_Item(idx - 1, '\\u0001');\r\n          }\r\n          res = true;\r\n        }\r\n        // new record\r\n        else {\r\n          let insertVal: string;\r\n          // chooses the value inserted to the skipped cells\r\n          if (this._cellsAttr === StorageAttribute.BLOB || this._cellsAttr === StorageAttribute.BLOB_VECTOR) {\r\n            // append the is vector flag\r\n            if (this._cellsAttr === StorageAttribute.BLOB_VECTOR)\r\n              insertVal = BlobType.getEmptyBlobPrefix('\\u0001');\r\n            else\r\n              insertVal = BlobType.getEmptyBlobPrefix('\\0');\r\n\r\n            if (!this._cellsIsNullDefault)\r\n              insertVal = insertVal + this._cellsDefaultVal; // concat regolar blob cntrol data\r\n          }\r\n          else if (this._cellsIsNullDefault)\r\n            insertVal = null;\r\n          // simple null value\r\n          else\r\n            insertVal = this._cellsDefaultVal; // default simple value\r\n\r\n          // QCR 503691 the value of true or false in the server are the numeric values of 1 and 0\r\n          if (insertVal !== null && StorageAttributeCheck.isTypeLogical(this._cellsAttr))\r\n            insertVal = (DisplayConvertor.toBoolean(insertVal) ? new StringBuilder().Append('\\u0001').ToString() : new StringBuilder().Append('\\0').ToString());\r\n\r\n          // create skipped records\r\n          // when a vector cell is set , if the cell is beyond the existing vector.\r\n          // we will fill the cells between vector size and set cell with default value.\r\n          // for example : if vector size is 0, and we do vecset (vec[5]). cell 5 needs to be set\r\n          // with the value. cells 1 to 4 will be created and set with the default value.\r\n          let dataBufVal: string = insertVal;\r\n\r\n          while (this._cells.length < idx) {\r\n            if (this._cellsAttr === StorageAttribute.BLOB || this._cellsAttr === StorageAttribute.BLOB_VECTOR) {\r\n              this._cells.push(new CellElement(insertVal.substr(VectorType.EMPTY_BLOB_PREFIX_LEN), this._cellsIsNullDefault, insertVal.substr(0, VectorType.EMPTY_BLOB_PREFIX_LEN)));\r\n              this._dataBuf.Append(this.getNullString(VectorType.BLOB_TYPE_STRUCT_SIZE));\r\n            }\r\n            else {\r\n              this._cells.push(new CellElement(insertVal, this._cellsIsNullDefault));\r\n\r\n              // update the data buf\r\n              if (insertVal !== null) {\r\n                // numeric types are represented in the data buf as num type so we\r\n                // translate them before inserting them to the buf\r\n                if (this._cellsAttr === StorageAttribute.NUMERIC || this._cellsAttr === StorageAttribute.DATE || this._cellsAttr === StorageAttribute.TIME) {\r\n                  if (createBufferValForNumType) {\r\n                    // create a buffer value for num type only once, and use it\r\n                    // over and over again for all the cells to be initialized.\r\n                    // do the translation only once to improve performance.\r\n                    createBufferValForNumType = false;\r\n                    dataBufVal = RecordUtils.byteStreamToString(insertVal);\r\n                  }\r\n                }\r\n\r\n                // dataBufVal either contains original insertVal, or a string of\r\n                // byteStream for num types.\r\n                this._dataBuf.Append(dataBufVal);\r\n\r\n                // since we don't alway keep the whole alpha\r\n                let valLen: number;\r\n                if (UtilStrByteMode.isLocaleDefLangDBCS() && (this._cellsAttr === StorageAttribute.ALPHA || this._cellsAttr === StorageAttribute.MEMO))\r\n                  valLen = UtilStrByteMode.lenB(dataBufVal);\r\n                else\r\n                  valLen = dataBufVal.length;\r\n\r\n                for (let i: number = valLen; <number>i < localCellSize; i++)\r\n                  this._dataBuf.Append((this._cellsAttr === StorageAttribute.ALPHA || this._cellsAttr === StorageAttribute.UNICODE) ? ' ' : '\\0');\r\n              }\r\n              else\r\n                this._dataBuf.Append(this.getNullString(localCellSize));\r\n            }\r\n\r\n            // update the null buf\r\n            this._nullBuf.Insert(this._cells.length - 1,\r\n              this._cellsIsNullDefault ? '\\u0001' : '\\0'\r\n            );\r\n          }\r\n\r\n          // vector has been filled till the requested idx.\r\n          // now its time to set the requested cell.\r\n          res = this.setVecCell(idx, newValue, isNull);\r\n        }\r\n      }\r\n    }\r\n    catch (ApplicationException) {\r\n      res = false;\r\n    }\r\n    return res;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   change the vector to fit the definitions of a different vector field\r\n  /// </summary>\r\n  /// <param name=\"field\">the new field</param>\r\n  adjustToFit(field: FieldDef): void {\r\n    if (field.getType() === StorageAttribute.BLOB_VECTOR) {\r\n      let srcAttr: StorageAttribute = this.getCellsAttr();\r\n      let dstAttr: StorageAttribute = field.getCellsType();\r\n\r\n      if (StorageAttributeCheck.isTheSameType(srcAttr, dstAttr)) {\r\n        this.init();\r\n\r\n        // trim data if needed ( only for alpha or memo)\r\n        if (StorageAttributeCheck.IsTypeAlphaOrUnicode(srcAttr) && StorageAttributeCheck.IsTypeAlphaOrUnicode(dstAttr)) {\r\n            let dstSizeInChars: number = field.getVecCellsSize();\r\n            let srcSizeInChars: number = ((this._cellsAttr === StorageAttribute.UNICODE) ? Math.floor(this._cellSize / 2) : this._cellSize);\r\n          let isByteMode: boolean = UtilStrByteMode.isLocaleDefLangDBCS() && StorageAttributeCheck.isTypeAlpha(dstAttr);\r\n\r\n          if (srcSizeInChars !== dstSizeInChars) {\r\n            let adjData: StringBuilder = new StringBuilder();\r\n\r\n            // goes over all cells in the vector\r\n            for (let i: number = 0; i < dstSizeInChars; i = i + 1) {\r\n              let curr: CellElement = this._cells.get_Item(i);\r\n              // trim is needed\r\n              if (!curr.isNull) { // unicode cell size are saved internally as byte length while the field returns char\r\n                // length\r\n                if (srcSizeInChars > dstSizeInChars) {\r\n                  if (isByteMode)\r\n                    curr.data = UtilStrByteMode.leftB(curr.data, dstSizeInChars);\r\n                  else\r\n                    curr.data = curr.data.substr(0, dstSizeInChars);\r\n                  adjData.Append(curr.data);\r\n                }\r\n                // padding is needed\r\n                else {\r\n                  let tmpData: StringBuilder = new StringBuilder();\r\n                  tmpData.Append(curr.data);\r\n                  let dataLen: number = isByteMode ? UtilStrByteMode.lenB(curr.data) : curr.data.length;\r\n\r\n                  // pad with blanks\r\n                  for (let j: number = dataLen; j < dstSizeInChars; j = j + 1)\r\n                    tmpData.Append(' ');\r\n                  adjData.Append(tmpData.ToString());\r\n\r\n                  // update the data in the vector cell\r\n                  curr.data = tmpData.ToString();\r\n                }\r\n              }\r\n              else {\r\n                let tmpData: StringBuilder = new StringBuilder();\r\n                for (let j: number = 0; j < dstSizeInChars; j = j + 1)\r\n                  tmpData.Append('\\0');\r\n                adjData.Append(tmpData.ToString());\r\n\r\n                // update the data in the vector cell\r\n                curr.data = tmpData.ToString();\r\n              }\r\n            }// end loop\r\n            this._dataBuf = adjData;\r\n          }\r\n        }\r\n\r\n        // QCR 747801 in the filed the size of numeric/date/time is thier hex size\r\n        // whereas here it is their NUM_TYPE size\r\n        let newSize: number = field.getVecCellsSize();\r\n\r\n        // change the headers data such as cell type and cells size\r\n        this._cellsAttr = field.getCellsType();\r\n        this._cellSize = <number>((this._cellsAttr === StorageAttribute.UNICODE) ? (newSize * 2) : newSize);\r\n        this._cellsDefaultVal = field.getCellDefualtValue();\r\n        this._cellsIsNullDefault = field.isNullDefault();\r\n        this._allowNull = field.NullAllowed;\r\n        this._originalflatData = this.toString();\r\n        return;\r\n      }\r\n      else\r\n        throw new ApplicationException(\"in VectorType.adjustToFit vector basic types does not agree\");\r\n    }\r\n    else\r\n      throw new ApplicationException(\"in  VectorType.adjustToFit \" + field.getName() + \" is not of type vector\");\r\n  }\r\n\r\n  /// <summary>\r\n  ///   update the vec size in the headers buf\r\n  /// </summary>\r\n  /// <param name = \"idx\">the new size</param>\r\n  private buildHeadersString(): string {\r\n    let res: string = VectorType.BLOB_TABLE_STR + VectorType.VECTOR_STR + \",\" + VectorType.VERSION + \",\" + 1 + \",\" + <string>this._cellsAttr + \",\";\r\n    res = res + this._cellSize + \",\";\r\n\r\n    // append the default value\r\n    let def: string = \"\";\r\n    if (this._cellsDefaultVal !== null)\r\n      if (this._cellsAttr === StorageAttribute.NUMERIC || this._cellsAttr === StorageAttribute.DATE || this._cellsAttr === StorageAttribute.TIME)\r\n        def = RecordUtils.byteStreamToString(this._cellsDefaultVal);\r\n      else\r\n        def = this._cellsDefaultVal;\r\n\r\n    // in string we do not keep the full length of the string in brwoser client\r\n    if (UtilStrByteMode.isLocaleDefLangDBCS() && (this._cellsAttr === StorageAttribute.ALPHA || this._cellsAttr === StorageAttribute.MEMO))\r\n      def = def + this.getEmptyString(this._cellSize - <number>UtilStrByteMode.lenB(def));\r\n    else\r\n      def = def + this.getEmptyString(this._cellSize - <number>def.length);\r\n\r\n    // continue building the headers\r\n    res = res + def + \",\" + (this._cellsIsNullDefault ? \"1\" : \"0\") + \",\";\r\n    res = res + (this._allowNull ? \"1\" : \"0\") + \",\" + this._cellSize + \",\" + this._cells.length + \",\";\r\n    res = res + ((this._cellsAttr === StorageAttribute.BLOB || this._cellsAttr === StorageAttribute.BLOB_VECTOR) ? \"1\" : \"0\") + \",\";\r\n\r\n    if (this._cellsAttr === StorageAttribute.BLOB || this._cellsAttr === StorageAttribute.BLOB_VECTOR)\r\n      res = res + \"0,\";\r\n\r\n    return res;\r\n  }\r\n\r\n  // returns a string with size null charecters\r\n  private getNullString(size: number): string {\r\n    let res: StringBuilder = new StringBuilder();\r\n    for (let i: number = 0; i < size; i = i + 1)\r\n      res.Append('\\0');\r\n    return res.ToString();\r\n  }\r\n\r\n  // returns a string with size blank charecters\r\n  private getEmptyString(size: number): string {\r\n    let res: StringBuilder = new StringBuilder();\r\n    for (let i: number = 0; i < size; i = i + 1)\r\n      res.Append(' ');\r\n    return res.ToString();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   goes over the cells of the vectors and builds the data buf of blobs since it is the only thing not\r\n  ///   updated dynamically\r\n  /// </summary>\r\n  private getBlobsBuf(): string {\r\n    let res: StringBuilder = new StringBuilder();\r\n    for (let i: number = 0; i < this._cells.length; i = i + 1) {\r\n      let data: string = \"\";\r\n      let blobSize: number = 0;\r\n      let curr: CellElement = this._cells.get_Item(i);\r\n\r\n      if (curr.data !== null) {\r\n        data = curr.data;\r\n        blobSize = data.length;\r\n      }\r\n\r\n      res.Append(blobSize);\r\n      res.Append(\",\" + curr.blobFieldPrefix + \",\" + data + \";\");\r\n    }\r\n    return (res + \",\");\r\n  }\r\n\r\n  /*-------------------------------------------------------------------------------------*/\r\n  /*                                                                                     */\r\n  /* static utility methods */\r\n  /*                                                                                     */\r\n  /*-------------------------------------------------------------------------------------*/\r\n\r\n\r\n  /// <summary>\r\n  ///   parses the cell attribute of the vector\r\n  /// </summary>\r\n  /// <param name = \"blob\">a vector in a flattened format</param>\r\n  /// <returns> att the the vector's cells attribute</returns>\r\n  static getCellsAttr(blob: string): StorageAttribute {\r\n    if (VectorType.validateBlobContents(blob)) {\r\n      let tokens: string[] = StrUtil.tokenize(blob.substr(BlobType.blobPrefixLength(blob)), \",\");\r\n\r\n      // skip the MGBTMGVEC\r\n\r\n      // skip the version\r\n\r\n      // skip the ColumnsCount_\r\n\r\n      // the next token is the cells attribute\r\n      return <StorageAttribute>tokens[3].charAt(0);\r\n    }\r\n    else\r\n      throw new ApplicationException(\"in static getCellsAttr the blob is in the wrong format\");\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parses the size of each cell in the vector all cell has the same size except when the vector cells are\r\n  ///   of type blob or vector\r\n  /// </summary>\r\n  /// <param name = \"blob\">a vector in a flattened format</param>\r\n  /// <returns> the cells size or -1 if there is encoding problem</returns>\r\n  static getCellSize(blob: string): number {\r\n    let cellsType: StorageAttribute = VectorType.getCellsAttr(blob);\r\n    if (cellsType !== StorageAttribute.BLOB && cellsType !== StorageAttribute.BLOB_VECTOR) {\r\n      let tokens: string[] = StrUtil.tokenize(blob.substr(BlobType.blobPrefixLength(blob)), \",\");\r\n\r\n      // skip the MGBTMGVEC\r\n\r\n      // skip the version\r\n\r\n      // skip the ColumnsCount_\r\n\r\n      // skip the cells type\r\n\r\n      // the next element is the cells size\r\n      return NNumber.Parse(tokens[4]);\r\n    }\r\n    else { // =============================>\r\n      return 2147483647;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parses the size of the vector\r\n  /// </summary>\r\n  /// <param name = \"blob\">a vector in a flattened format</param>\r\n  /// <returns> the size of the vector</returns>\r\n  static getVecSize(blob: string): number {\r\n\r\n    if (VectorType.validateBlobContents(blob)) {\r\n      let pos: number = BlobType.blobPrefixLength(blob);\r\n      let tokens: string[] = StrUtil.tokenize(blob.substr(pos), \",\");\r\n\r\n      // skip the MGBTMGVEC\r\n      pos = pos + (tokens[0].length + 1);\r\n\r\n      // skip the version\r\n      pos = pos + (tokens[1].length + 1);\r\n\r\n      // skip the ColumnsCount_\r\n      pos = pos + (tokens[2].length + 1);\r\n\r\n      // skip the cells type\r\n      pos = pos + (tokens[3].length + 1);\r\n\r\n      // skip the cells size\r\n      let cellsSize: string = tokens[4];\r\n      pos = pos + (cellsSize.length + 1);\r\n\r\n      // skip the cell default value and re-init the tokenizer\r\n      // since the default value may contain the delimeter charecter as data\r\n      pos = pos + (NNumber.Parse(cellsSize) + 1);\r\n      tokens = StrUtil.tokenize(blob.substr(pos), \",\");\r\n\r\n      // skip is cell null default\r\n\r\n      // skip is null allowed\r\n\r\n      // skip columns total length\r\n\r\n      // the next element is the vector size\r\n      return NNumber.Parse(tokens[3]);\r\n    }\r\n    throw new ApplicationException(\"in static getVecSize the blob is in the wrong format\");\r\n  }\r\n\r\n  /// <summary>\r\n  ///   check if flatData content was translated to unicode or not. flatData contains the vector's cells in flat\r\n  ///   (non-array) format. This is how the server sends us the data. However the server does not send it to us\r\n  ///   in a UNICODE format. Thus we translate it to unicode during the first time we \"de-serialize\" the\r\n  ///   flat-data into a vector. During the de-serialization operation during the first time we \"de-serialize\"\r\n  ///   the flat-data into a vector. During the de-serialization operation we modify the BLOB-TABLe eye catcher\r\n  ///   from upper case to lower case, this way we know if a translation was done or is needed.\r\n  /// </summary>\r\n  /// <param name = \"name\">flatData The vector's flat data</param>\r\n  /// <returns> TRUE if the flat data is already in unicode format</returns>\r\n  isUnicode(flatData: string): boolean {\r\n    let start: number = BlobType.blobPrefixLength(flatData);\r\n    let catcher: string = flatData.substr(start, VectorType.BLOB_TABLE_STR_LEN);\r\n    return (catcher === VectorType.BLOB_TABLE_STR);\r\n  }\r\n}\r\n\r\n/// <summary>\r\n///   this inner class represents a cell in the magic vector each data that the magic vector keeps per cell\r\n///   will be kept in the CellElement\r\n/// </summary>\r\nexport class CellElement {\r\n  blobFieldPrefix: string = null;\r\n  data: string = null;\r\n  isNull: boolean = false;\r\n\r\n  // all this variables are used only if the vector cell is of type vector or blob\r\n\r\n  constructor(val: string, is_null: boolean);\r\n  constructor(val: string, is_null: boolean, ctrlData: string);\r\n  constructor(val: string, is_null: boolean, ctrlData?: string) {\r\n    if (arguments.length === 2)\r\n      this.constructor_0(val, is_null);\r\n    this.constructor_1(val, is_null, ctrlData);\r\n  }\r\n\r\n  // constructs a new cell element for vectors whos cells are not of type blob or vector\r\n  private constructor_0(val: string, is_null: boolean): void {\r\n    this.data = val;\r\n    this.isNull = is_null;\r\n  }\r\n\r\n  // constructs a new cell element for vectors whos cells are of type blob or vector\r\n  private constructor_1(val: string, is_null: boolean, ctrlData: string): void {\r\n    this.data = val;\r\n    this.isNull = is_null;\r\n    this.blobFieldPrefix = ctrlData;\r\n  }\r\n}\r\n"]}