package mycompiler.myclass;

import java.util.Vector;

import mycompiler.SyntaxTreeNode;
import mycompiler.mybytecode.ClassFile;
import mycompiler.myexception.JVMCodeException;
import mycompiler.mymodifier.Modifiers;
import mycompiler.mystatement.Block;
import mycompiler.mytype.GenericTypeVar;
import mycompiler.mytype.RefType;
import mycompiler.mytype.Type;
import mycompiler.mytypereconstruction.replacementlistener.CReplaceTypeEvent;
import typinferenz.ConstraintsSet;
import typinferenz.JavaCodeResult;
import typinferenz.ResultSet;
import typinferenz.SingleConstraint;
import typinferenz.assumptions.ConstructorAssumption;
import typinferenz.assumptions.MethodAssumption;
import typinferenz.assumptions.TypeAssumptions;
import typinferenz.exceptions.TypinferenzException;

public class Constructor extends Method {
	private Method methode;

	/**
	 * Parser kann nicht zwischen einem Konstruktor und einer Methode unterscheiden.
	 * Diese Klasse beherbegt den als Methode geparsten Konstruktor und wandelt sein verhalten zu dem eines Konstruktors ab.
	 */
	public Constructor(Method methode){
		super(methode.getOffset());
		this.methode = methode;
		this.setDeclIdVector(methode.getDeclIdVector());
		this.methode.setType(new RefType(this.methode.getParentClass().getName(),0));
	}


	@Override
	public void setGenericMethodParameters(
			Vector<GenericTypeVar> genericMethodParameters) {
		 
		this.methode.setGenericMethodParameters(genericMethodParameters);
	}

	@Override
	public Vector<GenericTypeVar> getGenericMethodParameters() {
		 
		return this.methode.getGenericMethodParameters();
	}

	@Override
	public void sc_init_parameterlist(boolean ext) {
		 
		this.methode.sc_init_parameterlist(ext);
	}

	@Override
	public String getTypeName() {
		 
		return this.getType().getName();
	}

	@Override
	public Block get_Block() {
		 
		return this.methode.get_Block();
	}



	@Override
	public void set_Block(Block blo) {
		 
		this.methode.set_Block(blo);
	}

	@Override
	public void set_Modifiers(Modifiers modif) {
		 
		this.methode.set_Modifiers(modif);
	}

	@Override
	public void set_ExceptionList(ExceptionList exlist) {
		 
		this.methode.set_ExceptionList(exlist);
	}

	@Override
	public void setParameterList(ParameterList paralist) {
		 
		this.methode.setParameterList(paralist);
	}

	@Override
	public ParameterList getParameterList() {
		 
		return this.methode.getParameterList();
	}

	@Override
	public int getParameterCount() {
		 
		return this.methode.getParameterCount();
	}

	@Override
	public ExceptionList get_ExceptionList() {
		 
		return this.methode.get_ExceptionList();
	}

	@Override
	public int getOverloadedID() {
		 
		return this.methode.getOverloadedID();
	}

	@Override
	public void setOverloadedID(int overloadedID) {
		 
		this.methode.setOverloadedID(overloadedID);
	}

	@Override
	public String get_codegen_Param_Type(Vector paralist) {
		 
		return this.methode.get_codegen_Param_Type(paralist);
	}

	@Override
	public String get_Method_Name() {
		 
		return this.methode.get_Method_Name();
	}

	@Override
	public Vector get_Type_Paralist() {
		 
		return this.methode.get_Type_Paralist();
	}

	@Override
	public void codegen(ClassFile classfile, Vector paralist)
			throws JVMCodeException {
		 
		this.methode.codegen(classfile, paralist);
	}

	@Override
	public int getLineNumber() {
		 
		return this.methode.getLineNumber();
	}

	@Override
	public void setLineNumber(int lineNumber) {
		 
		this.methode.setLineNumber(lineNumber);
	}

	@Override
	public int getOffset() {
		 
		return this.methode.getOffset();
	}

	@Override
	public int getVariableLength() {
		 
		return this.methode.getVariableLength();
	}

	@Override
	public void setOffset(int Offset) {
		 
		this.methode.setOffset(Offset);
	}

	@Override
	public void replaceType(CReplaceTypeEvent e) {
		 
		this.methode.replaceType(e);
	}

	@Override
	public int getTypeLineNumber() {
		 
		return this.methode.getTypeLineNumber();
	}

	@Override
	public String toString() {
		 
		return this.methode.toString();
	}

	@Override
	public void setAbstract(boolean b) {
		 
		this.methode.setAbstract(b);
	}

	@Override
	public boolean isAbstract() {
		 
		return this.methode.isAbstract();
	}

	@Override
	public void wandleRefTypeAttributes2GenericAttributes(Vector<Type> paralist) {
		 
		this.methode.wandleRefTypeAttributes2GenericAttributes(paralist);
	}

	@Override
	public void set_Method_Name(String string) {
		 
		this.methode.set_Method_Name(string);
	}

	public ConstraintsSet TYPE(TypeAssumptions ass) {
		ConstraintsSet ret = new ConstraintsSet();
		
		ret.add(this.methode.get_Block().TYPEStmt(ass));
		return ret;
	}

	@Override
	public String getTypeInformation() {
		 
		return this.methode.getTypeInformation();
	}

	@Override
	public JavaCodeResult printJavaCode(ResultSet resultSet) {
		 
		return this.methode.printJavaCode(resultSet);
	}

	@Override
	public TypeAssumptions createTypeAssumptions(Class classmember) {
		Class parentClass = this.getParentClass();
		TypeAssumptions ret = new TypeAssumptions();
		ret.addConstructorAssumption(new ConstructorAssumption(this, parentClass));
		return ret;
	}

	@Override
	public SyntaxTreeNode getParent(){
		return this.methode.getParent();
	}
	
	@Override
	public void parserPostProcessing(SyntaxTreeNode parent) {
		 
		this.methode.parserPostProcessing(parent);
	}

	@Override
	public Vector<SyntaxTreeNode> getChildren() {
		 
		return this.methode.getChildren();
	}

	@Override
	public void setType(Type t) {
		throw new TypinferenzException("Einem Konstruktor kann kein Typ zugewiesen werden");
		//this.methode.setType(t);
	}

	@Override
	public Type getType() {
		return this.methode.getType();
	}
	
	
}