package typinferenz;

import java.util.Vector;

import mycompiler.mytype.Pair;
import mycompiler.mytype.RefType;
import mycompiler.mytype.Type;
import mycompiler.mytype.TypePlaceholder;

public class OderConstraint{
	private Vector<UndConstraint> oderConstraintPairs;
	
	/**
	 * Erstellt ein neues Oder Constraint und fügt bereits ein Constraint hinzu.
	 * @param p1
	 * @param p2
	 */
	public OderConstraint(Type p1, Type p2){
		if(p1 == null || p2 == null)throw new NullPointerException();
		Pair constraintPair = new Pair(p1,p2);
		oderConstraintPairs = new Vector<UndConstraint>();
		this.addConstraint(constraintPair);
	}
	
	public OderConstraint(){
		oderConstraintPairs = new Vector<UndConstraint>();
	}
	
	
	/**
	 * Liefert alle in diesem OderConstraint enthaltene Constraints. Dabei gehen die Verknüpfungen (Oder/Und) verloren.
	 * @return
	 */
	public Vector<Pair> getConstraintPairs(){
		Vector<Pair> ret = new Vector<Pair>();
		for(UndConstraint oC : this.oderConstraintPairs){
			ret.addAll(oC.getConstraintPairs());
		}
		return ret;
	}
	
	/**
	 * Fügt ein Pair(p1, p2) dem Constraint hinzu
	 * @param p1
	 * @param p2
	 */
	public void addConstraint(Type p1, Type p2){
		addConstraint(new Pair(p1,p2));
	}
	
	/**
	 * Falls die Type des toAdd-Pairs nicht vom Typ RefType bzw. TypePlaceholder sind, so werden sie in einen RefType umgewandelt.
	 * @param toAdd
	 */
	public void addConstraint(Pair toAdd){
		oderConstraintPairs.add(new SingleConstraint(toAdd.TA1, toAdd.TA2));
	}
	
	@Override
	public String toString(){
		String ret = "[";
		for(UndConstraint p : this.getUndConstraints()){
			ret += p.toString()+ "| ";
		}
		return ret+"]";
	}

	public Vector<UndConstraint> getUndConstraints() {
		return this.oderConstraintPairs;
		/*
		Vector<UndConstraint> ret = new Vector<UndConstraint>();
		for(Pair p : this.getConstraintPairs()){
			ret.add(new UndConstraint(p.TA1,p.TA2));
		}
		return ret;
		*/
	}

	public void addConstraint(UndConstraint methodConstraint) {
		oderConstraintPairs.add(methodConstraint);
	}
	
}