JavaCompilerCore/src/mycompiler/SyntaxTreeNode.java

package mycompiler;

import java.util.Vector;

import typinferenz.ResultSet;
import typinferenz.TypeInsertPoint;
import typinferenz.TypeInsertSet;
import typinferenz.TypeInsertable;
import typinferenz.exceptions.DebugException;
import typinferenz.exceptions.TypeinferenceException;
import mycompiler.myclass.Class;
import mycompiler.mytype.GenericTypeVar;
import mycompiler.mytype.Type;
import mycompiler.mytype.TypePlaceholder;

public abstract class SyntaxTreeNode {

	protected SyntaxTreeNode parent;

	/**
	 * Wird nach dem Parsen aufgerufen.
	 * Erf<EFBFBD>llt folgenden Aufgaben:
	 * 1. F<EFBFBD>llt fehlende Typangaben mit TPHs auf.
	 * 2. Verkn<EFBFBD>pft die Knoten des Syntaxbaums. (setzt Parent)
	 * 3. Wechselt RefTypes gegebenenfalls mit GenericTypeVars aus.
	 * 4. F<EFBFBD>hrt einen Teil des Syntaxckecks durch.
	 * 
	 */
	public void parserPostProcessing(SyntaxTreeNode parent) {
		this.parent = parent;
		for(SyntaxTreeNode node : this.getChildren())node.parserPostProcessing(this);
	}
	
	public SyntaxTreeNode getParent() {
		return this.parent;
	}
	
	public abstract Vector<SyntaxTreeNode> getChildren();
	
	public Class getParentClass(){
		SyntaxTreeNode parent = this.getParent();
		if(parent instanceof Class)return (Class)parent;
		if(parent == null)
			throw new DebugException("Das Wurzelelement eines Syntaxbaumes muss Class sein");
		return parent.getParentClass();
	}
	
	/**
	 * Eine Beschreibung/Name des SyntaxTree-Nodes
	 * @return
	 */
	public String getDescription(){
		return this.toString();
	}
	
	
	@Override
	public boolean equals(Object object){
		if(!(object instanceof SyntaxTreeNode))return false;
		SyntaxTreeNode equal = (SyntaxTreeNode)object;
		if(!equal.getDescription().equals(this.getDescription()))return false;
		if(this.getParent()!=null)
			if(!this.getParent().equals(equal.getParent()))return false; //auch das Elternelement <20>berpr<70>fen.
		return true;
	}
	
	/**
	 * Methode zur Generierung der TypeInsertPoints
	 * @param insertSet - Generierte InsertPoints werden dem insertSet angef<EFBFBD>gt
	 * @param result - Das ResultSet auf dessen Basis die InsertPoints generiert werden
	 */
	public void addTypeInsertPoints(TypeInsertSet insertSet,ResultSet result) {
		Vector<TypeInsertPoint> ret = new Vector<TypeInsertPoint>();
		//Fall der Knoten ein TypeInsertable ist, kann direkt der TypeInsertPoint generiert werden.
		if(this instanceof TypeInsertable){
			TypeInsertable that = (TypeInsertable)this;
				Type t = that.getType();
				if(t instanceof TypePlaceholder)
					ret.add(that.createTypeInsertPoint((TypePlaceholder) t, result));//ret.addAll(((TypePlaceholder)t).getTypeInsertPoints(result));
				
		}
		insertSet.add(ret);
		
		//Nachdem die InsertPoints und GenericVarTypeInsertPoints angef<65>gt wurden, kann im Knoten abgestiegen werden:
		for(SyntaxTreeNode node : this.getChildren()){
			node.addTypeInsertPoints(insertSet, result);
		}
	}
}