:recycle: Refactoring

src/migl/lisp/LispElement.java

@@ -2,6 +2,9 @@ package migl.lisp;
 
 import java.math.BigInteger;
 import java.util.Map;
+
+import migl.util.ConsList;
+
 import java.util.HashMap;
 
 /**
@@ -156,5 +159,21 @@ public class LispElement {
 		}
 		return new LispElement(elt);
 	}
+	
+	/**
+	 * Récupère un élément dans la liste lisp
+	 * Si l'element est une liste elle seras alors analyser
+	 * 
+	 * @param elt L'element à récupérer
+	 * @return L'element ou le resultat de l'analyse si l'element est une liste
+	 * @throws LispError
+	 */
+	@SuppressWarnings("unchecked")
+	public static LispElement getElement(Object elt) throws LispError {
+		if(elt instanceof ConsList) {
+			return LispImpl.evaluateList((ConsList<Object>) elt);
+		}
+		return generate(elt);
+	}
 
 }

src/migl/lisp/LispImpl.java

@@ -33,23 +33,23 @@ public class LispImpl implements Lisp {
 			if(lisp.size() != 3) {
 				throw new LispError(LispError.ERR_NUM_ARG);
 			}
-			if(getElement(lisp.car()).toBoolean()) {
-				return getElement(lisp.cdr().car());
+			if(LispElement.getElement(lisp.car()).toBoolean()) {
+				return LispElement.getElement(lisp.cdr().car());
 			} else {
-				return getElement(lisp.cdr().cdr().car());
+				return LispElement.getElement(lisp.cdr().cdr().car());
 			}
 		});
 		operators.put("not", (lisp) -> {
 			if(lisp.size() != 1) {
 				throw new LispError(LispError.ERR_NUM_ARG);
 			}
-			boolean result = !getElement(lisp.car()).toBoolean();
+			boolean result = !LispElement.getElement(lisp.car()).toBoolean();
 			return LispElement.generate(result);
 		});
 		operators.put("and", (lisp) -> {
 			boolean result = true;
 			while(!lisp.isEmpty()) {
-				result = result && getElement(lisp.car()).toBoolean();
+				result = result && LispElement.getElement(lisp.car()).toBoolean();
 				lisp = lisp.cdr();
 			}
 			return LispElement.generate(result);
@@ -57,7 +57,7 @@ public class LispImpl implements Lisp {
 		operators.put("or", (lisp) -> {
 			boolean result = false;
 			while(!lisp.isEmpty()) {
-				result = result || getElement(lisp.car()).toBoolean();
+				result = result || LispElement.getElement(lisp.car()).toBoolean();
 				lisp = lisp.cdr();
 			}
 			return LispElement.generate(result);
@@ -71,10 +71,10 @@ public class LispImpl implements Lisp {
 			double value = 0;
 			while(!lisp.isEmpty()) {
 				if(first) {
-					value = getElement(lisp.car()).toNumber();
+					value = LispElement.getElement(lisp.car()).toNumber();
 					first = false;
 				} else {
-					double temp = getElement(lisp.car()).toNumber();
+					double temp = LispElement.getElement(lisp.car()).toNumber();
 					result = result && (value > temp);
 					value = temp;
 				}
@@ -91,10 +91,10 @@ public class LispImpl implements Lisp {
 			double value = 0;
 			while(!lisp.isEmpty()) {
 				if(first) {
-					value = getElement(lisp.car()).toNumber();
+					value = LispElement.getElement(lisp.car()).toNumber();
 					first = false;
 				} else {
-					double temp = getElement(lisp.car()).toNumber();
+					double temp = LispElement.getElement(lisp.car()).toNumber();
 					result = result && (value >= temp);
 					value = temp;
 				}
@@ -111,10 +111,10 @@ public class LispImpl implements Lisp {
 			double value = 0;
 			while(!lisp.isEmpty()) {
 				if(first) {
-					value = getElement(lisp.car()).toNumber();
+					value = LispElement.getElement(lisp.car()).toNumber();
 					first = false;
 				} else {
-					double temp = getElement(lisp.car()).toNumber();
+					double temp = LispElement.getElement(lisp.car()).toNumber();
 					result = result && (value < temp);
 					value = temp;
 				}
@@ -131,10 +131,10 @@ public class LispImpl implements Lisp {
 			double value = 0;
 			while(!lisp.isEmpty()) {
 				if(first) {
-					value = getElement(lisp.car()).toNumber();
+					value = LispElement.getElement(lisp.car()).toNumber();
 					first = false;
 				} else {
-					double temp = getElement(lisp.car()).toNumber();
+					double temp = LispElement.getElement(lisp.car()).toNumber();
 					result = result && (value <= temp);
 					value = temp;
 				}
@@ -151,10 +151,10 @@ public class LispImpl implements Lisp {
 			double value = 0;
 			while(!lisp.isEmpty()) {
 				if(first) {
-					value = getElement(lisp.car()).toNumber();
+					value = LispElement.getElement(lisp.car()).toNumber();
 					first = false;
 				} else {
-					result = result && (value == getElement(lisp.car()).toNumber());
+					result = result && (value == LispElement.getElement(lisp.car()).toNumber());
 				}	
 				lisp = lisp.cdr();
 			}
@@ -163,7 +163,7 @@ public class LispImpl implements Lisp {
 		operators.put("+", (lisp) -> {
 			BigInteger resultInt = new BigInteger("0");
             while(!lisp.isEmpty()){
-                LispElement eltInt = getElement(lisp.car());
+                LispElement eltInt = LispElement.getElement(lisp.car());
                 if(eltInt.value.getClass() != BigInteger.class) break;
                 resultInt = resultInt.add(eltInt.toInt());
                 lisp = lisp.cdr();
@@ -173,7 +173,7 @@ public class LispImpl implements Lisp {
             //Sinon on continue en passant en double
             double result = resultInt.doubleValue();
             while(!lisp.isEmpty()) {
-                LispElement elt = getElement(lisp.car());
+                LispElement elt = LispElement.getElement(lisp.car());
                 result += elt.toNumber();
                 lisp = lisp.cdr();
             }
@@ -182,7 +182,7 @@ public class LispImpl implements Lisp {
 		operators.put("*", (lisp) -> {
 			BigInteger resultInt = new BigInteger("1");
             while(!lisp.isEmpty()){
-                LispElement eltInt = getElement(lisp.car());
+                LispElement eltInt = LispElement.getElement(lisp.car());
                 if(eltInt.value.getClass() != BigInteger.class) break;
                 resultInt = resultInt.multiply(eltInt.toInt());
                 lisp = lisp.cdr();
@@ -192,7 +192,7 @@ public class LispImpl implements Lisp {
             //Sinon on continue en passant en double
             double result = resultInt.doubleValue();
             while(!lisp.isEmpty()) {
-                LispElement elt = getElement(lisp.car());
+                LispElement elt = LispElement.getElement(lisp.car());
                 result *= elt.toNumber();
                 lisp = lisp.cdr();
             }
@@ -201,7 +201,7 @@ public class LispImpl implements Lisp {
 		operators.put("-", (lisp) -> {
 			switch(lisp.size()) {				
 				case 1:
-					LispElement elt = getElement(lisp.car());
+					LispElement elt = LispElement.getElement(lisp.car());
 					if(elt.value.getClass() == Double.class) {
 						//return LispElement.generate(elt.toNumber() * -1); //Pb pitest qui remplace * par / or *-1 == /-1
 						double value = elt.toNumber();
@@ -209,8 +209,8 @@ public class LispImpl implements Lisp {
 					}
 					return LispElement.generate(elt.toInt().multiply(new BigInteger("-1")));
 				case 2:
-					LispElement elt1 = getElement(lisp.car());
-					LispElement elt2 = getElement(lisp.cdr().car());
+					LispElement elt1 = LispElement.getElement(lisp.car());
+					LispElement elt2 = LispElement.getElement(lisp.cdr().car());
 					if(elt1.value.getClass() == Double.class || elt2.value.getClass() == Double.class) {
 						return LispElement.generate(elt1.toNumber() - elt2.toNumber());
 					}
@@ -223,8 +223,8 @@ public class LispImpl implements Lisp {
 			if(lisp.size() != 2) {
 				throw new LispError(LispError.ERR_NUM_ARG);
 			}
-			LispElement elt1 = getElement(lisp.car());
-			LispElement elt2 = getElement(lisp.cdr().car());
+			LispElement elt1 = LispElement.getElement(lisp.car());
+			LispElement elt2 = LispElement.getElement(lisp.cdr().car());
 			if(elt2.toNumber() == 0) {
 				throw new LispError("Division by zero");
 			}
@@ -404,7 +404,7 @@ public class LispImpl implements Lisp {
 	 * @return Valeur évaluer
 	 * @throws LispError
 	 */
-	private static LispElement evaluateList(ConsList<Object> lisp) throws LispError {
+	public static LispElement evaluateList(ConsList<Object> lisp) throws LispError {
 		if(lisp.isEmpty()) {
 			return LispElement.generate("()");
 		}
@@ -420,21 +420,5 @@ public class LispImpl implements Lisp {
 			throw new LispError("List Lisp malformed: " + ex.getMessage(), ex);
 		}
 	}
-	
-	/**
-	 * Récupère un élément dans la liste lisp
-	 * Si l'element est une liste elle seras alors analyser
-	 * 
-	 * @param elt L'element à récupérer
-	 * @return L'element ou le resultat de l'analyse si l'element est une liste
-	 * @throws LispError
-	 */
-	@SuppressWarnings("unchecked")
-	public static LispElement getElement(Object elt) throws LispError {
-		if(elt instanceof ConsList) {
-			return evaluateList((ConsList<Object>) elt);
-		}
-		return LispElement.generate(elt);
-	}
 
 }

src/migl/lisp/operator/ConsOperator.java

@@ -2,7 +2,6 @@ package migl.lisp.operator;
 
 import migl.lisp.LispElement;
 import migl.lisp.LispError;
-import migl.lisp.LispImpl;
 import migl.lisp.LispOperator;
 import migl.util.ConsList;
 import migl.util.ConsListFactory;
@@ -17,11 +16,11 @@ public class ConsOperator implements LispOperator {
 		ConsList<Object> cl;
 		if(lisp.cdr().car() instanceof ConsList) {
 			//Recup + evaluation de la liste
-			cl = this.parseList(LispImpl.getElement(lisp.cdr().car()).toString());
+			cl = this.parseList(LispElement.getElement(lisp.cdr().car()).toString());
 			//Ajoute la valeur de gauche devant
 			if(lisp.car() instanceof ConsList) {
 				//Si la valeur gauche est aussi une liste on evalue sa valaue
-				cl = cl.prepend(LispImpl.getElement(lisp.car()).value);
+				cl = cl.prepend(LispElement.getElement(lisp.car()).value);
 			} else {
 				cl = cl.prepend(lisp.car());
 			}
@@ -29,7 +28,7 @@ public class ConsOperator implements LispOperator {
 			LispElement le;
 			if(lisp.car() instanceof ConsList) {
 				//Si l'element est une liste on evalue sa valeur
-				le = LispImpl.getElement(lisp.car());
+				le = LispElement.getElement(lisp.car());
 			} else {
 				le = LispElement.generate(lisp.car());
 			}