@sap/artifact-management 1.25.0 → 1.26.0

package/dist/src/plugins/cap/readers/calculation-view/viewmodel/CalculationViewXmlParser.js

@@ -0,0 +1,2278 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processUDFParameter = exports.getParameterFromColumnView = exports.getElementFromsharedEntity = exports.getEntity = exports.getElementFromColumnView = void 0;
+const common_1 = __importDefault(require("../model/common"));
+const model_1 = require("../model/model");
+const XmlReader_1 = __importDefault(require("../model/XmlReader"));
+const sharedmodel_1 = __importDefault(require("../model/sharedmodel"));
+const CalculationViewXmlParserHelper_1 = __importDefault(require("./CalculationViewXmlParserHelper"));
+const modelbase_1 = require("../model/modelbase");
+const artifact_management_base_1 = require("@sap/artifact-management-base");
+class CalculationViewXmlParser {
+    static propagateDataTypeToDefaultNode(columnView) {
+        for (let i = 0; i < columnView.viewNodes.count(); i++) {
+            const viewNode = columnView.viewNodes.getAt(i);
+            this._propagateDataTypeToViewNode(viewNode);
+            const restrictedElements = [];
+            viewNode.elements.foreach((element) => {
+                if (element && element.measureType === model_1.MeasureType.RESTRICTION) {
+                    restrictedElements.push(element);
+                }
+            });
+            if (restrictedElements.length > 0) {
+                for (let k = 0; k < restrictedElements.length; k++) {
+                    const restrictedElement = restrictedElements[k];
+                    let baseMeasureElementInlineType = null;
+                    if (restrictedElement && restrictedElement.calculationDefinition) {
+                        const baseMeasureName = restrictedElement.calculationDefinition.formula;
+                        const baseMeasureElement = viewNode.elements.get(baseMeasureName);
+                        if (baseMeasureElement) {
+                            baseMeasureElementInlineType = baseMeasureElement.inlineType;
+                        }
+                    }
+                    if (baseMeasureElementInlineType) {
+                        const simpleTypeAttributes = {
+                            primitiveType: baseMeasureElementInlineType.primitiveType,
+                            length: baseMeasureElementInlineType.length,
+                            scale: baseMeasureElementInlineType.scale,
+                        };
+                        restrictedElement.createOrMergeSimpleType(simpleTypeAttributes);
+                    }
+                }
+            }
+        }
+    }
+    static _propagateDataTypeToViewNode(viewNode) {
+        if (viewNode.type === model_1.ViewNodeType.Graph /*&& viewNode.action == vModel.GraphAlgoritm.GET_SHORTEST_PATHS_ONE_TO_ALL*/) {
+            // viewNode.elements.foreach( function( element ) {
+            //     var inlineType = that._getInlineTypeFromSource( element, vModel.OutputType.Vertices );
+            //     if( inlineType ) {
+            //         var simpleTypeAttributes = {
+            //             primitiveType: inlineType.primitiveType,
+            //             length: inlineType.length || undefined,
+            //             precision: inlineType.precision || undefined,
+            //             scale: inlineType.scale || undefined
+            //         };
+            //         element.createOrMergeSimpleType( simpleTypeAttributes );
+            //     }
+            // });
+            // viewNode.outputElements2.foreach( function( element ) {
+            //     var inlineType = that._getInlineTypeFromSource( element, vModel.OutputType.Edges );
+            //     if( inlineType ) {
+            //         var simpleTypeAttributes = {
+            //             primitiveType: inlineType.primitiveType,
+            //             length: inlineType.length || undefined,
+            //             precision: inlineType.precision || undefined,
+            //             scale: inlineType.scale || undefined
+            //         };
+            //         element.createOrMergeSimpleType( simpleTypeAttributes );
+            //     }
+            // });
+        }
+        else if (viewNode.type === model_1.ViewNodeType.Hierarchy) {
+            viewNode.elements.foreach(element => {
+                if (element.name !== 'START_RANK') {
+                    const inlineType = this._getInlineTypeFromSource(element);
+                    if (inlineType) {
+                        const simpleTypeAttributes = {
+                            primitiveType: inlineType.primitiveType,
+                            length: inlineType.length,
+                            precision: inlineType.precision,
+                            scale: inlineType.scale,
+                        };
+                        element.createOrMergeSimpleType(simpleTypeAttributes);
+                    }
+                }
+            });
+        }
+        else {
+            viewNode.elements.foreach(element => {
+                //If element is calculated column or counter or restricted column
+                // then we should not update data type from source columns
+                if (element.isCalculatedColumn() || element.isRestrictedColumn() ||
+                    element.generatedColumn) {
+                    return;
+                }
+                const inlineType = this._getInlineTypeFromSource(element);
+                if (inlineType) {
+                    const simpleTypeAttributes = {
+                        primitiveType: inlineType.primitiveType,
+                        length: inlineType.length,
+                        precision: inlineType.precision,
+                        scale: inlineType.scale,
+                    };
+                    element.createOrMergeSimpleType(simpleTypeAttributes);
+                }
+                // const encryptionDet = that._getEncryptionInfoFromSource( element );
+                // if ( encryptionDet ) {
+                //     const encryptionAttributes = {
+                //         encryptionStatus: encryptionDet.encryptionStatus,
+                //         encryptionKey: encryptionDet.encryptionKey,
+                //         encryptionMode: encryptionDet.encryptionMode,
+                //     };
+                //     element.createorMergeEncryptionInfo( encryptionAttributes );
+                // }
+            });
+        }
+    }
+    static _getInlineTypeFromSource(element, outputName) {
+        // For Proxy element we can not get datatype
+        if (!(element.isProxy) && element.$getContainer() !== null &&
+            element.$getContainer() instanceof model_1.Entity) {
+            artifact_management_base_1.getLogger().trace(`eneity element: ${element.name} ${outputName}`);
+            return element.inlineType;
+        }
+        else if (element.$getContainer() !== null && element.$getContainer() instanceof model_1.ViewNode) {
+            artifact_management_base_1.getLogger().trace(`node element: ${element.name}`);
+            const viewNode = element.$getContainer();
+            let elementInput = null;
+            let mapping = null, sourceElement = null;
+            // Below two variables are to handle constant Element In UnionNode used in
+            // constantMapping
+            let isUnionNode = false;
+            let constantElementInUnionNode = null;
+            // Special handling for Graph Node Elements
+            // if ( viewNode.isGraphNode() ) {
+            //     // Based on algo it has to
+            //     switch ( viewNode.action ) {
+            //             case vModel.GraphAlgoritm.GET_NEIGHBORHOOD: // Get Key Only and depth is dummy
+            //                 if ( element.name == 'DEPTH' ) {
+            //                     return {
+            //                         primitiveType: 'INTEGER',
+            //                         length: undefined,
+            //                         scale: undefined,
+            //                     };
+            //                 }
+            //                 sourceElement = viewNode.workspace.vertexEntity.elements.get( element.name );
+            //                 break;
+            //             case vModel.GraphAlgoritm.GET_SHORTEST_PATHS_ONE_TO_ALL:
+            //                 if ( outputName == 'edges' ) {
+            //                     sourceElement = viewNode.workspace.edgeEntity.elements.get( element.name );
+            //                 } else {
+            //                     if ( element.name == 'WEIGHT' ) {
+            //                         if ( element.inlineType && element.inlineType.primitiveType ) {
+            //                             return {
+            //                                 primitiveType: element.inlineType.primitiveType,
+            //                                 length: element.inlineType.length,
+            //                                 scale: element.inlineType.scale,
+            //                             };
+            //                         } else {
+            //                             return {
+            //                                 primitiveType: 'INTEGER',
+            //                                 length: undefined,
+            //                                 scale: undefined,
+            //                             };
+            //                         }
+            //                     }
+            //                     sourceElement = viewNode.workspace.vertexEntity.elements.get( element.name );
+            //                 }
+            //                 break;
+            //             case vModel.GraphAlgoritm.GET_SHORTEST_PATH_ONE_TO_ONE:
+            //                 if ( element.name == 'WEIGHT' ) {
+            //                     if ( element.inlineType && element.inlineType.primitiveType ) {
+            //                         return {
+            //                             primitiveType: element.inlineType.primitiveType,
+            //                             length: element.inlineType.length,
+            //                             scale: element.inlineType.scale,
+            //                         };
+            //                     }
+            //                 }
+            //                 return element.inlineType;
+            //             case vModel.GraphAlgoritm.GET_STRONGLY_CONNECTED_COMPONENTS:
+            //                 if ( element.name == 'COMPONENT' ) {
+            //                     return {
+            //                         primitiveType: 'INTEGER',
+            //                         length: undefined,
+            //                         scale: undefined,
+            //                     };
+            //                 }
+            //                 sourceElement = viewNode.workspace.vertexEntity.elements.get( element.name );
+            //                 break;
+            //             case vModel.GraphAlgoritm.PATTERN_MATCHING:
+            //                 sourceElement = {};
+            //                 sourceElement.inlineType = undefined; // TODO: figure the graph pattern
+            //                 // matching algo
+            //                 break;
+            //             case vModel.GraphAlgoritm.SCRIPT_PATTERN_MATCHING:
+            //                 sourceElement = {};
+            //                 sourceElement.inlineType = undefined; // TODO: figure the graph pattern
+            //                 // matching algo
+            //                 break;
+            //             default:
+            //                 break;
+            //     }
+            //     return sourceElement.inlineType;
+            // }
+            if (viewNode.type === model_1.ViewNodeType.TableFunction) {
+                if (element.inlineType && element.inlineType.primitiveType) {
+                    return element.inlineType;
+                }
+            }
+            const allMappingsOfViewNode = viewNode.getAllMappingsOfViewNode();
+            let input = null;
+            for (let i = 0; i < viewNode.inputs.count(); i++) {
+                input = viewNode.inputs.getAt(i);
+                mapping = allMappingsOfViewNode[element.name] ?
+                    allMappingsOfViewNode[element.name].mapping : element.getMapping();
+                if (allMappingsOfViewNode[element.name] !== undefined && mapping !== undefined &&
+                    mapping.sourceElement !== undefined) {
+                    const ip = allMappingsOfViewNode[element.name].input;
+                    if (ip && (ip.repositoryInputNodeId === input.repositoryInputNodeId)) {
+                        elementInput = input;
+                        break;
+                    }
+                }
+                else if (mapping !== undefined &&
+                    mapping.sourceElement === null && mapping.targetElement !== null) {
+                    // It will only happen for constant Element In UnionNode used in
+                    // constantMapping;
+                    // in this case its inlineType is not derived from any source element rather it
+                    // will have its own inlineType stored with it
+                    isUnionNode = true;
+                    constantElementInUnionNode = mapping.targetElement;
+                }
+            }
+            if (elementInput) {
+                const elementInputSource = elementInput.getSource();
+                if (elementInputSource) {
+                    sourceElement = elementInputSource.elements.get(mapping.sourceElement.name);
+                    // I066990: if it is calculated column, return it directly as this would have
+                    // its own datatype
+                    if (sourceElement &&
+                        (sourceElement.isCalculatedColumn() ||
+                            sourceElement.isRestrictedColumn() ||
+                            sourceElement.generatedColumn)) {
+                        return sourceElement.inlineType;
+                    }
+                    if (elementInputSource instanceof model_1.ViewNode &&
+                        elementInputSource.type === model_1.ViewNodeType.Hierarchy &&
+                        sourceElement && sourceElement.isHierarchyGererated()) {
+                        return sourceElement.inlineType;
+                    }
+                    if (sourceElement) {
+                        return this._getInlineTypeFromSource(sourceElement);
+                    }
+                    else {
+                        // It will only happen for constant Element In UnionNode which are mapped to
+                        // some source elemnt
+                        return mapping.sourceElement.inlineType;
+                    }
+                }
+            }
+            else if (isUnionNode && constantElementInUnionNode) {
+                return constantElementInUnionNode.inlineType;
+            }
+        }
+    }
+    static parseScenario(xml, model, fixMixedLineEndings, forceLineEndings) {
+        const reader = new XmlReader_1.default(xml, fixMixedLineEndings + '', forceLineEndings);
+        reader.context.postProcessingRegistry = {
+            callback: [],
+        };
+        reader.context.loadPostProcessingCallBackQueue = {
+            callback: [],
+        };
+        reader.moveDown().moveTo('scenario', sharedmodel_1.default.NameSpace.CALCULATION, undefined);
+        const calculationScenarioType = 'TREE_BASED';
+        let outputViewType = reader.consumeAttribute('outputViewType', '');
+        let outputViewName = outputViewType;
+        const isStarJoin = CalculationViewXmlParserHelper_1.default.checkForStarJoinWithDomAPI(reader);
+        const mapDefaultClient = function (value) {
+            if (!value || value === '' || value === 'cross') {
+                return false;
+            }
+            else {
+                return true;
+            }
+        };
+        const schemaVersion = reader.consumeAttribute('schemaVersion', '');
+        artifact_management_base_1.getLogger().trace(`schemaVersion: ${schemaVersion}`);
+        // note: not process schemaVersion
+        const columnViewAttributes = reader.buildAttributes({
+            // name: "{id}",
+            id: '{id}',
+            applyPrivilegeType: '{applyPrivilegeType}',
+            defaultClient: '{defaultClient}',
+            dataCategory: '{dataCategory}',
+            visibility: '{visibility}',
+            defaultMember: '{defaultMember}',
+            historyEnabled: '{historyEnabled}',
+            enforceSqlExecution: '{enforceSqlExecution}',
+            cacheInvalidationPeriod: '{cacheInvalidationPeriod}',
+            alwaysAggregateResult: '{alwaysAggregateResult}',
+            propagateInstantiation: '{propagateInstantiation}',
+            runWithInvokerPrivileges: '{runWithInvokerPrivileges}',
+            scriptParametersCaseSensitive: '{scriptParametersCaseSensitive}',
+            dimensionType: '{dimensionType}',
+            hierarchyGeneration: '{hierarchyGeneration}',
+            deprecated: '{deprecated}',
+            endUserView: '{endUserView}',
+            generateMdsMetadata: '{generateMdsMetadata}',
+            maskMode: '{maskMode}',
+            translationRelevant: '{translationRelevant}',
+            pruningTable: '{pruningTable}',
+            cacheEnabled: '{cacheEnabled}',
+            rowCounterName: '{rowCounterName}',
+            hierarchiesSQLEnabled: '{hierarchiesSQLEnabled}',
+            evaluateSessionVariablesEarly: '{evaluateSessionVariablesEarly}',
+            analyticViewCompatibilityMode: '{analyticViewCompatibilityMode}',
+            xscCompatibilityMode: '{xscCompatibilityMode}',
+        }, undefined);
+        const columnViewSkippedNodes = reader.skippedNodes;
+        reader.moveDown();
+        const originAttributes = {};
+        this.parseOrigin(reader, originAttributes);
+        // const originSkippedNodes = reader.skippedNodes;
+        sharedmodel_1.default.parseDescriptions(reader, columnViewAttributes);
+        if (reader.tryMoveToIntermediate('defaultSchema')) {
+            reader.buildAttributes({
+                defaultSchema: '{schemaName}',
+            }, columnViewAttributes);
+            reader.next();
+        }
+        columnViewAttributes.clientDependent = mapDefaultClient(columnViewAttributes.defaultClient);
+        if (columnViewAttributes.clientDependent &&
+            columnViewAttributes.defaultClient !== '$$client$$') {
+            columnViewAttributes.fixedClient = columnViewAttributes.defaultClient;
+        }
+        delete columnViewAttributes.defaultClient;
+        if (columnViewAttributes.dataCategory === undefined) {
+            if (columnViewAttributes.visibility === 'reportingEnabled') {
+                columnViewAttributes.dataCategory = model_1.DataCategory.CUBE;
+            }
+            else {
+                columnViewAttributes.dataCategory = model_1.DataCategory.DEFAULT;
+            }
+        }
+        if (calculationScenarioType === 'TREE_BASED') {
+            if (!outputViewType && isStarJoin) {
+                outputViewType = model_1.ViewNodeType.JoinNode;
+                outputViewName = 'Star Join';
+            }
+            else if (outputViewType) {
+                outputViewName = outputViewType;
+            }
+        }
+        else if (calculationScenarioType === 'SCRIPT_BASED') {
+            outputViewType = model_1.ViewNodeType.Script;
+            outputViewName = 'Script_View';
+        }
+        // note: not process analytic privilege
+        const columnView = model.createColumnView(columnViewAttributes, columnViewSkippedNodes);
+        // todo: setting model should be this: $$setContainingFeature in SingleValueContainer
+        // =
+        // note: not process EndUserTexts
+        // note: not process Execution hint Properties
+        columnView._defaultNodeElementInstancesArray = [];
+        if (reader.moveToIntermediate('localVariables').tryMoveDown()) {
+            while (this.parseVariable(reader, columnView)) {
+                reader.next();
+            }
+            // note: do nothing
+            reader.moveUp();
+        }
+        reader.next();
+        if (reader.tryMoveToIntermediate('historyVariable')) {
+            // note: do nothing
+            reader.next();
+        }
+        if (reader.tryMoveToIntermediate('variableMappings')) {
+            // note: do nothing
+        }
+        reader.next();
+        while (reader.tryMoveTo('executionHints')) {
+            // note: do nothing
+            reader.next();
+        }
+        const dataSources = {};
+        if (reader.moveToIntermediate('dataSources').tryMoveDown()) {
+            while (this.parseDataSource(reader, dataSources)) {
+                reader.next();
+            }
+            reader.moveUp();
+        }
+        reader.next();
+        if (reader.tryMoveToIntermediate('sCubes')) {
+            // note: do nothing
+            reader.next();
+        }
+        // note: not process sCube
+        if (reader.tryMoveToIntermediate('snapshotProcedures')) {
+            // note: do nothing
+            reader.next();
+        }
+        // const staticResultCache = {};
+        while (reader.tryMoveTo('staticResultCache')) {
+            // note: do nothing
+            reader.next();
+        }
+        reader.next();
+        const nodeIDsInCalculationView = [];
+        if (reader.moveToIntermediate('calculationViews').tryMoveDown()) {
+            while (this.parseCalculationView(reader, columnView, dataSources, nodeIDsInCalculationView)) {
+                reader.next();
+            }
+            reader.moveUp();
+        }
+        reader.next();
+        // const inlineHierarchyRead = false;
+        if (reader._current && reader._current.nextSibling &&
+            reader._current.nextSibling.nodeName === 'inlineHierarchy') {
+            if (columnView && columnView.dataCategory && (columnView.dataCategory === model_1.DataCategory.DIMENSION ||
+                columnView.dataCategory === model_1.DataCategory.DEFAULT)) {
+                while (reader.tryMoveTo('inlineHierarchy')) {
+                    // note: do nothing
+                }
+            }
+        }
+        // note: not process multi-join ConvertMultiJoinToBinaryJoin
+        this.parseLogicalModel(reader, columnView, outputViewType, outputViewName, dataSources, isStarJoin);
+        reader.next();
+        // note: not process hanging data sources
+        if (reader.tryMoveToIntermediate('layout')) {
+            // note: do nothing
+            reader.next();
+        }
+        // note: not process inlineHierarchy
+        reader.moveUp();
+        this.doLoadPostProcessing(reader, columnView);
+        // New Way of Load Post Processing
+        this.excecuteLoadPostProcessingCallBackQueue(reader, columnView);
+        return reader.documentProperties;
+    }
+    static _getDefaultNodeElementInstanceByElementName(columnView, elementName, addIfNotPresent) {
+        let requiredElementInstance = null;
+        let elementInstanceFound = false;
+        const defaultNodeElementInstancesArray = columnView._defaultNodeElementInstancesArray;
+        if (defaultNodeElementInstancesArray) {
+            for (let index = 0; index < defaultNodeElementInstancesArray.length; index++) {
+                const elementInstance = defaultNodeElementInstancesArray[index];
+                if (elementInstance && elementInstance.name === elementName) {
+                    elementInstanceFound = true;
+                    return elementInstance;
+                }
+            }
+        }
+        else {
+            columnView._defaultNodeElementInstancesArray = [];
+        }
+        if (!elementInstanceFound && addIfNotPresent) {
+            requiredElementInstance = this._createDefaultNodeElementInstanceByElementName(defaultNodeElementInstancesArray, elementName);
+            return requiredElementInstance;
+        }
+    }
+    static _createDefaultNodeElementInstanceByElementName(defaultNodeElementInstancesArray, elementName) {
+        if (elementName && defaultNodeElementInstancesArray) {
+            const elementInstance = new model_1.Element({
+                name: elementName,
+                isProxy: true,
+            });
+            defaultNodeElementInstancesArray.push(elementInstance);
+            return elementInstance;
+        }
+    }
+    static _setSkippedNodes(object, skippedNodes) {
+        if (Array.isArray(skippedNodes)) {
+            for (let i = 0; i < skippedNodes.length; i++) {
+                object.$addSkippedNodes(skippedNodes[i]);
+            }
+        }
+        else {
+            object.$addSkippedNodes(skippedNodes);
+        }
+    }
+    static _checkProxyElementsInDefaultNode(defaultViewNode) {
+        const columnView = defaultViewNode.$getContainer();
+        const defaultNodeElementInstancesArray = columnView._defaultNodeElementInstancesArray;
+        if (defaultNodeElementInstancesArray) {
+            for (let index = 0; index < defaultNodeElementInstancesArray.length; index++) {
+                const elementInstance = defaultNodeElementInstancesArray[index];
+                if (elementInstance && elementInstance.isProxy === true) {
+                    return elementInstance;
+                }
+            }
+        }
+    }
+    static parseOrigin(reader, attributes, moveDown) {
+        // note: do nothing
+    }
+    static processInternalExternalConversion(reader, result) {
+        if (reader.tryMoveToIntermediate('internalExternalConversion')) {
+            // const fixedAttributes = reader.buildAttributes({
+            //     convertToExternalFunction: '{convertToExternalFunction}',
+            //     convertToInternalFunction: '{convertToInternalFunction}',
+            //     orderPreserving: '{orderPreserving}',
+            // });
+            // fixedAttributes.orderPreserving = RepositoryXmlParserHelper.getBooleanFromString( fixedAttributes.orderPreserving );
+            // result.createInternalExternalConversion( fixedAttributes );
+        }
+    }
+    static parseMaskingExpression(reader, element) {
+        if (reader.tryMoveToIntermediate('maskingExpression')) {
+            // const formula = reader.consumeContent();
+            // const maskingExpressionAttribute = {};
+            // maskingExpressionAttribute.formula = formula;
+            // element.createMaskingExpression( maskingExpressionAttribute, reader.skippedNodes );
+            reader.next();
+        }
+    }
+    static parseVariable(reader, columnView) {
+        // note: do nothing
+        return false;
+    }
+    static parseDataSource(reader, dataSources) {
+        if (reader.tryMoveTo('DataSource')) {
+            const dataSource = {
+                id: undefined,
+                type: undefined,
+                resourceUri: '',
+                alias: '',
+            };
+            const dataSourceAttributes = reader.buildAttributes({
+                id: '{id}',
+                type: '{type}',
+                temporalSource: '{temporalSource}',
+                systemTime1: '{systemTime1}',
+                systemTime2: '{systemTime2}',
+                systemTimeOperator: '{systemTimeOperator}',
+                applicationTime1: '{applicationTime1}',
+                partitionedExecution: '{partitionedExecution}',
+                clientColumn: '{clientColumn}',
+            });
+            reader.moveDown();
+            if (reader.tryMoveToIntermediate('partitionAttributeName')) {
+                // dataSource.partitionAttributeName = reader.getContent();
+            }
+            if (reader.tryMoveToIntermediate('resourceUri')) {
+                dataSource.resourceUri = reader.getContent();
+            }
+            dataSource.id = dataSourceAttributes.id;
+            dataSource.type = dataSourceAttributes.type;
+            dataSources[dataSourceAttributes.id] = dataSource;
+            if (dataSourceAttributes.id !== dataSource.resourceUri) {
+                if (dataSourceAttributes.id.indexOf('$') === -1) {
+                    dataSource.alias = dataSourceAttributes.id;
+                }
+                else {
+                    const alias = dataSourceAttributes.id.split('$')[2];
+                    if (alias && alias !== '') {
+                        dataSource.alias = alias;
+                    }
+                }
+            }
+            // Map EntityType for design time objects
+            if (CalculationViewXmlParserHelper_1.default.isItDesigntimeRepositoryObject(dataSource.type)) {
+                dataSource.type = CalculationViewXmlParserHelper_1.default.mapRepositoryTypeToEntityType(dataSource.type);
+            }
+            reader.skipChildren().next();
+            reader.moveUp();
+            return true;
+        }
+        return false;
+    }
+    static processTypedObjectExternalTypeOfElement(reader, columnView, result, isParameter) {
+        if (reader.tryMoveToIntermediate('externalLikeStructureName')) {
+            // note: not process
+        }
+        if (reader.tryMoveToIntermediate('externalLikeElementName')) {
+            // note: not process
+        }
+        else {
+            // note: not process
+            artifact_management_base_1.getLogger().trace('XML element is not <externalLikeElementName>');
+        }
+    }
+    static processTypedObjectExternalTypeOfElementParameterMapping(reader, result, columnView) {
+        let tempVariableMappings = null;
+        const variableMappings = [];
+        do {
+            tempVariableMappings = this.parseVariableMapping(reader, undefined, columnView);
+            if (tempVariableMappings) {
+                variableMappings.push(tempVariableMappings);
+                reader.next();
+            }
+        } while (tempVariableMappings);
+        // return variableMappings;
+        if (variableMappings && variableMappings.length > 0) {
+            for (let i = 0; i < variableMappings.length; i++) {
+                this.postProcessVariableMappings(reader, variableMappings[i], result);
+            }
+        }
+    }
+    static parseCalculationView(reader, columnView, dataSources, nodeIDsInCalculationView) {
+        if (reader.tryMoveTo('calculationView')) {
+            const mapType = function (value) {
+                let type = reader.removePrefix(sharedmodel_1.default.NameSpace.CALCULATION, value);
+                type = CalculationViewXmlParserHelper_1.default.mapViewNodeType(type);
+                return type;
+            };
+            const viewNodeAttributes = reader.buildAttributes({
+                name: '{id}',
+                type: common_1.default.createXsiSelector('type', mapType),
+                // Also reading JoinNode related attributes to handle skippnodes remembering
+                // attributeNames issue
+                joinType: '{joinType}',
+                cardinality: '{cardinality}',
+                languageColumn: '{languageColumn}',
+                dynamic: '{dynamic}',
+                optimizeJoinColumns: '{optimizeJoinColumns}',
+                greedyJoinPruning: '{greedyJoinPruning}',
+                workspace: '{workspace}',
+                action: '{action}',
+                partitionedExecution: '{partitionedExecution}',
+                columnBasedPruningFlag: '{columnBasedPruningFlag}',
+                tableFunctionName: '{tableFunctionName}',
+                allowFilterPushdown: '{allowFilterPushdown}',
+                dynamicPartitionAttributes: '{dynamicPartitionAttributes}',
+                dynamicOrderAttributes: '{dynamicOrderAttributes}',
+                ignoreMultipleOutputsForFilter: '{ignoreMultipleOutputsForFilter}',
+                referentialDirection: '{referentialDirection}',
+                hierarchyFunction: '{function}',
+                multiJoinCentralTable: '{multiJoinCentralTable}',
+                multiJoinNode: '{multiJoinNode}',
+                multiJoinOrder: '{multiJoinOrder}',
+                method: '{method}',
+            });
+            const filterExpressionLanguage = reader.consumeAttribute('filterExpressionLanguage');
+            if (viewNodeAttributes.type === model_1.ViewNodeType.JoinNode ||
+                viewNodeAttributes.type === model_1.ViewNodeType.NonEquiJoinNode) {
+                const joinAttributes = {};
+                CalculationViewXmlParserHelper_1.default.populateJoinAttributesFromViewNodeAttributes(joinAttributes, viewNodeAttributes);
+            }
+            reader.moveDown();
+            sharedmodel_1.default.parseDescriptions(reader, viewNodeAttributes);
+            const viewNode = columnView.createOrMergeViewNode(viewNodeAttributes, reader.skippedNodes);
+            CalculationViewXmlParserHelper_1.default.createEndUserTextsIfRequired(viewNode, viewNodeAttributes);
+            switch (viewNode.type) {
+                case model_1.ViewNodeType.Graph:
+                    // note: do nothing
+                    break;
+                default:
+                    if (reader.tryMoveToIntermediate('viewAttributes')) {
+                        if (reader.tryMoveDown()) {
+                            while (this.parseViewAttribute(reader, viewNode, undefined)) {
+                                reader.next();
+                            }
+                            reader.moveUp();
+                        }
+                    }
+            }
+            reader.next();
+            viewNode.viewAttributeKeys = viewNode.elements._keys
+                .reduce((result, item) => {
+                if (item) {
+                    result[item] = true; //a, b, c
+                }
+                return result;
+            }, {});
+            // note: not process Graph node
+            if (reader.tryMoveToIntermediate('calculatedViewAttributes')) {
+                if (reader.tryMoveDown()) {
+                    while (this.parseCalculatedViewAttribute(reader, viewNode)) {
+                        reader.next();
+                    }
+                    reader.moveUp();
+                }
+                reader.next();
+            }
+            if (reader.tryMoveToIntermediate('restrictedViewAttributes')) {
+                if (reader.tryMoveDown()) {
+                    while (this.parseRestrictedViewAttribute(reader, viewNode)) {
+                        reader.next();
+                    }
+                    reader.moveUp();
+                }
+                reader.next();
+            }
+            while (reader.tryMoveTo('localVariable')) {
+                // note: do nothing
+                reader.next();
+            }
+            if (viewNodeAttributes.tableFunctionName && viewNode.type === 'TableFunction') {
+                // note: not process table function
+            }
+            while (this.parseInput(reader, viewNode, dataSources, nodeIDsInCalculationView)) {
+                reader.next();
+            }
+            while (this.parseVariableMappings(reader, 'variableMapping', columnView, viewNode.type, viewNode.name)) {
+                reader.next();
+            }
+            if (reader.tryMoveToIntermediate('rankingFilter')) {
+                this.parseRankingFilter(reader, viewNode, columnView);
+            }
+            else if (reader.tryMoveToIntermediate('windowFunction')) {
+                // this.parseWindowFunction( reader, viewNode, columnView, true );
+            }
+            if (viewNodeAttributes.type === model_1.ViewNodeType.WindowFunction) {
+                CalculationViewXmlParserHelper_1.default.processWindowFunction(reader, columnView, viewNode);
+            }
+            if (reader.tryMoveToIntermediate('filter')) {
+                // var filterExpression = reader.consumeContent();
+                // viewNode.createFilterExpression({
+                //     'formula': filterExpression,
+                //     'expressionLanguage': filterExpressionLanguage
+                // });
+                artifact_management_base_1.getLogger().trace(`filterExpressionLanguage: ${filterExpressionLanguage}`);
+                reader.next();
+            }
+            if (reader.tryMoveToIntermediate('definition')) {
+                // viewNode.definition = reader.consumeContent();
+                reader.next();
+            }
+            // todo: process certain node:
+            if (viewNodeAttributes.type === model_1.ViewNodeType.Union) { }
+            if (viewNodeAttributes.type === model_1.ViewNodeType.JoinNode) { }
+            if (viewNodeAttributes.type === model_1.ViewNodeType.NonEquiJoinNode) { }
+            if (viewNodeAttributes.type === model_1.ViewNodeType.Hierarchy) { }
+            if (viewNodeAttributes.type === model_1.ViewNodeType.Anonymize) { }
+            if (viewNodeAttributes.type === model_1.ViewNodeType.Projection) { }
+            reader.moveUp();
+            return true;
+        }
+        return false;
+    }
+    static parseViewAttribute(reader, viewNode, outputType) {
+        if (reader.tryMoveTo('viewAttribute')) {
+            const elementAttributes = reader.buildAttributes({
+                name: '{id}',
+                keep: '{keepFlag}',
+                aggregationBehavior: '{aggregationType}',
+                transparentFilter: '{transparentFilter}',
+                primitiveType: '{datatype}',
+                length: common_1.default.createIntSelector('length'),
+                scale: common_1.default.createIntSelector('scale'),
+                semanticType: '{semanticType}',
+                // measureType: '{measureType}',
+                presentationScale: '{presentationScale}',
+            });
+            const simpleTypeAttributes = {};
+            // In all cases except script view attribute and constant target attribute in Union
+            // view, ViewAttribute's Datatype is derived from its source; so defaulting isDerived
+            // flag to true
+            simpleTypeAttributes.isDerived = true;
+            if (elementAttributes.primitiveType && elementAttributes.primitiveType !== undefined) {
+                // It means it is a script view attribute or constant target attribute in Union view
+                CalculationViewXmlParserHelper_1.default.populateSimpleTypeAttributesFromElementAttributes(elementAttributes, simpleTypeAttributes);
+                simpleTypeAttributes.isDerived = false;
+            }
+            simpleTypeAttributes.semanticType = elementAttributes.semanticType;
+            simpleTypeAttributes.presentationScale = elementAttributes.presentationScale;
+            // Parse the description which includes the comment , for view attribute in view Node.
+            if (reader.tryMoveDown()) {
+                sharedmodel_1.default.parseDescriptions(reader, elementAttributes);
+                const attributes = {
+                    elementAttributes: elementAttributes,
+                };
+                this.parseCurrencyAndUnitConversion(reader, attributes, viewNode.$getContainer(), viewNode.name);
+                reader.moveUp();
+            }
+            // note: not process script node
+            // note: not process graph node
+            const element = viewNode.createOrMergeElement(elementAttributes, reader.skippedNodes);
+            element.createOrMergeSimpleType(simpleTypeAttributes);
+            element.keep = common_1.default.parseBool(elementAttributes.keep);
+            element.transparentFilter = common_1.default.parseBool(elementAttributes.transparentFilter);
+            return true;
+        }
+        return false;
+    }
+    static parseRestrictedViewAttribute(reader, viewNode) {
+        // note: do nothing
+        return false;
+    }
+    static parseRankingFilter(reader, viewNode, columnView) {
+        const rankingFilter = viewNode.createRankFilter({
+            type: reader.getAttribute('type'),
+            offset: reader.getAttribute('offset'),
+            offsetParameter: reader.getAttribute('offsetParameter'),
+            offsetReference: reader.getAttribute('offsetReference'),
+            dynamicPartitionElements: CalculationViewXmlParserHelper_1.default.getBooleanFromString(reader.getAttribute('dynamicPartitionAttributes')),
+        });
+        const windowFunctionPostProcessValues = {};
+        windowFunctionPostProcessValues.rankingFilter = rankingFilter;
+        if (reader.tryMoveDown()) {
+            const partitionViewAttributes = [];
+            const orders = [];
+            windowFunctionPostProcessValues.partitionViewAttributes = partitionViewAttributes;
+            windowFunctionPostProcessValues.orders = orders;
+            while (reader.tryMoveTo('partitionViewAttributeName')) {
+                partitionViewAttributes[partitionViewAttributes.length] =
+                    reader.getAttribute('id') || reader.getContent();
+                reader.next();
+            }
+            while (reader.tryMoveTo('order')) {
+                orders[orders.length] = reader.buildAttributes({
+                    byViewAttributeName: '{byViewAttributeName}',
+                    direction: '{direction}',
+                });
+                const orderProperties = {
+                    byElement: viewNode.elements.get(orders[orders.length - 1].byViewAttributeName),
+                    direction: orders[orders.length - 1].direction,
+                };
+                rankingFilter.createOrder(orderProperties, reader.skippedNodes);
+                reader.next();
+            }
+            let udf = CalculationViewXmlParserHelper_1.default.parseUDFParameter(reader, 'rankThreshold');
+            udf = exports.processUDFParameter(columnView, udf, udf);
+            const rankThreholdSkippedNodes = reader.skippedNodes;
+            rankingFilter.createOrMergeRankThreshold(udf, rankThreholdSkippedNodes);
+            if (reader.tryMoveTo('rankViewAttributeName')) {
+                rankingFilter.rankViewAttributeName = reader.getContent();
+                const elementAttributes = {};
+                elementAttributes.name = reader.consumeContent();
+                elementAttributes.aggregationBehavior = 'SUM';
+                elementAttributes.generatedColumn = true;
+                const element = viewNode.createOrMergeElement(elementAttributes, undefined);
+                const typeAttributes = {
+                    primitiveType: model_1.PrimitiveType.BIGINT,
+                };
+                element.createOrMergeSimpleType(typeAttributes);
+            }
+            reader.moveUp();
+            for (let i = 0; i < partitionViewAttributes.length; i++) {
+                const elemenLocal = viewNode.elements.get(partitionViewAttributes[i]);
+                rankingFilter.partitionElements.addValue(elemenLocal);
+            }
+        }
+    }
+    static parseCalculatedViewAttribute(reader, viewNode) {
+        if (reader.tryMoveTo('calculatedViewAttribute')) {
+            const elementAttributes = reader.buildAttributes({
+                name: '{id}',
+                primitiveType: '{datatype}',
+                length: common_1.default.createIntSelector('length'),
+                scale: common_1.default.createIntSelector('scale'),
+                expressionLanguage: '{expressionLanguage}',
+            });
+            const simpleTypeAttributes = {};
+            // For CalculatedViewAttribute isDerived will always be false
+            simpleTypeAttributes.isDerived = false;
+            if (elementAttributes.primitiveType && elementAttributes.primitiveType !== undefined) {
+                CalculationViewXmlParserHelper_1.default.populateSimpleTypeAttributesFromElementAttributes(elementAttributes, simpleTypeAttributes);
+            }
+            let formula = null;
+            if (reader.tryMoveDown()) {
+                /*reader.tryMoveToIntermediate("formula");
+                formula = reader.consumeContent();*/
+                /*if (reader.tryMoveToIntermediate("filter")) {
+                    RepositoryXmlParserHelper.processElementFilter(reader, viewNode, elementAttributes.name);
+                    reader.next();
+                }*/
+                if (reader.tryMoveToIntermediate('formula')) {
+                    formula = reader.consumeContent();
+                }
+            }
+            if (formula !== undefined && formula !== null) {
+                elementAttributes.formula = formula;
+            }
+            else {
+                elementAttributes.formula = '';
+            }
+            reader.skipChildren().next().moveUp();
+            const element = viewNode.createOrMergeElement(elementAttributes, reader.skippedNodes);
+            element.createOrMergeSimpleType(simpleTypeAttributes);
+            if (elementAttributes.formula !== undefined) {
+                element.createCalculationDefinition({
+                    'formula': elementAttributes.formula,
+                    'expressionLanguage': elementAttributes.expressionLanguage,
+                });
+            }
+            return true;
+        }
+        return false;
+    }
+    static parseInput(reader, viewNode, dataSources, nodeIDsInCalculationView) {
+        if (reader.tryMoveTo('input')) {
+            const nodeID = reader.consumeAttribute('node');
+            nodeIDsInCalculationView.push(nodeID);
+            const inputAttributes = reader.buildAttributes({
+                emptyUnionBehavior: '{emptyUnionBehavior}',
+                tableParameterName: '{tableParameterName}',
+                type: '{type}',
+            });
+            const outputName = reader.consumeAttribute('outputName');
+            if (outputName) {
+                inputAttributes.outputName = outputName;
+            }
+            // : If View Node is Union then set default emptyUnionBehavior value even if it is not
+            // present in legacy model - TODO
+            if (viewNode.type === model_1.ViewNodeType.Union &&
+                inputAttributes.emptyUnionBehavior === undefined) {
+                inputAttributes.emptyUnionBehavior = 'NO_ROW';
+            }
+            const input = viewNode.createInput(inputAttributes, reader.skippedNodes);
+            input.setSource(getSourceForInput(nodeID, dataSources, viewNode));
+            input.repositoryInputNodeId = nodeID;
+            const columnView = viewNode.$getContainer();
+            if (reader.tryMoveDown()) {
+                while (this.parseMapping(reader, input, columnView, false)) {
+                    reader.next();
+                }
+                reader.moveUp();
+            }
+            const singleDataSourceNodes = [
+                model_1.ViewNodeType.Projection,
+                model_1.ViewNodeType.Aggregation,
+                model_1.ViewNodeType.Rank,
+                model_1.ViewNodeType.WindowFunction,
+                model_1.ViewNodeType.Anonymize,
+            ];
+            if (singleDataSourceNodes.indexOf(viewNode.type) !== -1) {
+                for (const attrKey in viewNode.viewAttributeKeys) {
+                    this.parseMapping(reader, input, columnView, true, attrKey);
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    static parseMapping(reader, input, columnView, isSimpleMapping, mappingElementName = '') {
+        if (reader.tryMoveTo('mapping') || isSimpleMapping) {
+            const mapType = function (value) {
+                const type = reader.removePrefix(sharedmodel_1.default.NameSpace.CALCULATION, value);
+                switch (type) {
+                    case 'AttributeMapping':
+                        return model_1.MappingType.ElementMapping;
+                    case 'ConstantAttributeMapping':
+                        return model_1.MappingType.ConstantElementMapping;
+                    default:
+                        return type;
+                }
+            };
+            let mappingAttributes = null;
+            if (isSimpleMapping) {
+                mappingAttributes = {
+                    type: model_1.MappingType.ElementMapping,
+                    sourceName: mappingElementName,
+                    targetName: mappingElementName,
+                };
+            }
+            else {
+                mappingAttributes = reader.buildAttributes({
+                    type: common_1.default.createXsiSelector('type', mapType),
+                    sourceName: '{source}',
+                    targetName: '{target}',
+                    isNull: '{null}',
+                    value: '{value}',
+                });
+            }
+            const viewNode = input.$getContainer();
+            // note: table function is not handled yet
+            mappingAttributes.targetElement = viewNode.elements.get(mappingAttributes.targetName);
+            delete mappingAttributes.targetName;
+            if (mappingAttributes.targetElement &&
+                mappingAttributes.targetElement.isCalculatedColumn &&
+                mappingAttributes.targetElement.isRestrictedColumn &&
+                (mappingAttributes.targetElement.isCalculatedColumn() ||
+                    mappingAttributes.targetElement.isRestrictedColumn())) {
+                return true;
+            }
+            const inputSource = input.getSource();
+            if (inputSource instanceof model_1.Entity && mappingAttributes.sourceName !== undefined) {
+                addElementToEntityIfNotPresent(inputSource, mappingAttributes.sourceName);
+                // } else if (inputSource instanceof ViewNode && mappingAttributes.sourceName !== undefined) {
+                //     addElementToViewNodeIfNotPresent( inputSource, mappingAttributes.sourceName );
+            }
+            // note: not handle Graph node
+            if (mappingAttributes.sourceName !== undefined) {
+                mappingAttributes.sourceElement = inputSource.elements
+                    .get(mappingAttributes.sourceName);
+                delete mappingAttributes.sourceName;
+            }
+            else if (mappingAttributes.type === model_1.MappingType.ElementMapping) {
+                return true;
+            }
+            if (mappingAttributes.isNull) {
+                mappingAttributes.isNull = common_1.default.parseBool(mappingAttributes.isNull);
+            }
+            // if ( viewNode.multiJoinNode ) {
+            //     mappingAttributes.sourceInput = input;
+            // }
+            const mapping = input.createMapping(mappingAttributes, reader.skippedNodes);
+            if (mapping.type === model_1.MappingType.ElementMapping &&
+                viewNode.viewAttributeKeys[mappingAttributes.targetElement.name]) {
+                delete viewNode.viewAttributeKeys[mappingAttributes.targetElement.name];
+            }
+            if (!isSimpleMapping) {
+                reader.skipChildren();
+            }
+            return true;
+        }
+        return false;
+    }
+    static parseVariableMappings(reader, variableMappingTagName, columnView, nodetype, nodeName) {
+        // note: do nothing
+        return false;
+    }
+    static parseVariableMapping(reader, variableMappingTagName, columnView) {
+        if (!variableMappingTagName) {
+            variableMappingTagName = 'variableMapping';
+        }
+        if (reader.tryMoveTo(variableMappingTagName)) {
+            const parsingMapper = function (value) {
+                return reader.removePrefix(sharedmodel_1.default.NameSpace.ACCESSCONTROL, value);
+            };
+            const variableMappingData = reader.buildAttributes({
+                type: common_1.default.createXsiSelector('type', parsingMapper),
+                value: '{value}',
+                dataSource: '{dataSource}',
+                forStarJoin: '{forStarJoin}',
+            });
+            if (reader.tryMoveDown()) {
+                if (reader.tryMoveTo('targetVariable')) {
+                    variableMappingData.parameterNameOtherView = reader.getAttribute('name');
+                    variableMappingData.resourceUri = reader.getAttribute('resourceUri');
+                    if (reader.tryMoveToIntermediate('localVariable')) {
+                        const localVariable = reader.consumeContent();
+                        variableMappingData.parameterName = localVariable;
+                    }
+                }
+                reader.moveUp();
+            }
+            return variableMappingData;
+        }
+        return undefined;
+    }
+    static postProcessVariableMappings(reader, variableMappingData, parent, columnView) {
+        // note: do nothing
+    }
+    static parseLogicalModel(reader, columnView, outputViewType, outputViewName, dataSources, isStarJoin) {
+        reader.moveTo('logicalModel');
+        const sourceName = reader.consumeAttribute('id');
+        const outputName = reader.consumeAttribute('outputName');
+        const filterExpressionLanguage = reader.consumeAttribute('filterExpressionLanguage');
+        if (!columnView.viewNodes.get(sourceName)) {
+            // could be Multi join node.
+            // if ( ConvertMultiJoinToBinaryJoin._multiJoinKeyValuePair[sourceName] ) {
+            //     sourceName = ConvertMultiJoinToBinaryJoin._multiJoinKeyValuePair[sourceName];
+            // }
+        }
+        const viewNodeAttributes = reader.buildAttributes({
+            name: outputViewName,
+            type: outputViewType,
+            ignoreMultipleOutputsForFilter: '{ignoreMultipleOutputsForFilter}',
+        });
+        viewNodeAttributes.ignoreMultipleOutputsForFilter =
+            CalculationViewXmlParserHelper_1.default.getBooleanFromString(viewNodeAttributes.ignoreMultipleOutputsForFilter);
+        const viewNode = columnView.createOrMergeViewNode(viewNodeAttributes, reader.skippedNodes, true);
+        artifact_management_base_1.getLogger().trace(`created default node: ${outputViewName}`);
+        let input = null;
+        // : if no table/view is assigned to Default Node, i.e; if there is no input to default node
+        // then source Name will be null.
+        if (!viewNode.isScriptNode() && sourceName) {
+            input = viewNode.createInput({}, {});
+            input.setSource(getSourceForInput(sourceName, dataSources, viewNode));
+            input.repositoryInputNodeId = sourceName;
+            if (outputName) {
+                // note: not process outputName, outputName is for Graph node
+                // input.outputName = outputName;
+            }
+        }
+        if (sourceName) {
+            const dataSource = getDataSource(sourceName, dataSources, columnView);
+            artifact_management_base_1.getLogger().trace(`got dataSource: ${dataSource}`);
+            // note: not set input alias
+        }
+        let singleElementAttributes = null; // new object to be used for creating Element seqentially
+        let elementIndex = 0;
+        const allAttributes = [];
+        viewNode.starJoinPrivateElements = [];
+        reader.moveDown();
+        if (reader.moveToIntermediate('attributes').tryMoveDown()) {
+            while (this.parseAttribute(reader, viewNode, allAttributes)) {
+                singleElementAttributes = allAttributes[elementIndex];
+                // Calling createDefaultNodeElement() which creates element based on order in
+                // viewnode's elements list
+                this.createDefaultNodeElement(viewNode, singleElementAttributes, viewNode.isScriptNode(), isStarJoin);
+                elementIndex++;
+                reader.next();
+            }
+            reader.moveUp();
+        }
+        reader.next();
+        if (reader.moveToIntermediate('calculatedAttributes').tryMoveDown()) {
+            while (this.parseCalculatedAttribute(reader, viewNode, allAttributes)) {
+                singleElementAttributes = allAttributes[elementIndex];
+                this.createDefaultNodeElement(viewNode, singleElementAttributes, viewNode.isScriptNode(), isStarJoin);
+                elementIndex++;
+                reader.next();
+            }
+            reader.moveUp();
+        }
+        reader.next();
+        if (reader.moveToIntermediate('baseMeasures').tryMoveDown()) {
+            while (this.parseMeasure(reader, viewNode, allAttributes)) {
+                singleElementAttributes = allAttributes[elementIndex];
+                this.createDefaultNodeElement(viewNode, singleElementAttributes, viewNode.isScriptNode(), isStarJoin);
+                elementIndex++;
+                reader.next();
+            }
+            reader.moveUp();
+        }
+        reader.next();
+        if (reader.moveToIntermediate('calculatedMeasures').tryMoveDown()) {
+            while (this.parseCalculatedMeasure(reader, viewNode, allAttributes)) {
+                singleElementAttributes = allAttributes[elementIndex];
+                this.createDefaultNodeElement(viewNode, singleElementAttributes, viewNode.isScriptNode(), isStarJoin);
+                elementIndex++;
+                reader.next();
+            }
+            reader.moveUp();
+        }
+        reader.next();
+        if (reader.moveToIntermediate('restrictedMeasures').tryMoveDown()) {
+            // throwUnsupportedOperationException("Restricted Column");
+            while (this.parseRestrictedMeasure(reader, viewNode, allAttributes)) {
+                // throwUnsupportedOperationException("Restricted Column");
+                singleElementAttributes = allAttributes[elementIndex];
+                this.createDefaultNodeElement(viewNode, singleElementAttributes, viewNode.isScriptNode(), isStarJoin);
+                elementIndex++;
+                reader.next();
+            }
+            reader.moveUp();
+        }
+        reader.next();
+        if (reader.tryMoveToIntermediate('sortAttributes')) {
+            if (reader.tryMoveDown()) {
+                while (reader.tryMoveTo('sortAttribute')) {
+                    const sortAttributeProperties = reader.buildAttributes({
+                        id: '{id}',
+                        direction: '{direction}',
+                    });
+                    sortAttributeProperties.name = viewNode.elements.get(sortAttributeProperties.id);
+                    if (!sortAttributeProperties.name) {
+                        viewNode.inputs.foreach(function (input) {
+                            if (input) {
+                                input.getSource().elements
+                                    .foreach(function (element) {
+                                    if (element.name === sortAttributeProperties.id) {
+                                        sortAttributeProperties.name = element;
+                                    }
+                                });
+                            }
+                        });
+                    }
+                    if (!sortAttributeProperties.name) {
+                        sortAttributeProperties.name = {
+                            name: sortAttributeProperties.id,
+                        };
+                    }
+                    viewNode.createSortAttributes(sortAttributeProperties, reader.skippedNodes);
+                    reader.next();
+                }
+            }
+            reader.moveUp();
+            reader.next();
+        }
+        // : At last add all private join colulmns of star join
+        for (let i = 0; i < viewNode.starJoinPrivateElements.length; i++) {
+            const starJoinPrivateElement = viewNode.starJoinPrivateElements[i];
+            // viewNode.elements.add(starJoinPrivateElement);
+            for (let index = 0; index < columnView._defaultNodeElementInstancesArray.length; index++) {
+                const elementInstance = columnView._defaultNodeElementInstancesArray[index];
+                if (elementInstance && starJoinPrivateElement &&
+                    elementInstance.name === starJoinPrivateElement.name) {
+                    delete columnView._defaultNodeElementInstancesArray[index];
+                }
+            }
+        }
+        // Check whether any proxy Element exists; if yes throw TransformationException
+        const proxyElementInstanceFound = this._checkProxyElementsInDefaultNode(viewNode);
+        if (proxyElementInstanceFound) {
+            throw new modelbase_1.TransformationException('Element {0} not found', [proxyElementInstanceFound.name]);
+        }
+        if (columnView.dataCategory === model_1.DataCategory.CUBE) {
+            if (reader.tryMoveToIntermediate('localDimensions')) {
+                // note: do nothing
+                reader.next();
+            }
+        }
+        // Star Join Code - START
+        if (reader.tryMoveToIntermediate('sharedDimensions')) {
+            if (reader.tryMoveDown()) {
+                while (reader.tryMoveTo('logicalJoin')) {
+                    const logicalJoinAttributes = reader.buildAttributes({
+                        languageAttributeName: '{languageAttributeName}',
+                        useDimensionViewHierarchies: '{useDimensionViewHierarchies}',
+                    });
+                    logicalJoinAttributes.useDimensionViewHierarchies =
+                        CalculationViewXmlParserHelper_1.default.getBooleanFromString(logicalJoinAttributes.useDimensionViewHierarchies);
+                    const associatedObjectUri = reader.consumeAttribute('associatedObjectUri');
+                    const fqName = associatedObjectUri; // FullQualifiedName.createByResourceURI(associatedObjectUri);
+                    const sharedEntity = exports.getEntity(columnView, fqName, undefined /*RepositoryXmlParserHelper.mapRepositoryTypeToEntityType(fqName.getSuffix())*/);
+                    sharedEntity.isLoadFromXML = true;
+                    const sharedInput = viewNode.createInput({}, undefined);
+                    sharedInput.setSource(sharedEntity);
+                    sharedInput.selectAll = true;
+                    let attributeRef = [];
+                    let attributeName = null;
+                    let join = null;
+                    if (reader.tryMoveDown()) {
+                        attributeRef = this.parseStarJoinPrivateJoinColumns(reader);
+                        attributeName = this.parseStarJoinSharedJoinColumns(reader);
+                        if (attributeRef.length !== attributeName.length) {
+                            throw new modelbase_1.TransformationException('Join for attribute view {0} is inconsistent', [fqName]);
+                        }
+                        const joinAttributes = this.parseStarJoinJoinProperties(reader);
+                        // Create join
+                        const starJoinNode = columnView.getDefaultNode();
+                        starJoinNode.useDimensionViewHierarchies = logicalJoinAttributes.useDimensionViewHierarchies;
+                        if (logicalJoinAttributes.languageAttributeName) {
+                            // joinAttributes.textJoinLanguageElementName =
+                            // logicalJoinAttributes.languageAttributeName;
+                            joinAttributes.languageColumn = logicalJoinAttributes.languageAttributeName;
+                        }
+                        if (joinAttributes) {
+                            join = starJoinNode.createJoin(joinAttributes, undefined);
+                            join.leftInput = input;
+                            /*var sharedInput = viewNode.createInput();
+                            sharedInput.setSource(sharedEntity);*/
+                            join.rightInput = sharedInput;
+                            join.rightInput.selectAll = true;
+                            this.processTemporalJoinProperties(reader, columnView.getDefaultNode(), sharedInput, join);
+                            if (logicalJoinAttributes.languageAttributeName &&
+                                logicalJoinAttributes.languageAttributeName !== 'undefined') {
+                                exports.getElementFromsharedEntity(sharedEntity, logicalJoinAttributes.languageAttributeName);
+                            }
+                            this.processStarJoinAliasedSharedJoinColumns(reader, columnView, fqName, sharedInput);
+                            this.parseAssociatedHierarchyFeature(reader, columnView, fqName, sharedEntity);
+                            this.processStarJoinSemanticAttributeMappings(reader, starJoinNode, sharedEntity, sharedInput);
+                        }
+                        reader.next();
+                        // : ThrowUnsupportedOperationException for Calc Integration of Hierarchies
+                        if (reader._current && reader._current.nextSibling &&
+                            reader._current.nextSibling.nodeName === 'associatedHierarchyFeature') {
+                            throw new modelbase_1.UnsupportedOperationException('Calc Integration of Hierarchies');
+                        }
+                        reader.moveUp();
+                    }
+                    // TODO: no need of listOfLocalJoinedAttributes : delete it later
+                    const listOfLocalJoinedAttributes = [];
+                    attributeRef = this.remove$localFromStarJoinPrivateJoinColumns(attributeRef, columnView);
+                    if (attributeRef && attributeName) {
+                        for (let i = 0; i < attributeRef.length; i++) {
+                            const leftJoinElementName = attributeRef[i];
+                            const inputSource = this.getStarJoinViewNodeInputSource(viewNode);
+                            const leftJoinElement = inputSource.elements.get(leftJoinElementName);
+                            // join.leftElements.add(leftJoinElement);
+                            if (listOfLocalJoinedAttributes.indexOf(leftJoinElementName) === -1) {
+                                listOfLocalJoinedAttributes.push(leftJoinElementName);
+                            }
+                            const rightJoinElementName = attributeName[i];
+                            // var rightJoinElement = getElementFromEntity(columnView, fqName,
+                            // rightJoinElementName);
+                            // inXSA there is no package and schema concept, the name itself is the
+                            // uri
+                            const rightSharedEntity = exports.getEntity(columnView, fqName, undefined /*RepositoryXmlParserHelper.mapRepositoryTypeToEntityType(fqName.getSuffix())*/);
+                            const rightJoinElement = exports.getElementFromsharedEntity(rightSharedEntity, rightJoinElementName);
+                            /*join.leftElements.add(leftJoinElement);
+                            join.rightElements.add(rightJoinElement);*/
+                            const key = leftJoinElement.name + '$$' + rightJoinElement.name;
+                            join.leftElements.add(key, leftJoinElement);
+                            join.rightElements.add(key, rightJoinElement);
+                            if (join.joinType === model_1.JoinType.LEFT_OUTER) {
+                                const mappingAttributes = {};
+                                mappingAttributes.type = model_1.MappingType.InputMapping;
+                                mappingAttributes.sourceElement = leftJoinElement;
+                                mappingAttributes.targetElement = rightJoinElement;
+                                mappingAttributes.sourceInput = input;
+                                sharedInput.createMapping(mappingAttributes, undefined);
+                            }
+                        }
+                    }
+                    // Join Attribute and mapping should not be present in logical Join as a private
+                    // element
+                    // Same local Join Attribute can be joined to more than one CV dimensions; even
+                    // in this case, we should remove it only one time from private attribute list,
+                    // because no matter how many time a local Join Attribute is joined, there will
+                    // be only one corresponding private attribute(with suffix '$local') added in
+                    // logical model,
+                    // while saving by M2M which should be removed while loading
+                    for (let i = 0; i < listOfLocalJoinedAttributes.length; i++) {
+                        // var elementName = listOfLocalJoinedAttributes[i];
+                        // var elementToRemove = viewNode.elements.get(elementName);
+                        /*RepositoryXmlParserHelper.removeAttributeMappingForAttribute(elementToRemove, input);
+                        viewNode.elements.remove(listOfLocalJoinedAttributes[i]);*/
+                    }
+                    reader.next();
+                }
+                reader.moveUp();
+            }
+            reader.next();
+        }
+        // Star Join Code - END
+        // filters
+        if (reader.tryMoveToIntermediate('filter')) {
+            const filterExpression = reader.consumeContent();
+            viewNode.createFilterExpression({
+                formula: filterExpression,
+                expressionLanguage: filterExpressionLanguage,
+            }, undefined);
+            artifact_management_base_1.getLogger().trace(`formula: ${filterExpression}, expressionLanguage: ${filterExpressionLanguage}`);
+            reader.next();
+        }
+    }
+    static parseStarJoinPrivateJoinColumns(reader) {
+        const attributeRefs = [];
+        if (reader.tryMoveTo('attributes')) {
+            if (reader.tryMoveDown()) {
+                while (reader.tryMoveTo('attributeRef')) {
+                    const localJoinAttr = reader.consumeContent();
+                    attributeRefs.push(localJoinAttr);
+                    reader.next();
+                }
+                reader.moveUp();
+            }
+        }
+        return attributeRefs;
+    }
+    static parseStarJoinSharedJoinColumns(reader) {
+        const attributeNames = [];
+        if (reader.tryMoveTo('associatedAttributeNames')) {
+            if (reader.tryMoveDown()) {
+                while (reader.tryMoveTo('attributeName')) {
+                    const sharedJoinAttrName = reader.consumeContent();
+                    attributeNames.push(sharedJoinAttrName);
+                    reader.next();
+                }
+                reader.moveUp();
+            }
+        }
+        return attributeNames;
+    }
+    static parseStarJoinJoinProperties(reader) {
+        let joinAttributes = null;
+        if (reader.tryMoveTo('properties')) {
+            joinAttributes = reader.buildAttributes({
+                joinType: '{joinType}',
+                cardinality: '{cardinality}',
+                joinOperator: '{joinOperator}',
+                optimizeJoinColumns: '{optimizeJoinColumns}',
+                greedyJoinPruning: '{greedyJoinPruning}',
+                dimensionJoin: '{dimensionJoin}',
+                dynamic: '{dynamic}',
+                languageAttributeName: '{languageAttributeName}',
+                referentialDirection: '{referentialDirection}',
+            });
+        }
+        if (joinAttributes) {
+            joinAttributes.optimizeJoinColumns =
+                CalculationViewXmlParserHelper_1.default.getBooleanFromString(joinAttributes.optimizeJoinColumns);
+        }
+        return joinAttributes;
+    }
+    static processTemporalJoinProperties(reader, viewNode, input, join) {
+        if (reader.tryMoveTo('temporalJoinProperties')) {
+            const temporalCondition = reader.consumeAttribute('temporalCondition');
+            const temporalJoinProperties = join.createTemporalJoinProperties({
+                temporalCondition: temporalCondition,
+            });
+            const temporalElementName = reader.consumeAttribute('temporalElementName');
+            if (temporalElementName) {
+                temporalJoinProperties.temporalElement = viewNode.elements.get(temporalElementName);
+            }
+            const rightSharedEntity = input.getSource();
+            const fromElementName = reader.consumeAttribute('fromElementName');
+            if (fromElementName) {
+                temporalJoinProperties.fromElement = exports.getElementFromsharedEntity(rightSharedEntity, fromElementName);
+            }
+            const toElementName = reader.consumeAttribute('toElementName');
+            if (toElementName) {
+                temporalJoinProperties.toElement = exports.getElementFromsharedEntity(rightSharedEntity, toElementName);
+            }
+        }
+    }
+    static processStarJoinAliasedSharedJoinColumns(reader, columnView, fqName, sharedInput) {
+        if (reader.tryMoveTo('associatedAttributeFeatures')) {
+            // note: do nothing
+        }
+    }
+    static parseAssociatedHierarchyFeature(reader, columnView, fqName, sharedEntity) {
+        while (reader.tryMoveTo('associatedHierarchyFeature')) {
+            // note: do nothing
+            reader.next();
+        }
+    }
+    static processStarJoinSemanticAttributeMappings(reader, starJoinNode, sharedEntity, sharedInput) {
+        if (reader.tryMoveTo('semanticAttributeMappings')) {
+            // note: do nothing
+        }
+    }
+    static remove$localFromStarJoinPrivateJoinColumns(attributeRefs, columnView) {
+        const privateJoinColumnNames = [];
+        for (let i = 0; i < attributeRefs.length; i++) {
+            if (attributeRefs[i] && attributeRefs[i].indexOf('$local') > -1) {
+                const elementAttributes_name_parts = attributeRefs[i].split('$local');
+                if (elementAttributes_name_parts && elementAttributes_name_parts.length > 0) {
+                    privateJoinColumnNames[i] = elementAttributes_name_parts[0];
+                }
+            }
+        }
+        return privateJoinColumnNames;
+    }
+    static getStarJoinViewNodeInput(viewNode) {
+        let input = null;
+        for (let i = 0; i < viewNode.inputs.count(); i++) {
+            if (viewNode.inputs.getAt(i) &&
+                viewNode.inputs.getAt(i).getSource() instanceof model_1.ViewNode) {
+                input = viewNode.inputs.getAt(i);
+                break;
+            }
+        }
+        return input;
+    }
+    static getStarJoinViewNodeInputSource(viewNode) {
+        const inputSource = this.getStarJoinViewNodeInput(viewNode).getSource();
+        return inputSource;
+    }
+    static parseCurrencyAndUnitConversion(reader, attributes, columnView, viewNodeName) {
+        // note: do nothing
+    }
+    static createDefaultNodeElement(viewNode, attributes, isScriptNode, isStarJoin) {
+        const columnView = viewNode.$getContainer();
+        let element = this._getDefaultNodeElementInstanceByElementName(columnView, attributes.elementAttributes.name, false);
+        if (isScriptNode ||
+            (isStarJoin && attributes.elementAttributes && attributes.elementAttributes.name &&
+                attributes.elementAttributes.name.match(/[$]local$/))) {
+            // For ScriptNode and StarJoin go usual way
+            let elementAttributes_name_parts = null;
+            if (!element && isStarJoin) {
+                if (attributes.elementAttributes && attributes.elementAttributes.name &&
+                    attributes.elementAttributes.name.match(/[$]local$/)) {
+                    if (attributes.elementAttributes && attributes.elementAttributes.name &&
+                        attributes.elementAttributes.name.indexOf('$local') > -1) {
+                        elementAttributes_name_parts = attributes.elementAttributes.name.split('$local');
+                        if (elementAttributes_name_parts && elementAttributes_name_parts.length > 0) {
+                            attributes.elementAttributes.name = elementAttributes_name_parts[0];
+                        }
+                    }
+                    const starJoinPrivateElement = viewNode.createOrMergeElement(attributes.elementAttributes, attributes.elementSkippedNodes);
+                    viewNode.starJoinPrivateElements.push(starJoinPrivateElement);
+                }
+            }
+            else if (element && isStarJoin) {
+                elementAttributes_name_parts = element.name.split('$local');
+                if (elementAttributes_name_parts && elementAttributes_name_parts.length > 0) {
+                    /*element.name = elementAttributes_name_parts[0];
+                     element.name = RepositoryXmlParserHelper.removeHashTag(element.name);*/
+                    const localElement = viewNode.createElementWithoutAddingIntoElementCollection(attributes.elementAttributes);
+                    viewNode.starJoinPrivateElements.push(localElement);
+                }
+            }
+        }
+        else {
+            // create Element Based On Order Index
+            let index = attributes.order;
+            index = common_1.default.parseInt(index);
+            if (element) {
+                attributes.elementAttributes.isProxy = false;
+                element.$setAttributes(attributes.elementAttributes);
+                this._setSkippedNodes(element, attributes.elementSkippedNodes);
+            }
+            else {
+                element = viewNode.createElementWithoutAddingIntoElementCollection(attributes.elementAttributes, attributes.elementSkippedNodes);
+            }
+            viewNode.elements.setAt(index, element);
+        }
+        // element.keep = Util.parseBool( attributes.elementAttributes.keep );
+        // if ( attributes.elementAttributes.key === 'true' ) {
+        //     element.$getContainer().keyElements.add( element );
+        // }
+        element = element;
+        if (attributes.simpleTypeAttributes) {
+            element.createOrMergeSimpleType(attributes.simpleTypeAttributes);
+        }
+        if (attributes.mappingAttributes && !isScriptNode) {
+            let inputSource = null, _input = null;
+            if (viewNode.type === model_1.ViewNodeType.JoinNode) {
+                // for star join, ViewNode can be in any input; it will not be fixed at first input
+                for (let i = 0; i < viewNode.inputs.count(); i++) {
+                    if (viewNode.inputs.getAt(i) &&
+                        viewNode.inputs.getAt(i).getSource() instanceof model_1.ViewNode) {
+                        inputSource = viewNode.inputs.getAt(i).getSource();
+                        _input = viewNode.inputs.getAt(i);
+                        break;
+                    }
+                }
+            }
+            else {
+                _input = viewNode.inputs.getAt(0);
+                inputSource = _input.getSource();
+            }
+            if (inputSource !== undefined && inputSource instanceof model_1.Entity &&
+                attributes.mappingAttributes.sourceName) {
+                addElementToEntityIfNotPresent(inputSource, attributes.mappingAttributes.sourceName);
+            }
+            // Do not create mapping for star join private join column
+            let needToCreateMapping = true;
+            if (attributes.elementAttributes && attributes.elementAttributes.name &&
+                attributes.elementAttributes.name.match(/[$]local$/)) {
+                needToCreateMapping = false;
+            }
+            if (needToCreateMapping) {
+                const _element = inputSource.elements;
+                // if ( inputSource.tableFunctionName && !_element.get( attributes.mappingAttributes.sourceName ) ) {
+                //     attributes.mappingAttributes.sourceElement = inputSource.createElement({
+                //         name: attributes.mappingAttributes.sourceName,
+                //     });
+                // } else {
+                attributes.mappingAttributes.sourceElement = _element.get(attributes.mappingAttributes.sourceName);
+                // }
+                attributes.mappingAttributes.targetElement = element;
+                //delete attributes.mappingAttributes.sourceName;
+                delete attributes.mappingAttributes.targetName;
+                element.createDefaultMapping(attributes.mappingAttributes, attributes.mappingSkippedNodes);
+            }
+        }
+        if (attributes.elementAttributes.formula !== undefined &&
+            attributes.elementAttributes.formula !== null) {
+            // element.createCalculationDefinition({
+            //     'formula': attributes.elementAttributes.formula,
+            //     'expressionLanguage': attributes.elementAttributes.expressionLanguage,
+            // });
+        }
+    }
+    static parseUnitCurrencyAttribute(reader, attributes) {
+        if (reader.tryMoveToIntermediate('unitCurrencyAttribute')) {
+            // note: not process
+            // attributes.unitCurrencyAttributeName = reader.consumeAttribute( 'attributeName' );
+        }
+        // if ( attributes.unitCurrencyAttributeName ) {
+        //     this.registerForLoadPostProcessing( reader, {
+        //         attribute: attributes.elementAttributes.name,
+        //         value: attributes.unitCurrencyAttributeName,
+        //     }, populateUnitCurrencyElements );
+        // }
+    }
+    static parseAttribute(reader, viewNode, allAttributes) {
+        if (reader.tryMoveTo('attribute')) {
+            const attributes = {
+                order: reader.consumeAttribute('order'),
+            };
+            attributes.elementAttributes = reader.buildAttributes({
+                name: '{id}',
+                hidden: '{hidden}',
+                aggregationBehavior: 'none',
+                attributeHierarchyActive: '{attributeHierarchyActive}',
+                displayAttribute: '{displayAttribute}',
+                displayFolder: '{displayFolder}',
+                infoObjectName: '{infoObject}',
+                attributeHierarchyDefaultMember: '{attributeHierarchyDefaultMember}',
+                keep: '{keepFlag}',
+                key: '{key}',
+                descriptionColumnName: '{descriptionColumnName}',
+                semanticType: '{semanticType}',
+                transparentFilter: '{transparentFilter}',
+                deprecated: '{deprecated}',
+                replaceNull: '{replaceNull}',
+                replaceNullBy: '{replaceNullBy}',
+            });
+            if (attributes.elementAttributes.replaceNull !== undefined && attributes.elementAttributes.replaceNull !== null) {
+                attributes.elementAttributes.replaceNull = common_1.default.parseBool(attributes.elementAttributes.replaceNull);
+            }
+            attributes.elementAttributes.transparentFilter = common_1.default.parseBool(attributes.elementAttributes.transparentFilter);
+            attributes.elementAttributes.deprecated = common_1.default.parseBool(attributes.elementAttributes.deprecated);
+            attributes.elementAttributes.hidden = CalculationViewXmlParserHelper_1.default.getBooleanFromString(attributes.elementAttributes.hidden);
+            // Create element instance upfront to be used to set other properties on it, e.g; label
+            // element
+            const columnView = viewNode.$getContainer();
+            const element = this._getDefaultNodeElementInstanceByElementName(columnView, attributes.elementAttributes.name, true);
+            // attributes.elementAttributes.transparentFilter =
+            // Util.parseBool(attributes.elementAttributes.transparentFilter);
+            // : Read semanticType using buildAttributes when reading other attributes to avoid
+            // reset issue
+            attributes.simpleTypeAttributes = {};
+            attributes.simpleTypeAttributes.semanticType = attributes.elementAttributes.semanticType;
+            // For Attribute in logical model isDerived will always be true
+            attributes.simpleTypeAttributes.isDerived = true;
+            attributes.elementSkippedNodes = reader.skippedNodes;
+            allAttributes.push(attributes);
+            reader.moveDown();
+            // parseDescriptions
+            sharedmodel_1.default.parseDescriptions(reader, attributes.elementAttributes);
+            CalculationViewXmlParserHelper_1.default.createEndUserTextsIfRequired(element, attributes.elementAttributes);
+            this.parseMaskingExpression(reader, element);
+            // parse InternalExternalConversion
+            this.processInternalExternalConversion(reader, element);
+            // Attribute can have unitCurrencyAttribute
+            if (attributes.simpleTypeAttributes.semanticType !== undefined &&
+                (attributes.simpleTypeAttributes.semanticType === 'amount' ||
+                    attributes.simpleTypeAttributes.semanticType === 'quantity')) {
+                this.parseUnitCurrencyAttribute(reader, attributes);
+                // : Do we need to thow UnsupportedOperationException since in UI
+                // UnitCurrencyAttribute for Attribute is not supported - TODO
+            }
+            this.processTypedObjectExternalTypeOfElement(reader, columnView, element, false);
+            this.processTypedObjectExternalTypeOfElementParameterMapping(reader, element, columnView);
+            // reader.next();
+            if (attributes.elementAttributes.descriptionColumnName !== undefined) {
+                // element.labelElement = this._getDefaultNodeElementInstanceByElementName( columnView, attributes.elementAttributes.descriptionColumnName,
+                //     true );
+            }
+            const attributeRelationshipAttributes = [];
+            while (reader.tryMoveTo('attributeRelationship')) {
+                const attributeRelationshipAttribute = reader.buildAttributes({
+                    parentAttributeName: '{parentAttribute}',
+                    type: '{type}',
+                });
+                attributeRelationshipAttributes.push(attributeRelationshipAttribute);
+                reader.next();
+            }
+            if (attributeRelationshipAttributes.length > 0) {
+                // this.registerForLoadPostProcessing( reader, attributeRelationshipAttributes, function( columnView ) {
+                //     for ( let index = 0; index < attributeRelationshipAttributes.length; index++ ) {
+                //         if ( attributeRelationshipAttributes[index].parentAttributeName ) {
+                //             attributeRelationshipAttributes[index].parentAttribute = getElementFromColumnView( columnView, attributeRelationshipAttributes[
+                //                 index].parentAttributeName );
+                //             delete attributeRelationshipAttributes[index].parentAttributeName;
+                //             element.createAttributeRelationship( attributeRelationshipAttributes[index] );
+                //         }
+                //     }
+                // });
+            }
+            if (reader.tryMoveToIntermediate('localVariable')) {
+                const variableName = reader.consumeContent();
+                const parameter = exports.getParameterFromColumnView(columnView, variableName);
+                if (parameter) {
+                    parameter.assignedElements.addValue(element);
+                }
+                reader.next();
+            }
+            if (reader.tryMoveToIntermediate('keyMapping')) {
+                attributes.mappingAttributes = reader.buildAttributes({
+                    type: 'ElementMapping',
+                    sourceName: '{columnName}',
+                    targetName: attributes.elementAttributes.name,
+                });
+            }
+            else {
+                // note: not process hasNoMapping
+                // attributes.elementAttributes.hasNoMapping = true;
+            }
+            // : Old way of storing descriptionColumn - TODO
+            /*
+            if (reader.tryMoveToIntermediate("descriptionMapping")) {
+                attributes.descriptionMappingAttributes = reader.buildAttributes({
+                    descriptionColumnName: "{columnName}"
+                });
+            }
+            */
+            // : Search Attributes and Attribute Relationship - TODO
+            // : ExternalLikeElementName - SP10 Task
+            // Reading currently using DOM API
+            // RepositoryXmlParserHelper.parseValueHelpForAttributeWithDomAPI(viewNode, reader);
+            // var mappingSkippedNodes = reader.skippedNodes;
+            //attributes.mappingSkippedNodes = reader.skippedNodes;
+            reader.skipChildren().next().moveUp();
+            return true;
+        }
+        return false;
+    }
+    static parseCalculatedAttribute(reader, viewNode, allAttributes) {
+        if (reader.tryMoveTo('calculatedAttribute')) {
+            const attributes = {
+                order: reader.consumeAttribute('order'),
+            };
+            attributes.simpleTypeAttributes = {
+                semanticType: reader.consumeAttribute('semanticType'),
+            };
+            // var semanticType = reader.consumeAttribute("semanticType");
+            const semanticType = attributes.simpleTypeAttributes.semanticType;
+            // For Calculated Attribute in logical model isDerived will always be false
+            attributes.simpleTypeAttributes.isDerived = false;
+            attributes.elementAttributes = reader.buildAttributes({
+                name: '{id}',
+                hidden: '{hidden}',
+                aggregationBehavior: 'none',
+                descriptionColumnName: '{descriptionColumnName}',
+                key: '{key}',
+                displayFolder: '{displayFolder}',
+                attributeHierarchyActive: '{attributeHierarchyActive}',
+                displayAttribute: '{displayAttribute}',
+                replaceNull: '{replaceNull}',
+                replaceNullBy: '{replaceNullBy}',
+            });
+            attributes.elementAttributes.hidden =
+                CalculationViewXmlParserHelper_1.default.getBooleanFromString(attributes.elementAttributes.hidden);
+            attributes.elementAttributes.replaceNull =
+                CalculationViewXmlParserHelper_1.default.getBooleanFromString(attributes.elementAttributes.replaceNull);
+            // Create element instance upfront to be used to set other properties on it, e.g; label
+            // element
+            const columnView = viewNode.$getContainer();
+            const element = this._getDefaultNodeElementInstanceByElementName(columnView, attributes.elementAttributes.name, true);
+            attributes.elementSkippedNodes = reader.skippedNodes;
+            allAttributes.push(attributes);
+            reader.moveDown();
+            // parseDescriptions
+            sharedmodel_1.default.parseDescriptions(reader, attributes.elementAttributes);
+            CalculationViewXmlParserHelper_1.default.createEndUserTextsIfRequired(element, attributes.elementAttributes);
+            this.parseMaskingExpression(reader, element);
+            // parse InternalExternalConversion
+            this.processInternalExternalConversion(reader, element);
+            // Calculated Attribute can have unitCurrencyAttribute
+            if (semanticType !== undefined &&
+                (semanticType === 'amount' || semanticType === 'quantity')) {
+                this.parseUnitCurrencyAttribute(reader, attributes);
+            }
+            /*if (attributes.elementAttributes.descriptionColumnName !== undefined) {
+                this.registerForLoadPostProcessing(reader, {
+                    attribute: attributes.elementAttributes.name,
+                    value: attributes.elementAttributes.descriptionColumnName
+                }, populateLabelElements);
+
+            }*/
+            if (attributes.elementAttributes.descriptionColumnName !== undefined) {
+                // const populateLabelElement = function() {
+                //     element.labelElement = getElementFromColumnView( columnView, attributes.elementAttributes.descriptionColumnName );
+                // };
+                // this.pushToLoadPostProcessingCallBackQueue( reader, populateLabelElement );
+            }
+            this.processTypedObjectExternalTypeOfElement(reader, columnView, element, false);
+            this.processTypedObjectExternalTypeOfElementParameterMapping(reader, element, columnView);
+            // TODO: Old way of storing descriptionColumn
+            // TODO: ExternalLikeElementName
+            if (reader.tryMoveToIntermediate('localVariable')) {
+                const variableName = reader.consumeContent();
+                const parameter = exports.getParameterFromColumnView(columnView, variableName);
+                if (parameter) {
+                    parameter.assignedElements.addValue(element);
+                }
+                reader.next();
+            }
+            // keyCalculation tag will always be there in xml; but it would be good to call
+            // tryMoveToIntermediate()
+            // reader.moveTo("keyCalculation");
+            if (reader.tryMoveToIntermediate('keyCalculation')) {
+                attributes.simpleTypeAttributes = reader.buildAttributes({
+                    primitiveType: '{datatype}',
+                    length: '{length}',
+                    scale: '{scale}',
+                }, attributes.simpleTypeAttributes);
+                attributes.simpleTypeAttributes.length = parseInt(attributes.simpleTypeAttributes.length);
+                attributes.simpleTypeAttributes.scale = parseInt(attributes.simpleTypeAttributes.scale);
+                attributes.elementAttributes.expressionLanguage = reader.getAttribute('expressionLanguage');
+                reader.moveDown();
+                reader.moveToIntermediate('formula');
+                // attributes.elementAttributes.formula = reader.consumeContent();
+                const formula = reader.consumeContent();
+                attributes.elementAttributes.formula = formula || '';
+                reader.skipChildren().next().moveUp().moveUp();
+            }
+            return true;
+        }
+        return false;
+    }
+    static parseMeasure(reader, viewNode, allAttributes) {
+        const mapAggregationType = function (value) {
+            return value;
+            // We will return valaue in small case as defined in enum model.AggregationBehavior; UI
+            // will render it in capital
+            // return value.toUpperCase();
+        };
+        let attributes = null;
+        if (reader.tryMoveTo('measure')) {
+            attributes = {
+                order: reader.consumeAttribute('order'),
+            };
+            // TODO: check semanticType is applicable for measure?
+            const semanticType = reader.consumeAttribute('semanticType');
+            const presentationScale = reader.consumeAttribute('presentationScale');
+            attributes.elementAttributes = reader.buildAttributes({
+                name: '{id}',
+                hidden: '{hidden}',
+                displayFolder: '{displayFolder}',
+                aggregationBehavior: common_1.default.createSelector('aggregationType', mapAggregationType),
+                key: '{key}',
+                engineAggregation: '{engineAggregation}',
+                deprecated: '{deprecated}',
+                replaceNull: '{replaceNull}',
+                replaceNullBy: '{replaceNullBy}',
+                unconverted: '{unconverted}',
+            });
+            /*if(attributes.elementAttributes.displayFolder){
+                throwUnsupportedOperationException("Measure Display Folder");
+            }*/
+            if (attributes.elementAttributes.engineAggregation === undefined) {
+                attributes.elementAttributes.engineAggregation = attributes.elementAttributes.aggregationBehavior;
+            }
+            attributes.elementAttributes.deprecated = common_1.default.parseBool(attributes.elementAttributes.deprecated);
+            attributes.elementAttributes.hidden = CalculationViewXmlParserHelper_1.default.getBooleanFromString(attributes.elementAttributes.hidden);
+            attributes.elementAttributes.replaceNull = CalculationViewXmlParserHelper_1.default.getBooleanFromString(attributes.elementAttributes.replaceNull);
+            attributes.elementAttributes.unconverted = CalculationViewXmlParserHelper_1.default.getBooleanFromString(attributes.elementAttributes.unconverted);
+            // Create element instance upfront to be used to set other properties on it, e.g; label
+            // element
+            const columnView = viewNode.$getContainer();
+            const element = this._getDefaultNodeElementInstanceByElementName(columnView, attributes.elementAttributes.name, true);
+            // - Measure Aggrgation Behaviour Defaulted To sum As Done In Modeler
+            if (!attributes.elementAttributes.hasOwnProperty('aggregationBehavior')) {
+                attributes.elementAttributes.aggregationBehavior = model_1.AggregationBehavior.SUM;
+            }
+            // TODO: Special logic to derive based aggregationBehavior isCalculateBeforeAggregation
+            attributes.simpleTypeAttributes = {};
+            if (semanticType) {
+                attributes.simpleTypeAttributes.semanticType = semanticType;
+            }
+            attributes.simpleTypeAttributes.presentationScale = presentationScale;
+            // For Measure in logical model isDerived will always be true
+            attributes.simpleTypeAttributes.isDerived = true;
+            attributes.elementSkippedNodes = reader.skippedNodes;
+            allAttributes.push(attributes);
+            reader.moveDown();
+            // parseDescriptions
+            sharedmodel_1.default.parseDescriptions(reader, attributes.elementAttributes);
+            CalculationViewXmlParserHelper_1.default.createEndUserTextsIfRequired(element, attributes.elementAttributes);
+            this.parseMaskingExpression(reader, element);
+            this.parseCurrencyAndUnitConversion(reader, attributes, viewNode.$getContainer());
+            // OLD Mapping Code - START
+            /*reader.tryMoveToIntermediate("measureMapping");
+            attributes.mappingAttributes = reader.buildAttributes({
+                type: "ElementMapping",
+                sourceName: "{columnName}",
+                targetName: attributes.elementAttributes.name
+            });
+            attributes.mappingSkippedNodes = reader.skippedNodes;*/
+            // OLD Mapping Code - END
+            // NEW Mapping Code - START
+            if (reader.tryMoveToIntermediate('measureMapping')) {
+                attributes.mappingAttributes = reader.buildAttributes({
+                    type: 'ElementMapping',
+                    sourceName: '{columnName}',
+                    targetName: attributes.elementAttributes.name,
+                });
+                attributes.mappingSkippedNodes = reader.skippedNodes;
+            }
+            else {
+                // note: not process hasNoMapping
+                // attributes.elementAttributes.hasNoMapping = true;
+            }
+            reader.skipChildren().next();
+            // NEW Mapping Code - END
+            this.parseExceptionAggregationMetadata(reader, attributes.elementAttributes.name);
+            reader.moveUp();
+        }
+        return attributes;
+    }
+    static parseCalculatedMeasure(reader, viewNode, allAttributes) {
+        const mapAggregationType = function (value) {
+            return value;
+            // We will return valaue in small case as defined in enum model.AggregationBehavior; UI
+            // will render it in capital
+            // return value.toUpperCase();
+        };
+        let attributes = null;
+        // singleElementAttributes = {};
+        if (reader.tryMoveTo('measure')) {
+            attributes = {
+                order: reader.consumeAttribute('order'),
+            };
+            // TODO: check semanticType is applicable for measure?
+            const semanticType = reader.consumeAttribute('semanticType');
+            // var measureType = reader.consumeAttribute("measureType"); // will be derived from
+            // semantic type
+            const isCounter = reader.consumeAttribute('calculatedMeasureType') === 'counter';
+            attributes.elementAttributes = reader.buildAttributes({
+                name: '{id}',
+                hidden: '{hidden}',
+                displayFolder: '{displayFolder}',
+                aggregationBehavior: common_1.default.createSelector('aggregationType', mapAggregationType),
+                primitiveType: '{datatype}',
+                length: '{length}',
+                scale: '{scale}',
+                presentationScale: '{presentationScale}',
+                key: '{key}',
+                aggregatable: '{aggregatable}',
+                engineAggregation: '{engineAggregation}',
+                expressionLanguage: '{expressionLanguage}',
+                replaceNull: '{replaceNull}',
+                replaceNullBy: '{replaceNullBy}',
+                unconverted: '{unconverted}',
+            });
+            attributes.elementAttributes.aggregatable = CalculationViewXmlParserHelper_1.default.getBooleanFromString(attributes.elementAttributes.aggregatable);
+            attributes.elementAttributes.hidden = CalculationViewXmlParserHelper_1.default.getBooleanFromString(attributes.elementAttributes.hidden);
+            attributes.elementAttributes.replaceNull = CalculationViewXmlParserHelper_1.default.getBooleanFromString(attributes.elementAttributes.replaceNull);
+            attributes.elementAttributes.unconverted = CalculationViewXmlParserHelper_1.default.getBooleanFromString(attributes.elementAttributes.unconverted);
+            // Extra logic to conver CalculatedMeasure's aggregationBehavior from sum or count to
+            // Formula
+            if (attributes.elementAttributes.aggregationBehavior) {
+                if (!attributes.elementAttributes.aggregatable) {
+                    attributes.elementAttributes.aggregationBehavior = 'formula';
+                }
+            }
+            if (attributes.elementAttributes.engineAggregation === undefined) {
+                attributes.elementAttributes.engineAggregation =
+                    attributes.elementAttributes.aggregationBehavior;
+            }
+            // Create element instance upfront to be used to set other properties on it, e.g; label
+            // element
+            const columnView = viewNode.$getContainer();
+            const element = this._getDefaultNodeElementInstanceByElementName(columnView, attributes.elementAttributes.name, true);
+            attributes.simpleTypeAttributes = {};
+            CalculationViewXmlParserHelper_1.default.populateSimpleTypeAttributesFromElementAttributes(attributes.elementAttributes, attributes.simpleTypeAttributes);
+            // For Calculated Measure in logical model isDerived will always be false
+            attributes.simpleTypeAttributes.isDerived = false;
+            // TODO: Also consider isCalculateBeforeAggregation while deriving aggregationBehavior
+            // to make code more generic
+            if (semanticType) {
+                attributes.simpleTypeAttributes.semanticType = semanticType;
+            }
+            attributes.elementSkippedNodes = reader.skippedNodes;
+            allAttributes.push(attributes);
+            reader.moveDown();
+            // parseDescriptions
+            sharedmodel_1.default.parseDescriptions(reader, attributes.elementAttributes);
+            CalculationViewXmlParserHelper_1.default.createEndUserTextsIfRequired(element, attributes.elementAttributes);
+            this.parseMaskingExpression(reader, element);
+            this.parseCurrencyAndUnitConversion(reader, attributes, viewNode.$getContainer());
+            if (!isCounter && attributes.elementAttributes.aggregationBehavior !== 'none') {
+                attributes.elementAttributes.measureType = model_1.MeasureType.CALCULATED_MEASURE;
+            }
+            if (isCounter) {
+                attributes.elementAttributes.measureType = model_1.MeasureType.COUNTER;
+                const counterData = {};
+                counterData.name = attributes.elementAttributes.name;
+                counterData.attributes = [];
+                if (reader.tryMoveToIntermediate('exceptionAggregation')) {
+                    if (reader.tryMoveDown()) {
+                        while (reader.tryMoveTo('attribute')) {
+                            counterData.attributes.push({
+                                attributeName: reader.getAttribute('attributeName'),
+                                dimensionUri: reader.getAttribute('dimensionUri'),
+                                skippedNodes: reader.skippedNodes,
+                            });
+                            reader.next();
+                        }
+                        reader.moveUp();
+                    }
+                }
+                // this.registerForLoadPostProcessing( reader, counterData, function( columnView, data ) {
+                //     const attributes = data.attributes;
+                //     const counterElement = getElementFromColumnView( columnView, data.name );
+                //     if ( counterElement ) {
+                //         const exceptionAggregationStep = counterElement.createExceptionAggregationStep();
+                //         let element = null;
+                //         let fqName = null,
+                //             sharedEntity = null,
+                //             entity = null,
+                //             key = null;
+                //         for ( let i = 0; i < attributes.length; i++ ) {
+                //             let isStarJoin = false;
+                //             if ( attributes[i].dimensionUri ) {
+                //                 fqName = attributes[i].dimensionUri;
+                //                 sharedEntity = getEntity( columnView, fqName );
+                //                 element = getElementFromsharedEntity( sharedEntity, attributes[i].attributeName );
+                //                 isStarJoin = true;
+                //             } else {
+                //                 element = getElementFromColumnView( columnView, attributes[i].attributeName );
+                //             }
+                //             exceptionAggregationStep.skippedNodes = attributes[i].skippedNodes;
+                //             if ( element && isStarJoin ) {
+                //                 // exceptionAggregationStep.referenceElements.add(element);
+                //                 entity = element.$getContainer();
+                //                 fqName = entity.getFullyQualifiedName();
+                //                 key = fqName + '.' + element.name;
+                //                 exceptionAggregationStep.referenceElements.add( key, element );
+                //             } else {
+                //                 exceptionAggregationStep.referenceElements.add( element );
+                //             }
+                //         }
+                //     }
+                // });
+                reader.next();
+            }
+            if (reader.tryMoveToIntermediate('formula')) {
+                const formula = reader.consumeContent();
+                attributes.elementAttributes.formula = formula || (isCounter ? '1' : '');
+            }
+            reader.skipChildren().next();
+            this.parseExceptionAggregationMetadata(reader, attributes.elementAttributes.name);
+            reader.moveUp();
+        }
+        return attributes;
+    }
+    static parseRestrictedMeasure(reader, viewNode, allAttributes) {
+        const mapAggregationType = function (value) {
+            return value;
+        };
+        let attributes = null;
+        if (reader.tryMoveTo('measure')) {
+            attributes = {
+                order: reader.consumeAttribute('order'),
+            };
+            attributes.elementAttributes = reader.buildAttributes({
+                name: '{id}',
+                hidden: '{hidden}',
+                baseMeasure: '{baseMeasure}',
+                displayFolder: '{displayFolder}',
+                expressionLanguage: '{restrictionExpressionLanguage}',
+                aggregationBehavior: common_1.default.createSelector('aggregationType', mapAggregationType),
+                replaceNull: '{replaceNull}',
+                replaceNullBy: '{replaceNullBy}',
+            });
+            attributes.elementAttributes.hidden = CalculationViewXmlParserHelper_1.default.getBooleanFromString(attributes.elementAttributes.hidden);
+            attributes.elementAttributes.replaceNull = CalculationViewXmlParserHelper_1.default.getBooleanFromString(attributes.elementAttributes.replaceNull);
+            // Create element instance upfront to be used to set other properties on it, e.g; label
+            // element
+            const columnView = viewNode.$getContainer();
+            const element = this._getDefaultNodeElementInstanceByElementName(columnView, attributes.elementAttributes.name, true);
+            attributes.elementAttributes.measureType = model_1.MeasureType.RESTRICTION;
+            attributes.simpleTypeAttributes = {};
+            // For Restricted Measure in logical model isDerived will always be true since
+            // Restricted Measure derives datatype from its base measure
+            attributes.simpleTypeAttributes.isDerived = true;
+            attributes.elementSkippedNodes = reader.skippedNodes;
+            allAttributes.push(attributes);
+            reader.moveDown();
+            // parseDescriptions
+            sharedmodel_1.default.parseDescriptions(reader, attributes.elementAttributes);
+            CalculationViewXmlParserHelper_1.default.createEndUserTextsIfRequired(element, attributes.elementAttributes);
+            this.parseMaskingExpression(reader, element);
+            this.parseCurrencyAndUnitConversion(reader, attributes, viewNode.$getContainer());
+            const restrictedMeasureData = {};
+            restrictedMeasureData.name = attributes.elementAttributes.name;
+            restrictedMeasureData.restrictions = [];
+            restrictedMeasureData.expressionLanguage = attributes.elementAttributes.expressionLanguage;
+            while (reader.tryMoveTo('restriction')) {
+                const restrictions = [];
+                if (reader.tryMoveDown()) {
+                    while (reader.tryMoveTo('filter')) {
+                        // var restriction = {};
+                        const restriction = {};
+                        const parsingMapper = function (value) {
+                            return reader.removePrefix(sharedmodel_1.default.NameSpace.PRIVILEGE, value);
+                        };
+                        const filterAttributes = reader.buildAttributes({
+                            type: common_1.default.createXsiSelector('type', parsingMapper),
+                            attributeName: '{attributeName}',
+                        });
+                        if (filterAttributes && filterAttributes.attributeName) {
+                            restriction.elementName = filterAttributes.attributeName;
+                        }
+                        if (reader.tryMoveDown()) {
+                            restriction.valueFilters = [];
+                            while (reader.tryMoveTo('valueFilter')) {
+                                const valueFilter = sharedmodel_1.default.parseValueFilter(reader);
+                                restriction.valueFilters.push(valueFilter);
+                                reader.next();
+                            }
+                            reader.moveUp();
+                        }
+                        reader.next();
+                        restrictions.push(restriction);
+                    }
+                    // if (reader.tryMoveTo("attributeName")) {
+                    // restriction.elementName = reader.consumeContent();
+                    // var elementName = reader.consumeContent();
+                    // }
+                    if (reader.tryMoveTo('dimensionUri')) {
+                        const dimensionUri = reader.consumeContent();
+                        // restriction.elementName = filterAttributes.attributeName;
+                        for (let index = 0; index < restrictions.length; index++) {
+                            const restrictionLocal = restrictions[index];
+                            restrictionLocal.dimensionUri = dimensionUri;
+                        }
+                    }
+                    reader.moveUp();
+                }
+                // restrictedMeasureData.restrictions.push(restriction);
+                for (let index = 0; index < restrictions.length; index++) {
+                    const restrictionLocal = restrictions[index];
+                    restrictedMeasureData.restrictions.push(restrictionLocal);
+                }
+                reader.next();
+            }
+            if (attributes.elementAttributes.baseMeasure) {
+                restrictedMeasureData.baseMeasure = attributes.elementAttributes.baseMeasure;
+            }
+            if (reader.tryMoveToIntermediate('restrictionExpression')) {
+                restrictedMeasureData.restrictionExpression = reader.getContent();
+            }
+            this.parseExceptionAggregationMetadata(reader, attributes.elementAttributes.name);
+            reader.moveUp();
+            this.registerForLoadPostProcessing(reader, restrictedMeasureData, function (columnView, data) {
+                const restrictions = data.restrictions;
+                const restrictedMeasureElement = exports.getElementFromColumnView(columnView, data.name);
+                if (restrictedMeasureElement) {
+                    for (let i = 0; i < restrictions.length; i++) {
+                        let element = null;
+                        if (restrictions[i].dimensionUri === undefined) {
+                            element = exports.getElementFromColumnView(columnView, restrictions[i].elementName);
+                        }
+                        else {
+                            const fqName = restrictions[i].dimensionUri;
+                            // element = getElementFromEntity(columnView, fqName,
+                            // restrictions[i].elementName,
+                            // RepositoryXmlParserHelper.mapRepositoryTypeToEntityType(fqName.getSuffix()));
+                            const sharedEntity = exports.getEntity(columnView, fqName);
+                            element = exports.getElementFromsharedEntity(sharedEntity, restrictions[i].elementName);
+                        }
+                        if (restrictedMeasureElement && element) {
+                            const restriction = restrictedMeasureElement.createRestriction({
+                                type: 'AttributeFilter',
+                            }, restrictions[i].skippedNodes);
+                            const attributes = {};
+                            attributes.formula = restrictions[i].elementName;
+                            restrictedMeasureElement.createCalculationDefinition(attributes);
+                            restriction.element = element;
+                            for (let j = 0; j < restrictions[i].valueFilters.length; j++) {
+                                restriction.valueFilters.addValue(restrictions[i].valueFilters[j]);
+                            }
+                        }
+                    }
+                    restrictedMeasureElement.createCalculationDefinition({}).formula = data.baseMeasure;
+                    // restrictedMeasureElement.typeOfElement = getElementFromColumnView( columnView, data.baseMeasure );
+                    if (data.restrictionExpression) {
+                        restrictedMeasureElement.createRestrictionExpression({
+                            formula: data.restrictionExpression,
+                            expressionLanguage: data.expressionLanguage,
+                        });
+                    }
+                }
+            });
+        }
+        return attributes;
+    }
+    static parseExceptionAggregationMetadata(reader, elementName) {
+        if (reader.tryMoveToIntermediate('exceptionAggregationMetadata')) {
+            // note: do nothing
+            reader.next();
+        }
+    }
+    static doLoadPostProcessing(reader, columnView) {
+        for (let i = 0; i < reader.context.postProcessingRegistry.callback.length; i++) {
+            reader.context.postProcessingRegistry.callback[i].method(columnView, reader.context.postProcessingRegistry.callback[i].data);
+        }
+        return columnView;
+    }
+    static registerForLoadPostProcessing(reader, callbackData, callbackMethod) {
+        const callback = {};
+        callback.method = callbackMethod;
+        callback.data = callbackData;
+        reader.context.postProcessingRegistry.callback.push(callback);
+    }
+    static excecuteLoadPostProcessingCallBackQueue(reader, columnView) {
+        for (let i = 0; i < reader.context.loadPostProcessingCallBackQueue.callback.length; i++) {
+            reader.context.loadPostProcessingCallBackQueue.callback[i].method(columnView);
+        }
+    }
+}
+exports.default = CalculationViewXmlParser;
+const getSourceForInput = (id, dataSources, viewNode) => {
+    const columnView = viewNode.$getContainer();
+    const dataSource = dataSources[id];
+    if (dataSource !== undefined) {
+        const attributes = {
+            id: dataSource.resourceUri || dataSource.id,
+            isProxy: true,
+        };
+        let entity = viewNode.$getModel()._entities.get(attributes.id);
+        if (entity !== null && entity !== undefined) {
+            return entity;
+        }
+        else {
+            entity = viewNode.$getModel().createEntity(attributes);
+        }
+        // var entity = viewNode.$getModel().createEntity(attributes);
+        // Code to avoid creation of duplicate entitiy for same FQName - End
+        // var entity = viewNode.$getModel().createEntity(attributes, dataSource.skippedNodes);
+        return entity;
+    }
+    else {
+        return columnView.viewNodes.get(id);
+    }
+};
+const getElementFromColumnView = (columnView, name) => {
+    let foundElement = null;
+    if (columnView && name) {
+        if (columnView.getDefaultNode() !== null &&
+            columnView.getDefaultNode() !== undefined) {
+            foundElement = columnView.getDefaultNode().elements.get(name);
+            if (foundElement !== null && foundElement !== undefined) {
+                return foundElement;
+            }
+        }
+    }
+    return null;
+};
+exports.getElementFromColumnView = getElementFromColumnView;
+const getEntity = (columnView, id, entityType) => {
+    const viewModel = columnView.$getContainer();
+    const entity = viewModel._entities.get(id);
+    if (entity !== null && entity !== undefined) {
+        return entity;
+    }
+    else {
+        const entityAttributes = {
+            isProxy: true,
+            name: id,
+            id: id,
+            type: entityType,
+        };
+        return viewModel.createEntity(entityAttributes);
+    }
+};
+exports.getEntity = getEntity;
+const createSharedElementNameInAgreedFormat = (entity, elementName) => {
+    /*var fqName = entity.getFullyQualifiedName();
+    var sharedElementName = fqName + "." + elementName;
+    return sharedElementName;*/
+    return elementName;
+};
+const getElementFromsharedEntity = (entity, elementName) => {
+    const sharedElementName = createSharedElementNameInAgreedFormat(entity, elementName);
+    const element = entity.elements.get(sharedElementName);
+    if (element) {
+        return element;
+    }
+    else {
+        return entity.createElement({
+            name: sharedElementName,
+            isProxy: true,
+        });
+    }
+};
+exports.getElementFromsharedEntity = getElementFromsharedEntity;
+const getParameterFromColumnView = (columnView, name) => {
+    if (columnView.parameters !== null && columnView.parameters !== undefined) {
+        const foundParameter = columnView.parameters.get(name);
+        if (foundParameter !== null && foundParameter !== undefined) {
+            return foundParameter;
+        }
+    }
+    return null;
+};
+exports.getParameterFromColumnView = getParameterFromColumnView;
+const addElementToEntityIfNotPresent = (entity, elementName) => {
+    if (entity !== null && entity !== undefined) {
+        const element = entity.elements.get(elementName);
+        if (element !== null && element !== undefined) {
+            return element;
+        }
+        else {
+            return entity.createElement({
+                name: elementName,
+                isProxy: true,
+            });
+        }
+    }
+};
+const processUDFParameter = (columnView, udfParameter, values) => {
+    if (udfParameter && values) {
+        if (values.parameter) {
+            udfParameter.parameter = exports.getParameterFromColumnView(columnView, values.parameter);
+        }
+        if (values.constantValue) {
+            udfParameter.constantValue = values.constantValue;
+        }
+        udfParameter.skippedNodes = values.skippedNodes;
+    }
+    return udfParameter;
+};
+exports.processUDFParameter = processUDFParameter;
+const getDataSource = (id, dataSources, columnView) => {
+    const dataSource = dataSources[id];
+    return dataSource;
+};
+//# sourceMappingURL=CalculationViewXmlParser.js.map