Examples with OutputTreeNode org.talend.designer.xmlmap.model.emf.xmlmap.OutputTreeNode used on opensource projects

Example 31 with OutputTreeNode

use of org.talend.designer.xmlmap.model.emf.xmlmap.OutputTreeNode in project tdi-studio-se by Talend.

the class SetGroupAction method calculateEnabled.

@Override
protected boolean calculateEnabled() {
    subGroupTraceNames.clear();
    if (getSelectedObjects().isEmpty()) {
        return false;
    }
    Object s = getSelectedObjects().get(0);
    if (s instanceof List && !((List) s).isEmpty()) {
        List selectedarts = (List) s;
        Object obj = selectedarts.get(selectedarts.size() - 1);
        if (obj instanceof OutputTreeNodeEditPart) {
            nodePart = (OutputTreeNodeEditPart) obj;
            OutputTreeNode model = (OutputTreeNode) nodePart.getModel();
            if (model.eContainer() instanceof TreeNode && XmlMapUtil.DOCUMENT.equals(((TreeNode) model.eContainer()).getType())) {
                return false;
            }
            if (NodeType.ATTRIBUT.equals(model.getNodeType()) || NodeType.NAME_SPACE.equals(model.getNodeType()) || !(model.eContainer() instanceof TreeNode) || model.isChoice() || model.isSubstitution()) {
                //$NON-NLS-N$
                return false;
            }
            // fixed for TDI-20808 ,disable group and aggregate for 501
            AbstractInOutTree abstractTree = XmlMapUtil.getAbstractInOutTree(model);
            if (abstractTree instanceof OutputXmlTree) {
                OutputXmlTree outputTree = ((OutputXmlTree) abstractTree);
                if (outputTree.isMultiLoops()) {
                    return false;
                }
            }
            OutputTreeNode findDownLoopNode = findDownLoopNode(model);
            if (findDownLoopNode == null) {
                return false;
            }
            if (!model.isGroup()) {
                setText("As group element");
                isRemove = false;
            } else {
                setText("Remove group element");
                isRemove = true;
            }
            if (isRemove) {
                if (model.isGroup()) {
                    return true;
                } else {
                    return false;
                }
            }
        } else {
            return false;
        }
    }
    return true;
}

Example 32 with OutputTreeNode

use of org.talend.designer.xmlmap.model.emf.xmlmap.OutputTreeNode in project tdi-studio-se by Talend.

the class DirectEditCommand method execute.

@Override
public void execute() {
    try {
        if (model != null) {
            if (DirectEditType.EXPRESSION.equals(type)) {
                List<TableEntryLocation> matchedLocations = expressionManager.parseTableEntryLocation((String) newValue);
                EList<? extends INodeConnection> connections = null;
                if (model instanceof OutputTreeNode || model instanceof VarNode) {
                    connections = model.getIncomingConnections();
                } else if (model instanceof TreeNode) {
                    connections = ((TreeNode) model).getLookupIncomingConnections();
                }
                List usefullConnections = new ArrayList();
                mapperData = XmlMapUtil.getXmlMapData(model);
                if (!matchedLocations.isEmpty()) {
                    for (int i = 0; i < matchedLocations.size(); i++) {
                        TableEntryLocation currentLocation = matchedLocations.get(i);
                        boolean found = false;
                        for (INodeConnection conn : connections) {
                            TableEntryLocation sourceLocation = null;
                            if (conn.getSource() instanceof TreeNode) {
                                sourceLocation = expressionManager.parseTableEntryLocation(XmlMapUtil.convertToExpression(((TreeNode) conn.getSource()).getXpath())).get(0);
                            } else if (conn.getSource() instanceof VarNode) {
                                VarNode varNode = (VarNode) conn.getSource();
                                sourceLocation = new TableEntryLocation(((VarTable) varNode.eContainer()).getName(), varNode.getName());
                            }
                            if (currentLocation.equals(sourceLocation)) {
                                found = true;
                                usefullConnections.add(conn);
                                break;
                            }
                        }
                        if (!found) {
                            if (mapperData != null) {
                                String convertToXpath = XmlMapUtil.convertToXpath(currentLocation.toString());
                                boolean findFromVar = false;
                                if (model instanceof OutputTreeNode) {
                                    findFromVar = true;
                                }
                                AbstractNode sourceNode = findConnectionSource(mapperData, currentLocation, XmlMapUtil.getXPathLength(convertToXpath), findFromVar);
                                if (sourceNode != null) {
                                    INodeConnection connection = null;
                                    if (model instanceof OutputTreeNode || model instanceof VarNode) {
                                        connection = XmlmapFactory.eINSTANCE.createConnection();
                                        sourceNode.getOutgoingConnections().add((Connection) connection);
                                        model.getIncomingConnections().add((Connection) connection);
                                    } else if (model instanceof TreeNode && sourceNode instanceof TreeNode) {
                                        TreeNode source = (TreeNode) sourceNode;
                                        connection = XmlmapFactory.eINSTANCE.createLookupConnection();
                                        source.getLookupOutgoingConnections().add((LookupConnection) connection);
                                        ((TreeNode) model).getLookupIncomingConnections().add((LookupConnection) connection);
                                    }
                                    //
                                    // if (model instanceof OutputTreeNode && sourceNode instanceof TreeNode) {
                                    // createInputLoopTable((TreeNode) sourceNode, (OutputTreeNode) model);
                                    // }
                                    connection.setSource(sourceNode);
                                    connection.setTarget(model);
                                    mapperData.getConnections().add(connection);
                                    usefullConnections.add(connection);
                                }
                            }
                        }
                    }
                } else {
                    if (!connections.isEmpty()) {
                        if (model instanceof OutputTreeNode || model instanceof VarNode) {
                            XmlMapUtil.detachConnectionsSouce(model, mapperData, false);
                            model.getIncomingConnections().clear();
                        } else if (model instanceof TreeNode) {
                            XmlMapUtil.detachLookupSource((TreeNode) model, mapperData);
                            ((TreeNode) model).getLookupIncomingConnections().clear();
                        }
                    }
                }
                List<INodeConnection> copyOfConnections = new ArrayList<INodeConnection>(connections);
                copyOfConnections.removeAll(usefullConnections);
                if (model instanceof OutputTreeNode || model instanceof VarNode) {
                    for (INodeConnection connection : copyOfConnections) {
                        if (connection.getSource() != null) {
                            if (connection.getSource().getOutgoingConnections().contains(connection)) {
                                connection.getSource().getOutgoingConnections().remove(connection);
                                mapperData.getConnections().remove(connection);
                            }
                        }
                    }
                    model.getIncomingConnections().removeAll(copyOfConnections);
                } else if (model instanceof TreeNode) {
                    for (INodeConnection connection : copyOfConnections) {
                        if (connection.getSource() != null) {
                            if (((TreeNode) connection.getSource()).getLookupOutgoingConnections().contains(connection)) {
                                ((TreeNode) connection.getSource()).getLookupOutgoingConnections().remove(connection);
                                mapperData.getConnections().remove(connection);
                            }
                        }
                    }
                    ((TreeNode) model).getLookupIncomingConnections().removeAll(copyOfConnections);
                }
                if (model instanceof OutputTreeNode) {
                    OutputTreeNode outModel = (OutputTreeNode) model;
                    if (NodeType.NAME_SPACE.equals(outModel.getNodeType()) && outModel.getExpression() != null && !"".equals(model.getExpression())) {
                        outModel.setDefaultValue("");
                    }
                }
                model.setExpression((String) newValue);
            } else if (DirectEditType.VAR_NODE_TYPE.equals(type)) {
                VarNode varModel = (VarNode) model;
                JavaType javaTypeFromLabel = JavaTypesManager.getJavaTypeFromLabel((String) newValue);
                if (javaTypeFromLabel == null) {
                    javaTypeFromLabel = JavaTypesManager.getDefaultJavaType();
                }
                varModel.setType(javaTypeFromLabel.getId());
            } else if (DirectEditType.NODE_NAME.equals(type)) {
                if (model instanceof VarNode) {
                    List<VarNode> children = new ArrayList<VarNode>();
                    children.addAll(((VarTable) model.eContainer()).getNodes());
                    children.remove(model);
                    String message = XmlMapUtil.isValidColumnName(children, (String) newValue);
                    if (message != null) {
                        MessageDialog.openError(null, "Error", message);
                        return;
                    }
                    String oldName = model.getName();
                    String oldExpression = XmlMapUtil.VAR_TABLE_NAME + XmlMapUtil.EXPRESSION_SEPARATOR + oldName;
                    model.setName((String) newValue);
                    String newExpression = XmlMapUtil.VAR_TABLE_NAME + XmlMapUtil.EXPRESSION_SEPARATOR + model.getName();
                    XmlMapUtil.updateTargetExpression(model, oldExpression, newExpression, expressionManager);
                } else if (model instanceof GlobalMapNode) {
                    model.setName((String) newValue);
                }
            }
        }
    } catch (PatternSyntaxException ex) {
    // Syntax error in the regular expression
    }
}

Example 33 with OutputTreeNode

use of org.talend.designer.xmlmap.model.emf.xmlmap.OutputTreeNode in project tdi-studio-se by Talend.

the class InsertNewColumnCommand method execute.

@Override
public void execute() {
    if (rq == null || objects.getToTransfer() == null || targetEditPart == null || dropType == null) {
        return;
    }
    Object targetModel = targetEditPart.getModel();
    for (Object obj : objects.getToTransfer()) {
        AbstractNode createdNode = rq.getNewObject();
        // INPUT => OUTPUT INSERT
        if (objects.getType() == TransferdType.INPUT) {
            TreeNodeEditPart part = (TreeNodeEditPart) obj;
            TreeNode sourceNode = (TreeNode) part.getModel();
            String expression = XmlMapUtil.convertToExpression(sourceNode.getXpath());
            switch(dropType) {
                case DROP_INSERT_OUTPUT:
                    int index = -1;
                    OutputXmlTree outputTree = null;
                    if (targetModel instanceof OutputTreeNode) {
                        OutputTreeNode targetNode = (OutputTreeNode) targetModel;
                        if (targetNode.eContainer() instanceof OutputXmlTree) {
                            outputTree = (OutputXmlTree) targetNode.eContainer();
                            index = outputTree.getNodes().indexOf(targetNode);
                        }
                    } else if (targetModel instanceof OutputXmlTree) {
                        outputTree = (OutputXmlTree) targetModel;
                    }
                    if (outputTree != null) {
                        boolean fillNode = fillTreeNode(outputTree.getNodes(), sourceNode, outputTree.getName(), expression, (OutputTreeNode) createdNode);
                        if (!fillNode) {
                            return;
                        }
                        if (index != -1) {
                            outputTree.getNodes().add(index, (OutputTreeNode) createdNode);
                        } else {
                            outputTree.getNodes().add((OutputTreeNode) createdNode);
                        }
                        createConnection(sourceNode, createdNode);
                        AbstractInOutTree abstractTree = XmlMapUtil.getAbstractInOutTree(sourceNode);
                        createOutputMetadataColumn(abstractTree.getName(), outputTree.getName(), sourceNode, createdNode.getName(), index);
                    }
                    break;
                case DROP_INSERT_VAR:
                    VarNode targetVar = (VarNode) targetModel;
                    VarNode varNode = (VarNode) createdNode;
                    if (targetVar.eContainer() instanceof VarTable) {
                        VarTable varTable = (VarTable) targetVar.eContainer();
                        String validSourceName = validSourceNodeName(varTable.getNodes(), sourceNode);
                        String name = getUniqueTableEntry(varTable.getNodes(), validSourceName);
                        varNode.setName(name);
                        varNode.setType(sourceNode.getType());
                        varNode.setExpression(expression);
                        varTable.getNodes().add(varTable.getNodes().indexOf(targetVar), varNode);
                        createConnection(sourceNode, createdNode);
                    }
                    break;
                case DROP_INSERT_INPUT:
                    if (targetModel instanceof InputXmlTree) {
                        InputXmlTree inputTree = (InputXmlTree) targetModel;
                        boolean fillNode = fillTreeNode(inputTree.getNodes(), sourceNode, inputTree.getName(), expression, (TreeNode) createdNode);
                        if (!fillNode) {
                            return;
                        }
                        inputTree.getNodes().add((TreeNode) createdNode);
                        createLookupConnection(sourceNode, (TreeNode) createdNode);
                        AbstractInOutTree abstractTree = XmlMapUtil.getAbstractInOutTree(sourceNode);
                        createInputMetadataColumn(abstractTree.getName(), inputTree.getName(), sourceNode, createdNode.getName(), -1);
                    }
                default:
                    break;
            }
        } else // VAR => OUTPUT INSERT
        if (objects.getType() == TransferdType.VAR) {
            VarNodeEditPart part = (VarNodeEditPart) obj;
            VarNode sourceNode = (VarNode) part.getModel();
            //$NON-NLS-1$
            String tableName = "Var";
            if (sourceNode.eContainer() instanceof VarTable) {
                tableName = ((VarTable) sourceNode.eContainer()).getName();
            }
            //$NON-NLS-1$
            String expression = tableName + "." + sourceNode.getName();
            if (dropType == DropType.DROP_INSERT_OUTPUT) {
                int index = -1;
                OutputXmlTree outputTree = null;
                if (targetModel instanceof OutputTreeNode) {
                    OutputTreeNode targetNode = (OutputTreeNode) targetModel;
                    if (targetNode.eContainer() instanceof OutputXmlTree) {
                        outputTree = (OutputXmlTree) targetNode.eContainer();
                        index = outputTree.getNodes().indexOf(targetNode);
                    }
                } else if (targetModel instanceof OutputXmlTree) {
                    outputTree = (OutputXmlTree) targetModel;
                }
                if (outputTree != null) {
                    OutputTreeNode outputNode = (OutputTreeNode) createdNode;
                    String name = getUniqueTableEntry(outputTree.getNodes(), sourceNode.getName());
                    outputNode.setName(name);
                    outputNode.setType(sourceNode.getType());
                    outputNode.setExpression(expression);
                    outputNode.setXpath(XmlMapUtil.getXPath(outputTree.getName(), outputNode.getName(), outputNode.getNodeType()));
                    if (index != -1) {
                        outputTree.getNodes().add(index, (OutputTreeNode) createdNode);
                    } else {
                        outputTree.getNodes().add((OutputTreeNode) createdNode);
                    }
                    createConnection(sourceNode, createdNode);
                    createOutputMetadataColumn(null, outputTree.getName(), sourceNode, createdNode.getName(), index);
                // List<IMetadataTable> metadataTargets = manager.getMapperComponent().getMetadataList();
                // IMetadataTable metadataTarget = null;
                // if (metadataTargets != null) {
                // for (IMetadataTable target : metadataTargets) {
                // if (target.getTableName().equals(outputTree.getName())) {
                // metadataTarget = target;
                // }
                // }
                // if (metadataTarget != null) {
                // IMetadataColumn createNewColumn = new MetadataColumn();
                // createNewColumn.setLabel(outputNode.getName());
                // createNewColumn.setTalendType(outputNode.getType());
                // createNewColumn.setNullable(true);
                // metadataTarget.getListColumns().add(createNewColumn);
                // }
                // }
                }
            }
        }
    }
    switch(dropType) {
        case DROP_INSERT_OUTPUT:
            manager.getMapperUI().getTabFolderEditors().getOutputMetaEditorView().getTableViewerCreator().refresh();
        case DROP_INSERT_INPUT:
            manager.getMapperUI().getTabFolderEditors().getOutputMetaEditorView().getTableViewerCreator().refresh();
    }
}

Example 34 with OutputTreeNode

use of org.talend.designer.xmlmap.model.emf.xmlmap.OutputTreeNode in project tdi-studio-se by Talend.

the class XmlMapService method checkXMLMapDifferents.

/*
     * (non-Javadoc)
     * 
     * @see org.talend.core.service.IXmlMapService#checkXMLMapDifferents(org.talend.core.model.process.INode,
     * org.talend.core.model.process.INode)
     */
@Override
public boolean checkXMLMapDifferents(INode testNode, INode originalNode) {
    AbstractExternalData oriExternalData = originalNode.getExternalNode().getExternalEmfData();
    AbstractExternalData testExternalData = testNode.getExternalNode().getExternalEmfData();
    if (oriExternalData == null && testExternalData == null) {
        return false;
    }
    if (oriExternalData == null || testExternalData == null) {
        return true;
    }
    if (!(oriExternalData instanceof XmlMapData) || !(testExternalData instanceof XmlMapData)) {
        return false;
    }
    Map<String, String> inputConnNameMap = getInputConnectionNameMap(testNode);
    XmlMapData oriXmlData = (XmlMapData) oriExternalData;
    XmlMapData testXmlData = (XmlMapData) testExternalData;
    EList<InputXmlTree> oriInputs = oriXmlData.getInputTrees();
    EList<OutputXmlTree> oriOutputs = oriXmlData.getOutputTrees();
    EList<VarTable> oriVars = oriXmlData.getVarTables();
    EList<InputXmlTree> testInputs = testXmlData.getInputTrees();
    EList<OutputXmlTree> testOutputs = testXmlData.getOutputTrees();
    EList<VarTable> testVars = testXmlData.getVarTables();
    if (oriInputs.size() != testInputs.size()) {
        return true;
    }
    if (oriOutputs.size() != testOutputs.size()) {
        return true;
    }
    if (oriVars.size() != testVars.size()) {
        return true;
    }
    for (InputXmlTree oriInput : oriInputs) {
        String oriName = oriInput.getName();
        InputXmlTree testInput = null;
        for (InputXmlTree input : testInputs) {
            if (input.getName().equals(oriName)) {
                testInput = input;
                break;
            }
        }
        if (testInput == null) {
            testInput = getInputXmlTree(testNode, testInputs, oriName);
        }
        if (testInput == null) {
            return true;
        }
        if (oriInput.isActivateExpressionFilter() != testInput.isActivateExpressionFilter()) {
            return true;
        }
        if (oriInput.getExpressionFilter() != testInput.getExpressionFilter()) {
            return true;
        }
        if (oriInput.isMinimized() != testInput.isMinimized()) {
            return true;
        }
        if (oriInput.isActivateCondensedTool() != testInput.isActivateCondensedTool()) {
            return true;
        }
        EList<TreeNode> oriEntrys = oriInput.getNodes();
        EList<TreeNode> testEntrys = testInput.getNodes();
        if (oriEntrys.size() != testEntrys.size()) {
            return true;
        }
        for (TreeNode oriEntry : oriEntrys) {
            String oriEntryName = oriEntry.getName();
            boolean found = false;
            for (TreeNode testEntry : testEntrys) {
                if (oriEntryName.equals(testEntry.getName())) {
                    found = true;
                    if (checkExpression(oriEntry.getExpression(), testEntry.getExpression(), inputConnNameMap)) {
                        return true;
                    }
                    break;
                }
            }
            if (!found) {
                return true;
            }
        }
    }
    for (OutputXmlTree oriOutput : oriOutputs) {
        String oriName = oriOutput.getName();
        OutputXmlTree testOutput = null;
        for (OutputXmlTree output : testOutputs) {
            if (output.getName().equals(oriName)) {
                testOutput = output;
                break;
            }
        }
        if (testOutput == null) {
            testOutput = getOutputXmlTree(testNode, testOutputs, oriName);
        }
        if (testOutput == null) {
            return true;
        }
        if (oriOutput.isActivateExpressionFilter() != testOutput.isActivateExpressionFilter()) {
            return true;
        }
        if (oriOutput.getExpressionFilter() != testOutput.getExpressionFilter()) {
            return true;
        }
        if (oriOutput.isMinimized() != testOutput.isMinimized()) {
            return true;
        }
        if (oriOutput.isActivateCondensedTool() != testOutput.isActivateCondensedTool()) {
            return true;
        }
        EList<OutputTreeNode> oriEntrys = oriOutput.getNodes();
        EList<OutputTreeNode> testEntrys = testOutput.getNodes();
        if (oriEntrys.size() != testEntrys.size()) {
            return true;
        }
        for (OutputTreeNode oriEntry : oriEntrys) {
            String oriEntryName = oriEntry.getName();
            boolean found = false;
            for (OutputTreeNode testEntry : testEntrys) {
                if (oriEntryName.equals(testEntry.getName())) {
                    found = true;
                    if (found) {
                        if (checkChildOutputTreeNode(oriEntry, testEntry, inputConnNameMap)) {
                            return true;
                        }
                    }
                    break;
                }
            }
            if (!found) {
                return true;
            }
        }
    }
    for (VarTable oriVar : oriVars) {
        String oriName = oriVar.getName();
        VarTable testVar = null;
        for (VarTable var : testVars) {
            if (var.getName().equals(oriName)) {
                testVar = var;
                break;
            }
        }
        if (testVar == null) {
            return true;
        }
        if (oriVar.isMinimized() != testVar.isMinimized()) {
            return true;
        }
        EList<VarNode> oriEntrys = oriVar.getNodes();
        EList<VarNode> testEntrys = testVar.getNodes();
        if (oriEntrys.size() != testEntrys.size()) {
            return true;
        }
        for (VarNode oriEntry : oriEntrys) {
            String oriEntryName = oriEntry.getName();
            boolean found = false;
            for (VarNode testEntry : testEntrys) {
                if (oriEntryName.equals(testEntry.getName())) {
                    found = true;
                    if (checkExpression(oriEntry.getExpression(), testEntry.getExpression(), inputConnNameMap)) {
                        return true;
                    }
                }
            }
            if (!found) {
                return true;
            }
        }
    }
    return false;
}

Example 35 with OutputTreeNode

use of org.talend.designer.xmlmap.model.emf.xmlmap.OutputTreeNode in project tdi-studio-se by Talend.

the class XmlMapService method externalEmfDataClone.

/*
     * (non-Javadoc)
     * 
     * @see
     * org.talend.core.service.IXmlMapService#externalEmfDataClone(org.talend.designer.core.model.utils.emf.talendfile
     * .AbstractExternalData)
     */
@Override
public AbstractExternalData externalEmfDataClone(AbstractExternalData externalEmfData) {
    if (!(externalEmfData instanceof XmlMapData)) {
        return externalEmfData;
    }
    Map<EObject, EObject> nodeMaps = new HashMap<EObject, EObject>();
    XmlMapData newXmlMapData = XmlmapFactory.eINSTANCE.createXmlMapData();
    XmlMapData xmlMapData = (XmlMapData) externalEmfData;
    EList<InputXmlTree> oriInputs = xmlMapData.getInputTrees();
    EList<OutputXmlTree> oriOutputs = xmlMapData.getOutputTrees();
    EList<VarTable> oriVars = xmlMapData.getVarTables();
    EList<IConnection> oriConns = xmlMapData.getConnections();
    for (IConnection oriConn : oriConns) {
        if (oriConn instanceof INodeConnection) {
            AbstractNode sourceNode = ((INodeConnection) oriConn).getSource();
            AbstractNode targetNode = ((INodeConnection) oriConn).getTarget();
            EObject source = null;
            if (nodeMaps.get(sourceNode) != null) {
                source = nodeMaps.get(sourceNode);
            } else {
                source = cloneTreeNode(sourceNode);
                nodeMaps.put(sourceNode, source);
            }
            EObject target = null;
            if (nodeMaps.get(targetNode) != null) {
                target = nodeMaps.get(targetNode);
            } else {
                target = cloneTreeNode(targetNode);
                nodeMaps.put(targetNode, target);
            }
            if (oriConn instanceof Connection) {
                new XmlMapConnectionBuilder().createConnection((AbstractNode) source, (AbstractNode) target, newXmlMapData);
            } else if (oriConn instanceof LookupConnection) {
                new XmlMapConnectionBuilder().createLookupConnection((TreeNode) source, (TreeNode) target, newXmlMapData);
            }
        } else if (oriConn instanceof FilterConnection) {
            AbstractNode sourceNode = ((FilterConnection) oriConn).getSource();
            AbstractInOutTree targetNode = ((FilterConnection) oriConn).getTarget();
            EObject source = null;
            if (nodeMaps.get(sourceNode) != null) {
                source = nodeMaps.get(sourceNode);
            } else {
                source = cloneTreeNode(sourceNode);
                nodeMaps.put(sourceNode, source);
            }
            EObject target = null;
            if (nodeMaps.get(targetNode) != null) {
                target = nodeMaps.get(targetNode);
            } else {
                target = cloneTreeNode(targetNode);
                nodeMaps.put(targetNode, target);
            }
            new XmlMapConnectionBuilder().createFilterConnection((AbstractNode) source, (AbstractInOutTree) target, newXmlMapData);
        }
    }
    for (InputXmlTree inputXml : oriInputs) {
        InputXmlTree newInputXml = null;
        if (nodeMaps.get(inputXml) == null) {
            newInputXml = (InputXmlTree) cloneTreeNode(inputXml);
        } else {
            newInputXml = (InputXmlTree) nodeMaps.get(inputXml);
        }
        if (inputXml.getNodes() != null) {
            for (TreeNode treeNode : inputXml.getNodes()) {
                EObject obj = nodeMaps.get(treeNode);
                if ((obj != null) && !newInputXml.getNodes().contains(obj)) {
                    newInputXml.getNodes().add((TreeNode) obj);
                }
            }
        }
        if (!newXmlMapData.getInputTrees().contains(newInputXml)) {
            newXmlMapData.getInputTrees().add(newInputXml);
        }
        nodeMaps.put(inputXml, newInputXml);
    }
    for (OutputXmlTree outputXml : oriOutputs) {
        OutputXmlTree newOutputXml = null;
        if (nodeMaps.get(outputXml) == null) {
            newOutputXml = (OutputXmlTree) cloneTreeNode(outputXml);
        } else {
            newOutputXml = (OutputXmlTree) nodeMaps.get(outputXml);
        }
        if (outputXml.getNodes() != null) {
            for (OutputTreeNode treeNode : outputXml.getNodes()) {
                EObject obj = nodeMaps.get(treeNode);
                if ((obj != null) && !newOutputXml.getNodes().contains(obj)) {
                    newOutputXml.getNodes().add((OutputTreeNode) obj);
                }
            }
        }
        // }
        if (!newXmlMapData.getOutputTrees().contains(newOutputXml)) {
            newXmlMapData.getOutputTrees().add(newOutputXml);
        }
        nodeMaps.put(outputXml, newOutputXml);
    }
    for (VarTable varXml : oriVars) {
        VarTable newVarXml = null;
        if (nodeMaps.get(varXml) == null) {
            newVarXml = XmlmapFactory.eINSTANCE.createVarTable();
            newVarXml.setMinimized(varXml.isMinimized());
            newVarXml.setName(varXml.getName());
            if (varXml.getNodes() != null) {
                for (VarNode treeNode : varXml.getNodes()) {
                    EObject obj = nodeMaps.get(treeNode);
                    if (obj != null) {
                        newVarXml.getNodes().add((VarNode) obj);
                    }
                }
            }
            if (!newXmlMapData.getVarTables().contains(newVarXml)) {
                newXmlMapData.getVarTables().add(newVarXml);
            }
            nodeMaps.put(varXml, newVarXml);
        }
    }
    return newXmlMapData;
}