Tree with parents

[John Vorwald]

Hi,
I have a tree structure that uses a list of nodes for the children, along with a reference to the parent.
I would like to be able to extract a node incorporating the data from the ancestors of a node.
But, I don't know how to call a member of the generic class.

class GenericsTreeNode<T> {

	public T data;
	public List<GenericsTreeNode<T>> children;
	private GenericsTreeNode<T> parent;

	public GenericsTreeNode() {
		super();
		parent = null;
		children = new ArrayList<GenericsTreeNode<T>>();
	}

	public GenericsTreeNode(T data) {
		this();
		setData(data);
	}

	public void setData(T data) {
		this.data = data;
	}

	public void addChild(GenericsTreeNode<T> child) {
		child.parent = this;
		this.children.add(child);
	}

	public GenericTreeNode<T> incoporateAncestors() {
		GenericTreeNode<T> nodeWithAncestors = new GenericTreeNode<T>();
		nodeWithAncestors.data = this.data;
		GenericsTreeNode<T> currentParent = this.parent;
		while (currentParent != null) {
			// How to write this line to access incorporateParent in T
			nodeWithAncestors.getData().incorporateParent(currentParent.data);  
			currentParent = currentParent.parent;
		}
		return nodeWithAncestors;
	}
}

class FooData {
	final String word;
	final Integer number;
	public FooData(String aWord, Integer aNumber) {
		word = aWord;
		number = aNumber;
	}
	public FooData incorporateParent(FooData parentsData) {
		FooData summary = new FooData(this.word+parentsData.word, this.number+parentsData.number);
		return summary;
	}
}

class TestTree {
	public static void main(String[] args) {

		GenericsTreeNode<FooData> root = new  GenericsTreeNode<FooData>(new FooData("Beginning", 0));
		GenericsTreeNode<FooData> child1 = new  GenericsTreeNode<FooData>(new FooData("of", 1));
		GenericsTreeNode<FooData> child2 = new  GenericsTreeNode<FooData>(new FooData("the", 2));
		GenericsTreeNode<FooData> child3 = new  GenericsTreeNode<FooData>(new FooData("week", 3));

		child2.addChild(child3);
		child1.addChild(child2);
		root.addChild(child1);
		GenericTreeNode<FooData> child3Sumary = child3.incoporateAncestors();
		System.out.printf("%s\n%d", child3Sumary.getData().word, child3Sumary.getData().number);
	}
}

I have an alternative solution where the generic class contains a reference to a tree node, and can access the parent, so the generic class can construct the summary.
In the alternative solution, I don't get the expected result of "Beginning of the week", 6. The output is "week", 3.

package genericTree;

import java.util.ArrayList;
import java.util.List;

class GenericsTreeNode2<T> {

	public T data;
	public List<GenericsTreeNode2<T>> children;
	public GenericsTreeNode2<T> parent;

	public GenericsTreeNode2() {
		super();
		parent = null;
		children = new ArrayList<GenericsTreeNode2<T>>();
	}

	public GenericsTreeNode2(T data) {
		this();
		setData(data);
	}

	public void setData(T data) {
		this.data = data;
	}

	public void addChild(GenericsTreeNode2<T> child) {
		child.parent = this;
		this.children.add(child);

	}

}

class FooData2 {
	final String word;
	final Integer number;
	GenericsTreeNode2<FooData2> node;
	public FooData2(String aWord, Integer aNumber) {
		word = aWord;
		number = aNumber;
	}
	public FooData2(FooData2 aThat) {
		this.word = aThat.word;
		this.number = aThat.number;
	}
	public void setNode(GenericsTreeNode2<FooData2> root) {
		node = root;
	}
	public FooData2 incorporateParent(FooData2 parentsData) {
		FooData2 summary = new FooData2(this.word+parentsData.word, this.number+parentsData.number);
		return summary;
	}
	public FooData2 incoporateAncestors() {
		FooData2 nodeWithAncestors = new FooData2(this);
		GenericsTreeNode2<FooData2> currentParent = this.node.parent;
		while (currentParent != null) {
			// How to write this line to access incorporateParent in T
			nodeWithAncestors.incorporateParent(currentParent.data);  
			currentParent = currentParent.parent;
		}
		return nodeWithAncestors;
	}
}

class TestTree2 {
	public static void main(String[] args) {

		GenericsTreeNode2<FooData2> root = new  GenericsTreeNode2<FooData2>(new FooData2("Beginning", 0));
		GenericsTreeNode2<FooData2> child1 = new  GenericsTreeNode2<FooData2>(new FooData2("of", 1));
		GenericsTreeNode2<FooData2> child2 = new  GenericsTreeNode2<FooData2>(new FooData2("the", 2));
		GenericsTreeNode2<FooData2> child3 = new  GenericsTreeNode2<FooData2>(new FooData2("week", 3));

		root.data.setNode(root);
		child1.data.setNode(child1);
		child2.data.setNode(child2);
		child3.data.setNode(child3);

		child2.addChild(child3);
		child1.addChild(child2);
		root.addChild(child1);
		FooData2 child3Sumary = child3.data.incoporateAncestors();
		System.out.printf("%s\n%d", child3Sumary.word, child3Sumary.number);
	}
}

[John Vorwald]

The alternative solution had a error in the incorporateParent member. The correction is below.
But, I'd still prefer to use the first alternative, to have the tree/node class manage incorporating ancestors data, instead of passing the tree node to the generic class.

package genericTree;

import java.util.ArrayList;
import java.util.List;

class GenericsTreeNode2<T> {

	public T data;
	public List<GenericsTreeNode2<T>> children;
	public GenericsTreeNode2<T> parent;

	public GenericsTreeNode2() {
		super();
		parent = null;
		children = new ArrayList<GenericsTreeNode2<T>>();
	}

	public GenericsTreeNode2(T data) {
		this();
		setData(data);
	}

	public void setData(T data) {
		this.data = data;
	}

	public void addChild(GenericsTreeNode2<T> child) {
		child.parent = this;
		this.children.add(child);

	}

}

class FooData2 {
	String word;
	Integer number;
	GenericsTreeNode2<FooData2> node;
	public FooData2(String aWord, Integer aNumber) {
		word = aWord;
		number = aNumber;
	}
	public FooData2(FooData2 aThat) {
		this.word = aThat.word;
		this.number = aThat.number;
	}
	public void setNode(GenericsTreeNode2<FooData2> root) {
		node = root;
	}
	public void incorporateParent(FooData2 parentsData) {
		word = parentsData.word.concat(word);
		number+=parentsData.number;
	}
	public FooData2 incoporateAncestors() {
		FooData2 nodeWithAncestors = new FooData2(this);
		GenericsTreeNode2<FooData2> currentParent = this.node.parent;
		while (currentParent != null) {
			// How to write this line to access incorporateParent in T
			nodeWithAncestors.incorporateParent(currentParent.data);  
			currentParent = currentParent.parent;
		}
		return nodeWithAncestors;
	}
}

class TestTree2 {
	public static void main(String[] args) {

		GenericsTreeNode2<FooData2> root = new  GenericsTreeNode2<FooData2>(new FooData2("Beginning", 0));
		GenericsTreeNode2<FooData2> child1 = new  GenericsTreeNode2<FooData2>(new FooData2("of", 1));
		GenericsTreeNode2<FooData2> child2 = new  GenericsTreeNode2<FooData2>(new FooData2("the", 2));
		GenericsTreeNode2<FooData2> child3 = new  GenericsTreeNode2<FooData2>(new FooData2("week", 3));

		root.data.setNode(root);
		child1.data.setNode(child1);
		child2.data.setNode(child2);
		child3.data.setNode(child3);

		child2.addChild(child3);
		child1.addChild(child2);
		root.addChild(child1);
		FooData2 child3Sumary = child3.data.incoporateAncestors();
		System.out.printf("%s\n%d", child3Sumary.word, child3Sumary.number);
	}
}

[John Vorwald]

I dug a little deeper into how the treenode class could be modified to manage the incorporating of ancestors. One approach to allow a generic function to call a specific member function is to make the generic extend an interface that defines the function.

The following code is an example of a tree that is able to incorporate data from ancestor nodes. It produces the result "Beginning of the week", 6, which is the desired result.

interface HasIncorporate<T> {
    public void incorporateParent(T o);	
}

class GenericsTreeNode<T extends HasIncorporate<T>> {

	public T data;
	public List<GenericsTreeNode<T>> children;
	private GenericsTreeNode<T> parent;

	public GenericsTreeNode() {
		super();
		parent = null;
		children = new ArrayList<GenericsTreeNode<T>>();
	}

	public GenericsTreeNode(T data) {
		this();
		setData(data);
	}

	public void setData(T data) {
		this.data = data;
	}

	public void addChild(GenericsTreeNode<T> child) {
		child.parent = this;
		this.children.add(child);
	}

	public GenericsTreeNode<T> incoporateAncestors() {
		GenericsTreeNode<T> nodeWithAncestors = new GenericsTreeNode<T>();
		nodeWithAncestors.data = this.data;
		GenericsTreeNode<T> currentParent = this.parent;
		while (currentParent != null) {
			// How to write this line to access incorporateParent in T
			nodeWithAncestors.data.incorporateParent(currentParent.data);  
			currentParent = currentParent.parent;
		}
		return nodeWithAncestors;
	}
}


class FooData implements HasIncorporate<FooData> {
	String word;
	Integer number;
	public FooData(String aWord, Integer aNumber) {
		word = aWord;
		number = aNumber;
	}
	@Override
	public void incorporateParent(FooData parentsData) {
		word = parentsData.word.concat(" "+word);
		number+=parentsData.number;
	}
}

class TestTree {
	public static void main(String[] args) {

		GenericsTreeNode<FooData> root = new  GenericsTreeNode<FooData>(new FooData("Beginning", 0));
		GenericsTreeNode<FooData> child1 = new  GenericsTreeNode<FooData>(new FooData("of", 1));
		GenericsTreeNode<FooData> child2 = new  GenericsTreeNode<FooData>(new FooData("the", 2));
		GenericsTreeNode<FooData> child3 = new  GenericsTreeNode<FooData>(new FooData("week", 3));

		child2.addChild(child3);
		child1.addChild(child2);
		root.addChild(child1);
		GenericsTreeNode<FooData> child3Sumary = child3.incoporateAncestors();
		System.out.printf("%s\n%d", child3Sumary.data.word, child3Sumary.data.number);
	}
}