adding documentation

app/src/main/java/sudoku/structure/Sudoku.java

@@ -24,7 +24,7 @@ public class Sudoku {
 	 */
 	private final List<IConstraint> constraints;
 	/**
-	 * Largeur des Blocks s'ils sont rectangulaires, sinon ça vaut 0.
+	 * Largeur des Blocks s'ils sont rectangulaires, valant 0 si ce n'est pas le cas.
 	 */
 	private int blockWidth;
 
@@ -35,7 +35,7 @@ public class Sudoku {
 	}
 
 	/**
-	 * Transforme un index de Cell en Coordiante.
+	 * Transforme un index de Cell en Coordinate.
 	 *
 	 * @param index int, index d'une Cell.
 	 * @return Coordinate, correspondante à l'index donné.
@@ -56,7 +56,7 @@ public class Sudoku {
 
 	/**
 	 * Vérifie que des coordonnées correspondent bien à une Cell dans le Sudoku.
-	 * @return boolean, wether the coords are in the sudoku
+	 * @return boolean, valant true si les coordonnées sont dans les bornes du Sudoku, false sinon.
 	 */
 	public boolean isValidCoords(int x, int y) {
 		int index = toIndex(x, y);
@@ -64,12 +64,20 @@ public class Sudoku {
 	}
 
 	/**
-	 * @return wether the coords are in the sudoku
+	 * Vérifie que l'index correspond bien à une Cell dans le Sudoku.
+	 * @return boolean, valant true si l'index est dans les bornes du Sudoku, false sinon.
 	 */
 	public boolean isValidCoords(int index) {
 		return index < getSize() * getSize();
 	}
 
+	/**
+	 * Teste si on peut placer la value dans la Cell aux coordonnées x, y d'après les contraintes du Sudoku.
+	 * @param x int, abscisse de la Cell voulue.
+	 * @param y int, ordonnée de la Cell voulue.
+	 * @param value int, index du symbole qu'on veut placer.
+	 * @return boolean, true si on peut la placer et false sinon.
+	 */
 	public boolean canBePlaced(int x, int y, int value) {
 		for (IConstraint constraint : this.constraints) {
 			if (!constraint.canBePlaced(this, x, y, value)) {
@@ -79,6 +87,13 @@ public class Sudoku {
 		return true;
 	}
 
+	/**
+	 * Tente de placer le symbole value dans la Cell de coordonnées x, y.
+	 * @param x int, abscisse de la Cell voulue.
+	 * @param y int, coordonnée de la Cell voulue;
+	 * @param value int, index du symbole que l'on veut placer.
+	 * @return boolean, true si le symbole a été placé, false sinon
+	 */
 	public boolean tryPlaceCellSymbol(int x, int y, int value) {
 		assert (isValidCoords(x, y));
 		if (!canBePlaced(x, y, value))
@@ -88,12 +103,21 @@ public class Sudoku {
 		return true;
 	}
 
+	/**
+	 * Vide la Cell dotn les coordonnées sont renseignées de son symbole.
+	 * @param x int, abscisse de la Cell voulue.
+	 * @param y int, coordonnée de la Cell voulue.
+	 */
+
 	public void clearCell(int x, int y) {
 		assert (isValidCoords(x, y));
 		Cell cell = getCell(x, y);
 		cell.setSymbolIndex(Cell.NOSYMBOL);
 	}
 
+	/**
+	 * Vide toutes les Cell du Sudoku.
+	 */
 	public void clear() {
 		for (int i = 0; i < getSize() * getSize(); i++) {
 			Cell cell = getCell(i);
@@ -107,9 +131,11 @@ public class Sudoku {
 	}
 
 	/**
-	 * Try to place a cell at the given coordinate
-	 *
-	 * @return Cell created or null if it can't be done
+	 * Place le symbole d'index value dans la Cell de coordonnées précisées.
+	 * @param x int, abscisse de la Cell voulue.
+	 * @param y int, coordonnée de la Cell voulue.
+	 * @param value int, index du symbole à placer.
+	 * @return Cell, la Cell qui a été modifiée.
 	 */
 	public Cell setCellSymbol(int x, int y, int value) {
 		assert (isValidCoords(x, y));
@@ -123,6 +149,11 @@ public class Sudoku {
 		return cell;
 	}
 
+	/**
+	 * Place les symboles d'index contenus dans values dans les cases du Sudoku.
+	 * @param values List<Integer>, liste des index des symboles à placer.
+	 * @return boolean, vaut true si les symboles ont été placés, false sinon.
+	 */
 	public boolean setCellsSymbol(List<Integer> values) {
 		if (values.size() > this.cells.size()) {
 			return false;
@@ -136,6 +167,11 @@ public class Sudoku {
 		return true;
 	}
 
+	/**
+	 * Place les symboles d'index contenus dans values dans les cases du Sudoku et rend ces cases immuables.
+	 * @param values List<Integer>, liste des index des symboles à placer.
+	 * @return boolean, vaut true si les symboles ont été placés, false sinon.
+	 */
 	public boolean setImmutableCellsSymbol(List<Integer> values) {
 		if (values.size() > this.cells.size()) {
 			return false;
@@ -185,10 +221,21 @@ public class Sudoku {
 		return this.blocks;
 	}
 
+	/**
+	 * Vérifie si une Cell appartient au Sudoku.
+	 * @param cell Cell, cellule dont on veut vérifier l'appartenance au Sudoku.
+	 * @return boolean, vaut true si la Cell appartient au Sudoku.
+	 */
 	public boolean contains(Cell cell) {
 		return this.cells.contains(cell);
 	}
 
+	/**
+	 * Localise la Cell dans le Sudoku.
+	 * @param c Cell, cellule dont on veut les coordonées.
+	 * @return Coordinate, coordonnées de la Cell.
+	 * @throws Exception si la Cell n'appartient pas au Sudoku.
+	 */
 	private Coordinate getCoordinateCell(Cell c) throws Exception {
 		int x = 0, y = 0;
 		int size = this.getSize();
@@ -213,7 +260,11 @@ public class Sudoku {
 		return new Coordinate(x, y);
 	}
 
-	public void updateSymbolsPossibilities() throws Exception {
+	/**
+	 * Met à jour les symboles possibles des Cells du Sudoku.
+	 *
+	 */
+	public void updateSymbolsPossibilities(){
 		for (IConstraint constraint : constraints) {
 			List<Cell> cells = this.getCells();
 			for (Cell cell : cells) {
@@ -221,16 +272,12 @@ public class Sudoku {
 				try {
 					coord = this.getCoordinateCell(cell);
 				} catch (Exception e) {
-					throw new RuntimeException(e);
+					System.out.println("Cas jamais atteint.");
 				}
 				List<Integer> newPossibleSymbols = cell.getPossibleSymbols();
 				newPossibleSymbols.retainAll(constraint.getPossibleSymbols(this, coord.getX(), coord.getY()));
 
 				cell.setPossibleSymbols(newPossibleSymbols);
-
-				if (cell.getPossibleSymbols().isEmpty()) {
-					throw new Exception("Rollback bitch");
-				}
 			}
 		}
 	}
@@ -249,6 +296,10 @@ public class Sudoku {
 		return sb.toString();
 	}
 
+	/**
+	 * Renvoie la 1re Cell vide du Sudoku.
+	 * @return Cell, une Cell vide, ou null s'il n'y en a pas.
+	 */
 	public Cell getFirstEmptyCell() {
 		for (Cell cell : this.cells) {
 			if (cell.isEmpty()) {
@@ -258,6 +309,11 @@ public class Sudoku {
 		return null;
 	}
 
+	/**
+	 * Renvoie l'index des symboles possibles de la Cell passée en paramètres.
+	 * @param cellToFill Cell, cellule dont on cherche les symboles posisbles.
+	 * @return List<Integer>, la liste des index des symboles possibles, vide si la Cell n'appartient pas au Sudoku.
+	 */
 	public List<Integer> getPossibleSymbolsOfCell(Cell cellToFill) {
 		List<Integer> result = new ArrayList<>();
 		Coordinate cellCoordinates;
@@ -277,6 +333,10 @@ public class Sudoku {
 		return result;
 	}
 
+	/**
+	 * Vérifie que le Sudoku est cohérent avec ses contraintes.
+	 * @return boolean, valant true si le Sudoku est cohérent avec ses contraintes, false sinon.
+	 */
 	public boolean isValid() {
 		for (Cell cell : this.cells) {
 			if (cell.isMutable()) {