/**
 * 
 */
package valutazione.normalization.normalizeExpressionStrict;

import restrizioniIstanze.expressions.AndNorm;
import restrizioniIstanze.expressions.ArrayConsNorm;
import restrizioniIstanze.expressions.BooleanNorm;
import restrizioniIstanze.expressions.ConcatNorm;
import restrizioniIstanze.expressions.DifferentNorm;
import restrizioniIstanze.expressions.DivisioneNorm;
import restrizioniIstanze.expressions.EqualNorm;
import restrizioniIstanze.expressions.ExpressionNorm;
import restrizioniIstanze.expressions.FirstNorm;
import restrizioniIstanze.expressions.GetNorm;
import restrizioniIstanze.expressions.IdentExprNorm;
import restrizioniIstanze.expressions.InsertNorm;
import restrizioniIstanze.expressions.IntegerNorm;
import restrizioniIstanze.expressions.LengthNorm;
import restrizioniIstanze.expressions.ListConsNorm;
import restrizioniIstanze.expressions.MaggioreNorm;
import restrizioniIstanze.expressions.MaggioreUgualeNorm;
import restrizioniIstanze.expressions.MinoreNorm;
import restrizioniIstanze.expressions.MinoreUgualeNorm;
import restrizioniIstanze.expressions.MoltiplicazioneNorm;
import restrizioniIstanze.expressions.NegazioneNorm;
import restrizioniIstanze.expressions.OrNorm;
import restrizioniIstanze.expressions.PutNorm;
import restrizioniIstanze.expressions.ReadNorm;
import restrizioniIstanze.expressions.RealNorm;
import restrizioniIstanze.expressions.RecordConsNorm;
import restrizioniIstanze.expressions.RemoveNorm;
import restrizioniIstanze.expressions.SommaNorm;
import restrizioniIstanze.expressions.SottrazioneNorm;
import restrizioniIstanze.expressions.TailNorm;
import restrizioniIstanze.expressions.WriteNorm;
import specificheAEmilia.And;
import specificheAEmilia.ArrayCons;
import specificheAEmilia.Boolean;
import specificheAEmilia.Concat;
import specificheAEmilia.Different;
import specificheAEmilia.Divisione;
import specificheAEmilia.Equal;
import specificheAEmilia.Expression;
import specificheAEmilia.First;
import specificheAEmilia.Get;
import specificheAEmilia.IdentExpr;
import specificheAEmilia.Insert;
import specificheAEmilia.Integer;
import specificheAEmilia.Length;
import specificheAEmilia.ListCons;
import specificheAEmilia.Maggiore;
import specificheAEmilia.MaggioreUguale;
import specificheAEmilia.Minore;
import specificheAEmilia.MinoreUguale;
import specificheAEmilia.Moltiplicazione;
import specificheAEmilia.Negazione;
import specificheAEmilia.Or;
import specificheAEmilia.Put;
import specificheAEmilia.Read;
import specificheAEmilia.Real;
import specificheAEmilia.RecordCons;
import specificheAEmilia.Remove;
import specificheAEmilia.Somma;
import specificheAEmilia.Sottrazione;
import specificheAEmilia.Tail;
import specificheAEmilia.Write;

/**
 * @author Mirko
 *
 */
public class MetodiVari {

	ExpressionNorm getExpressionNorm(Expression oldExp, Expression newExp) 
	{
	if (newExp instanceof And)
		{
		AndNorm andNorm = new AndNorm();
		andNorm.setOldExpression(oldExp);
		andNorm.setNewExpression((And)newExp);
		return andNorm;
		}
	else if (newExp instanceof ArrayCons)
		{
		ArrayConsNorm arrayConsNorm = new ArrayConsNorm();
		arrayConsNorm.setOldExpression(oldExp);
		arrayConsNorm.setNewExpression((ArrayCons)newExp);
		return arrayConsNorm;
		}
	else if (newExp instanceof Boolean)
		{
		BooleanNorm booleanNorm = new BooleanNorm();
		booleanNorm.setOldExpression(oldExp);
		booleanNorm.setNewExpression((Boolean)newExp);
		return booleanNorm;
		}
	else if (newExp instanceof Concat)
		{
		ConcatNorm concatNorm = new ConcatNorm();
		concatNorm.setOldExpression(oldExp);
		concatNorm.setNewExpression((Concat)newExp);
		return concatNorm;
		}
	else if (newExp instanceof Different)
		{
		DifferentNorm differentNorm = new DifferentNorm();
		differentNorm.setOldExpression(oldExp);
		differentNorm.setNewExpression((Different)newExp);
		return differentNorm;
		}
	else if (newExp instanceof Divisione)
		{
		DivisioneNorm divisioneNorm = new DivisioneNorm();
		divisioneNorm.setOldExpression(oldExp);
		divisioneNorm.setNewExpression((Divisione)newExp);
		return divisioneNorm;
		}
	else if (newExp instanceof Equal)
		{
		EqualNorm equalNorm = new EqualNorm();
		equalNorm.setOldExpression(oldExp);
		equalNorm.setNewExpression((Equal)newExp);
		return equalNorm;
		}
	else if (newExp instanceof First)
		{
		FirstNorm firstNorm = new FirstNorm();
		firstNorm.setOldExpression(oldExp);
		firstNorm.setNewExpression((First)newExp);
		return firstNorm;
		}
	else if (newExp instanceof Get)
		{
		GetNorm getNorm = new GetNorm();
		getNorm.setOldExpression(oldExp);
		getNorm.setNewExpression((Get)newExp);
		return getNorm;
		}
	else if (newExp instanceof IdentExpr)
		{
		IdentExprNorm identExprNorm = new IdentExprNorm();
		identExprNorm.setOldExpression(oldExp);
		identExprNorm.setNewExpression((IdentExpr)newExp);
		return identExprNorm;
		}
	else if (newExp instanceof Insert)
		{
		InsertNorm insertNorm = new InsertNorm();
		insertNorm.setOldExpression(oldExp);
		insertNorm.setNewExpression((Insert)newExp);
		return insertNorm;
		}
	else if (newExp instanceof Integer)
		{
		IntegerNorm integerNorm = new IntegerNorm();
		integerNorm.setOldExpression(oldExp);
		integerNorm.setNewExpression((Integer)newExp);
		return integerNorm;
		}
	else if (newExp instanceof Length)
		{
		LengthNorm lengthNorm = new LengthNorm();
		lengthNorm.setOldExpression(oldExp);
		lengthNorm.setNewExpression((Length)newExp);
		return lengthNorm;
		}
	else if (newExp instanceof ListCons)
		{
		ListConsNorm listConsNorm = new ListConsNorm();
		listConsNorm.setOldExpression(oldExp);
		listConsNorm.setNewExpression((ListCons)newExp);
		return listConsNorm;
		}
	else if (newExp instanceof Maggiore)
		{
		MaggioreNorm maggioreNorm = new MaggioreNorm();
		maggioreNorm.setOldExpression(oldExp);
		maggioreNorm.setNewExpression((Maggiore)newExp);
		return maggioreNorm;
		}
	else if (newExp instanceof MaggioreUguale)
		{
		MaggioreUgualeNorm maggioreUgualeNorm = new MaggioreUgualeNorm();
		maggioreUgualeNorm.setOldExpression(oldExp);
		maggioreUgualeNorm.setNewExpression((MaggioreUguale)newExp);
		return maggioreUgualeNorm;
		}
	else if (newExp instanceof Minore)
		{
		MinoreNorm minoreNorm = new MinoreNorm();
		minoreNorm.setOldExpression(oldExp);
		minoreNorm.setNewExpression((Minore)newExp);
		return minoreNorm;
		}
	else if (newExp instanceof MinoreUguale)
		{
		MinoreUgualeNorm minoreUgualeNorm = new MinoreUgualeNorm();
		minoreUgualeNorm.setOldExpression(oldExp);
		minoreUgualeNorm.setNewExpression((MinoreUguale)newExp);
		return minoreUgualeNorm;
		}
	else if (newExp instanceof Moltiplicazione)
		{
		MoltiplicazioneNorm moltiplicazioneNorm = new MoltiplicazioneNorm();
		moltiplicazioneNorm.setOldExpression(oldExp);
		moltiplicazioneNorm.setNewExpression((Moltiplicazione)newExp);
		return moltiplicazioneNorm;
		}
	else if (newExp instanceof Negazione)
		{
		NegazioneNorm negazioneNorm = new NegazioneNorm();
		negazioneNorm.setOldExpression(oldExp);
		negazioneNorm.setNewExpression((Negazione)newExp);
		return negazioneNorm;
		}
	else if (newExp instanceof Or)
		{
		OrNorm orNorm = new OrNorm();
		orNorm.setOldExpression(oldExp);
		orNorm.setNewExpression((Or)newExp);
		return orNorm;
		}
	else if (newExp instanceof Put)
		{
		PutNorm putNorm = new PutNorm();
		putNorm.setOldExpression(oldExp);
		putNorm.setNewExpression((Put)newExp);
		return putNorm;
		}
	else if (newExp instanceof Read)
		{
		ReadNorm readNorm = new ReadNorm();
		readNorm.setOldExpression(oldExp);
		readNorm.setNewExpression((Read)newExp);
		return readNorm;
		}
	else if (newExp instanceof Real)
		{
		RealNorm realNorm = new RealNorm();
		realNorm.setOldExpression(oldExp);
		realNorm.setNewExpression((Real)newExp);
		return realNorm;
		}
	else if (newExp instanceof RecordCons)
		{
		RecordConsNorm recordConsNorm = new RecordConsNorm();
		recordConsNorm.setOldExpression(oldExp);
		recordConsNorm.setNewExpression((RecordCons)newExp);
		return recordConsNorm;
		}
	else if (newExp instanceof Remove)
		{
		RemoveNorm removeNorm = new RemoveNorm();
		removeNorm.setOldExpression(oldExp);
		removeNorm.setNewExpression((Remove)newExp);
		return removeNorm;
		}
	else if (newExp instanceof Somma)
		{
		SommaNorm sommaNorm = new SommaNorm();
		sommaNorm.setOldExpression(oldExp);
		sommaNorm.setNewExpression((Somma)newExp);
		return sommaNorm;
		}
	else if (newExp instanceof Sottrazione)
		{
		SottrazioneNorm sottrazioneNorm = new SottrazioneNorm();
		sottrazioneNorm.setOldExpression(oldExp);
		sottrazioneNorm.setNewExpression((Sottrazione)newExp);
		return sottrazioneNorm;
		}
	else if (newExp instanceof Tail)
		{
		TailNorm tailNorm = new TailNorm();
		tailNorm.setOldExpression(oldExp);
		tailNorm.setNewExpression((Tail)newExp);
		return tailNorm;
		}
	else if (newExp instanceof Write)
		{
		WriteNorm writeNorm = new WriteNorm();
		writeNorm.setOldExpression(oldExp);
		writeNorm.setNewExpression((Write)newExp);
		return writeNorm;
		}
	else
		return null;
	}
}
