References in properties change in both JTree

Question

Before all I'm sorry for my bad english and tell me if anything is not understandable.

I have 2 Jtree. Each tree apparently has the same information. The only thing that changes in them are the names of the properties that has each node.

Eg JTree1 has an ID and a ParentID. These properties have as a name and value. Name: ID_Tree1. Value: TESTID1 / / Name: ParentID_Tree1. Value: TESTPID1 In JTree2 has the same values ​​as in the JTree1 but the names are different.

There is a moment in which I transfer a node from JTree1 to JTree2 to create it. The transfer/creation is correct but when I read the nodes, it has a different property name architecture(Jtree1 arch.) and can't be read because need to have the JTree2 architecture. I have the function changeAttributesNamesFromDOORSToTC() to solve the problem because it just change the name to the correct name and understandable for JTree2

The real problem: The function make the change in the node of JTree2 but at the same time it change the values name of the same node in JTree1. It makes reference data instead of assignments I think.

How can I solve this!?

Thanks!

JTree treeDOORSCode; //JTree1
JTree treeTCCode;  //JTree2

Main Code:

//ACTUAL NODE
DefaultMutableTreeNode selectedTreeNode = (DefaultMutableTreeNode) CurrentSelection.getLastPathComponent();
NodeClass actualNode = (NodeClass)selectedTreeNode.getUserObject();


//ACTUAL PARENT NODE
DefaultMutableTreeNode selectedParentTreeNode = (DefaultMutableTreeNode)     selectedTreeNode.getParent();
NodeClass parentNode = (NodeClass) selectedParentTreeNode.getUserObject();
DefaultMutableTreeNode parent = findNode(NodeClass.getNodeParentIdentifierAttrDOORS(parentNode), treeTCCode);


//NEW NODE
DefaultMutableTreeNode newSelectedTreeNode = selectedTreeNode;

//NEW PART
NodeClass newNode = new NodeClass();
        newNode = insertNodeInfo(actualNode);

//Create the Model and insert the node
DefaultTreeModel treeModelTC = (DefaultTreeModel)treeTCCode.getModel();
treeModelTC.insertNodeInto(newSelectedTreeNode, parent, 0);

//NEW PART
newNode .changeAttributesNamesFromDOORSToTC();
newSelectedTreeNode.setUserObject(newNode);

Function which change the attr Name values:

public void changeAttributesNamesFromDOORSToTC(){

    for (int i = 0; i < this.attributes.size(); i++) {
        if (this.attributes.get(i).attributeName.equals(DOORS_ID)){
            if (this.tag.equals(TYPE_NAME_CASE)){
                this.attributes.get(i).attributeName = TC_IDCASE;
            }
            if (this.tag.equals(TYPE_NAME_FOLDER)){
                this.attributes.get(i).attributeName = TC_IDFOLDER;
            }
            if (this.tag.equals(TYPE_NAME_FEATURE)){
                this.attributes.get(i).attributeName = TC_IDFEATURE;
            }
        }
        if (this.attributes.get(i).attributeName.equals(DOORS_PARENTID)){
            this.attributes.get(i).attributeName = TC_PARENTID;
        }
        if (this.attributes.get(i).attributeName.equals(DOORS_SRS)){
            this.attributes.get(i).attributeName = TC_SRS;
        }

    }
}

Attributes Class:

NodeAttributesClass (String attributeName, String attributeValue)
{
    this.attributeName = attributeName;
    this.attributeValue = attributeValue;
}

Let me know if need more info!

Answer 1

Object assignment in java is actually a reference copy.

NodeClass newActualNode = actualNode;

That line doesn't mean "put the values of object actualNode into object newActualNode", because actually the variable actualNode is not an instance of NodeClass, but a reference to an instance of NodeClass. So when you do NodeClass newActualNode = actualNode; you are copying the reference and now both variables effectively point to the same instance.

Then when you change the attribute names in one "the other" also changes, because there is no such other, it's the same place in memory.

Now, what you need to do is to create a new instance of NodeClass with the values you want. There are several ways to do so, it's hard for me to know wich one is more suitable as I don't know the internal structures, but in the end you need to:

• Create a new NodeClass instance for the newActualNode variable
• Put the values (fields) of actualNode into the newActualNode
• Assign the attribute names that you want in newActualNode

So, it could be something like this:

NodeClass newActualNode = new NodeClass(actualNode);  //copy constructor  NodeClass(NodeClass anotherNode);
newActualNode.changeAttributesNamesFromDOORSToTC(); //assuming the constructor doesn't put them right

or you could use a flag in the NodeClass construtors to indicate what kind of attribute names you want.

and the copy constructor should look like this:

public NodeClass(NodeClass anotherNode)
{
    this(anotherNode.someFields); //call to your "normal" constructor, with whatever params you need

    //copy the values into the new instance this, if you didn't do it in the above line
    this.field1 = anotherNode.field1;
    this.field2 = anotherNode.field2;
    //...
    this.fieldn = anotherNode.fieldn;
}

You can take this code with a grain of salt, there are several ways to do it, the differences are subtle if any. The important thing is that you need to have another instance for the other tree.

EDIT

If that doesn't work my guess would be, that either you need to do newSelectedTreeNode.setUserObject(newNode); before the insert, like this:

NodeClass newNode = new NodeClass();
newNode = insertNodeInfo(actualNode);
newNode.changeAttributesNamesFromDOORSToTC();
DefaultMutableTreeNode newSelectedTreeNode = new DefaultMutableTreeNode();
newSelectedTreeNode.setUserObject(newNode);
treeModelTC.insertNodeInto(newSelectedTreeNode, parent, 0);

or that parent is not properly calculated, in particular that you are getting the parent node of the treeDOORSCode, and not the one of the treeTCCode.