/** 
 *
 * @author  MR DAZY
 * @version 1.0
 */

public abstract interface Visiteur{
  public abstract Object visiteEntier(Entier n);
  public abstract Object visiteInverse(Inverse i);
  public abstract Object visiteAddition(Addition a);
  public abstract Object visiteSoustraction(Soustraction s);
  public abstract Object visiteMultiplication(Multiplication m);
  public abstract Object visiteDivision(Division d);
  public abstract Object visiteSuccesseur(Successeur s);
  public abstract Object visitePredecesseur(Predecesseur p);
}

/** 
 *
 * @author  MR DAZY
 * @version 1.0
 */
public class VisiteurParDefaut implements Visiteur{
  public Object visiteEntier(Entier n)                {return n;}
  public Object visiteInverse(Inverse i)              {return i;}
  public Object visiteAddition(Addition a)            {return a;}
  public Object visiteSoustraction(Soustraction s)    {return s;}
  public Object visiteMultiplication(Multiplication m){return m;}
  public Object visiteDivision(Division d)            {return d;}
  public Object visiteSuccesseur(Successeur s)          {return s;}
  public Object visitePredecesseur(Predecesseur p)      {return p;}
}

/*
 * VisiteurEvaluation.java
 *
 * @author  MR DAZY
 * @version 1.0
 */
public class VisiteurEvaluation extends VisiteurParDefaut {

  public Object visiteEntier(Entier n){
    return new Integer(n.n);
  }
  public Object visiteInverse(Inverse i){
    return new Integer(-evalExpr(i.e));
  }
 
  public Object visiteAddition(Addition a){
    return new Integer(evalExpr(a.e1)+evalExpr(a.e2)) ;
  }
  public Object visiteSoustraction(Soustraction s){
    return new Integer(evalExpr(s.e1)-evalExpr(s.e2)) ;
  }   
  public Object visiteMultiplication(Multiplication m){
    return new Integer(evalExpr(m.e1)*evalExpr(m.e2)) ;
  } 
  public Object visiteDivision(Division d){
    return new Integer(evalExpr(d.e1)/evalExpr(d.e2)) ;
  } 
  public Object visiteSuccesseur(Successeur s){
    return new Integer(evalExpr(s.e)+1) ;
  } 
  public Object visitePredecesseur(Predecesseur p){
    return new Integer(evalExpr(p.e)-1) ;
  } 

  /**
   * methodes de service
  */
   public int evalExpr(Expression e){
    Visiteur v = new VisiteurEvaluation();
    return ((Integer)e.accept(v)).intValue();
  }
}



/** vision Objet des expressions entières...
 * 
 * @see ExpressionSimple , ExpressionComposee
 * @author dazy
 */
public abstract class Expression {

  /** Schéma de méthode imposé pour l'évaluation des expressions
  */
  /** toutes les actions sur les feuilles de la structure
  * sont regroupées dans les visiteurs
  */
  public abstract Object accept(Visiteur v);
  
} /* end class Expression */

/** Expression Composée :  contient 2 sous expressions
 * 
 * @see OtherClasses
 * @author dazy
 */
public class Addition extends ExpressionBinaire {

  Addition(Expression e1 , Expression e2){
	  super(e1,e2);
  }
  /** toutes les actions sur les feuilles de la structure
  * sont regroupées dans les visiteurs
  */
  public Object accept(Visiteur v){
    return v.visiteAddition(this);
  } 
} /* end class Addition */

/*
 * Successeur.java
 *
 * @author  MR DAZY
 * @version 1.0
 */
public class Successeur extends ExpressionUnaire {

  /** Creates new Suc */
  public Successeur(Expression e) {
	  super(e);
  }

  /** toutes les actions sur les feuilles de la structure
  * sont regroupées dans les visiteurs
  */
  public Object accept(Visiteur v){
    return v.visiteSuccesseur(this);
  } 
} /* end class Successeur */

/*
 * VisiteurSimplication.java
 *
 * @author  MR DAZY
 * @version 1.0
 */
public class VisiteurSimplication extends VisiteurParDefaut {
 
  public Object visiteAddition(Addition a){
    if ((a.e1 instanceof Entier) && (((Entier)a.e1).n == 1)){
      return new Successeur(a.e2);
    }else{
      if ((a.e2 instanceof Entier) && (((Entier)a.e2).n == 1)){
        return new Successeur(a.e1);
      }else{return a;}
    }
  }
  public Object visiteSoustraction(Soustraction s){
    if ((s.e1 instanceof Entier) && (((Entier)s.e1).n == 1)){
      return new Predecesseur(s.e2);
    }else{
      if ((s.e1 instanceof Entier) && (((Entier)s.e1).n == 1)){
        return new Predecesseur(s.e1);
      }else{return s;}
    }
  }
}