# RAPPORT FINALE

> ANDJEMBE Maksoudath, TANIEL Rémi

Le but du projet est de réaliser un tableur "basique" mais facilement
extensible, l'application sera divisée en 2 parties :
* le kernel
* la partie graphique

Le kernel s'occupera de toutes les opérations de notre grid, les cases
ne pourront contenir que des réels ou des formules(opération binaire ou
des fonctions acceptant des plages de cases).

## 1. ANALYSE ET CONCEPTION


### SCHEMA UML

Voici le schéma UML de notre application, les classes et méthodes
abstraites sont en italique :

![UML](uml.png)


### PSEUDO-JAVA CREATION GRILLE,CASES

Voici un exemple de création d'une grid et de l'ajout / modification /
affichage de plusieurs types de case :

```java
class Application {
    
    public static void main(String[] args) {
        Grille g = new Grille();
        
        g.createCase("b",1); //Ajout case vide
        g.createCase("a",1,100.0); //Ajout case avec valeur
        g.createCase("a",2,50.0); //Ajout case avec valeur
        g.createCase("a",3,new Addition(g.getCase("a",2),g.getCase("a",1))); //Ajout case avec operation binaire
        
        List<Case> plageCase1 = new ArrayList<Case>(); // Crée une liste de case
        plageCase1.add(g.getCase("a",1));
        plageCase1.add(g.getCase("a",2));
        plageCase1.add(g.getCase("a",3));
        
        g.createCase("a",4,new Somme(plageCase1)); //Ajout case avec fonctions
        
        g.setValeur("b",1,100); //Met la valeur de b1 à 100
        
        List<Case> plageCase2 = new ArrayList<Case>(); // Crée une liste de case
        plageCase1.add(g.getCase("a",4));
        plageCase1.add(g.getCase("a",2));
        plageCase1.add(g.getCase("a",3));
        
        g.setFormule("b",2,new Moyenne(plageCase2)); //Met la formule dans b2 
        
        g.getValeur("a",1); //Affichera 100.0
        g.getValeur("a",4); //Affichera (100+50+150)=100
        g.getFormuleAsString("b",2); //Affichera MOYENNE(a4,a2,a3)
        g.getFormuleDeveloppe("b",2); 
    }
}
```

### CHOIX STRUCTURE DE DONNÉES

Nous devons choisir une structure de donnée pour stocker les cases dans 
notre grid, nous savons déjà que nous allons utiliser ne collection
pour les stocker,voici celles que nous connaissons:
- des tableaux
- des listes
- des maps
- des sets
  
D'après le schéma UML ci-dessus, nous allons donc utiliser une `HashMap` 
pour stocker les cases de notre grid :
* Pour rechercher une case et, effectuer des opérations dessus ce sera 
plus facile, la clé de la Map sera une chaine de caractère (String) qui 
représente la coordonnée de cette case (c'est-à-dire la concaténation 
du nom de ligne et de l'indice de la colonne, exemple "A1", "B9", etc...)

Une case peut etre utilisée dans plusieurs autres cases, on ne sait 
pas le nombre d'autres cases où elle sera utilisée, on stockera donc 
cette donée dans une `ArrayList` de `Case`.

Certaines fonctions (`Moyenne`, `Somme`) utilise également une plage de case, pour stocker ces cases,
nous allons également une `ArrayList` de `Case`.

### METHODES ESSENTIELLES EN PSEUDO-JAVA

#### 1. Methode getValeur

```java

class Grid {
  Map<String, Case> cases  = new HashMap<>();
  
  double getValue(String column, int line){
    return cases.getCell(column, line).getValue();
  }
}


class Cell {
  String column;
  int line;
  double value;
  
  double getValue() {
    return value;
  }
}

```


#### 2. Methode getFormuleAsString (acceder au contenu)

```java

class Grid {
  Map<String, Case> cases = new HashMap<>();
  
  String getFormuleAsString(String column, int line) {
    return this.getCell(column, line).toString();
  }
}


class Cell {
  String column;
  int line;
  double value;
  Formula formula;
  
  String getFormuleAsString() {
      if (formula != null) 
          return formula.toString();
      else
          return toString();
  }
}

// Exemple pour Addition
class Addition {
    Cell leftCell;
    Cell rightCell;
    
    String toString() {
        return leftCell.toString() + "+" + rightCell.toString();
    }
}

```


#### 3. Methode getDevelopedFormula

```java
class Grid{
  Map<String, Case> cases  = new HashMap<>();
  
  String getDevelopedFormula(String column, int line) {
    return this.getCell(column,line).getFormuleDeveloppe();
  }
}

class Case{
  String column;
  int line;
  double value;
  Formula formula;
  List<Cell> usedIn = new ArrayList<>(); 
  
  String getDevelopedFormula() {
      if (formula != null)
          return formula.getFormuleDeveoppe();
      else
          return toString();
  }
}

Average
class Average {
    List<Cell> listCases = new ArrayList<Cell>();
    
    String getDevelopedFormula() {
        return Average + listCases.stream().map(c -> c.getFormuleDeveloppe()).collect((Collectors).joining(", ")) + ")";
    }
}

```


#### 4. Methode eval()

- Dans Addition :

```java
class Addition {
  Case gauche;
  Case droite;

  double eval() {
      return gauche.getValeur() + droite.getValeur();
  }
}

```

- Dans Multiplication :

```java
class Multiplication {
  Cell gauche;
  Cell droite;

  double eval() {
      return gauche.getValeur() * droite.getValeur();
  }
}
```


- Dans Soustraction :

```java
class Soustraction {
  Cell gauche;
  Cell droite;

  double eval() {
      return gauche.getValeur() - droite.getValeur();
  }
}

```

- Dans Division :

```java
class Division {
  Cell gauche;
  Cell droite;

  double eval() {
    if (droite.getValeur() != 0)
        return gauche.getValeur() / droite.getValeur();
    else
        lève une exception
  }
}

```

- Dans Moyenne :

```java
class Average {
  List<Cell> listCases = new ArrayList<Cell>(); 

  double eval() {
    double val=0;
  
    if (listCases.size() != 0)
      for(int i=0; i<listCases.size(); i++)
            val += listCases.get(i).getValeur();
      return val / listCases.size();
    else
      lève une exception
  }
}

```
- Dans Somme :

```java
class Sum {
  List<Cell> listCases = new ArrayList<Cell>(); 

  double eval() {
    double val=0;
    if (listCases.size() != 0)
      for(int i=0; i<listCases.size(); i++)
            val += listCases.get(i).getValeur();
      return val;
    else
        lève une exception
  }
}

```

#### 5. Methode setValeur

```java
class Grid {
  Map<String, Case> cases  = new HashMap<>();
  
  void setValeur(String colonne, int ligne, double value) {
    String code = colonne + ligne;
    return cases.get(code).setValeur(value);
  }
}

class Cell {
  String colonne;
  int ligne;
  double valeur;
  Formule formule;
  List<Cell> utiliseDans = new ArrayList<Cell>(); 
  
  void setValeur(double value) {
    valeur = value;
    for(int i=0; i<utiliseDans.size(); i++)
       utiliseDans.get(i).updateValeur();
  }
}

```

#### 5. Methode setFormule

```java
class Grid {
  Map<String, Cell> cases  = new HashMap<>();
  
  void setFormule(String colonne, int ligne, Formule formule) {
    String code = colonne + ligne;
    return cases.get(code).setFormule(formula);
  }
}


class Cell {
  String colonne;
  int ligne;
  double valeur;
  Formule formule;
  List<Cell> utiliseDans = new ArrayList<Cell>();
  
  void updateValeur() {
      valeur = formule.eval();
  }
  
  void setFormule(Formule formula) {
    if (!formula.creerCycle(this))
      formule = formula;
      updateValeur();
      for(int i=0; i<utiliseDans.size(); i++)
        utiliseDans.get(i).updateValeur();
    else
      lève une exception
  }
}

BinaryOperation
class OperationBinaire {
    Cell gauche;
    Cell droite;
    
    boolean creerCycle(Case case) {
        Si la case gauche ne contient pas de formule et la case de droite contient une
          rechercher si la case est dans la formule de la case de droite
          
        Si la case gauche contient une  formule et la case de droite n'en contient pas
          rechercher si la case est dans la formule de la case de gauche
                  
        Si la case gauche et la droite contiennent des formules
          rechercher si la case est dans les deux formule
        
        Si les deux cases n'ont pas de formules
          rechercher si la case est égale à case gauche ou droite
    }
}

Function
class Fonction {
    List<Cell> listCells;
    
    boolean creerCycle(Case case) {
        
        Si la case n'est pas dans listCells
          Pour toute les cases dans listCells qui contiennent des formules, regarder si la case est dans la formule
    }
}

```

### LISTE DE TESTS

Afin de s'assurer de la maintenabilité de notre code et de la qualité de
celui-ci, nous allons réaliser plusieurs tests sur les différentes méthodes
que nous allons programmé dans notre application, voici quelques
exemples :

- Création d'une case avec une valeur fixe
- Création d'une case avec une formule d' `Opération binaire` et une 
fonction comme `Moyenne`
- Modification d'une case avec une valeur sans qu'elle soit utilisée dans
une autre case
- Modification d'une case avec une valeur utilisée dans une autre case
- Vérification qu'une erreur se lève lors de la création des 2 types
de cycles (direct et indirect)
- Renvoie de la formule dévéloppée d'une case avec une formule assez compliqué

## 2. STRUCTURE DU PROJET


### PACKAGES,CLASSES,FICHIERS DE DONNÉES

L'implémentation du projet peut se résumer comme suit :

![PACKAGE](package.png)


Le schéma ci-dessus nous montre que, l'implémentation est composé de 5 package (representant 5 repertoires) contenant des classes ( chaque classe est un fichier d'extension java).

### MODES D'UTILISATION


** Commande de compilation**: 

find src -not \( -path src/kernel/test -prune \) -name \*.java |xargs -i javac -d bin {} -cp src/ 

** Commande d'exécution**: 

java bin/app/Main

## 3. BILAN 

Au cours de ce projet les actions suivantes ont été faites :

### Le noyeau

- La gestion des cycles aussi bien direct qu'indirects.
- La modification d'une case par des valeurs ou des formules et dans ce dernier cas la vérification qu'aucun cycle n'est créée.
- La gestion de la langue (en francais et en anglais).
- De supprimer une case que si elle existe et, n'est pas utilisée par d'autres cases.
- De sérialiser l'état d'une grille après avoir effectué des actions.

### L'interface graphique

L'interface graphique implementée permet d'effectuer les actions suivantes :

- Créer une case à partir de d'une valeure.
- Créer une case en saisissant une formule (aussi bien français qu'en anglais).
   Par exemple, on crée la case A10=SOMME(A1,A2,B2)
   
  ![CASE](rapport_image/case_f.PNG)  
  
  ![CASE](rapport_image/case_fv.PNG)
  
- Emettre une erreur lorsque l'on saisit du texte au lieu d'un double ou une formule incorrecte.
  
  ![CASE](rapport_image/erreur_s.PNG)
- Emettre une erreur indiquant qu'un cycle est généré.
- Emettre une erreur indiquant qu'on ne peut pas supprimer une case utilisé par d'autres cases.
  
  ![CASE](rapport_image/erreur_sup.PNG)

### Les tests

Plusieurs tests ont été réalisés au cours de ce projet notamment celles permettant de :

- Créer une ou plusieurs cases
- Mettre à jour une case avec une valeur ou formule
- Créer une exception lorsqu'un cycle est créee
- Créer une exception lorsqu'on utilise une case pas encore créée
- Effectuer le re-calcul des cases qui dependent d'une case quand elle est modifiée
- Supprimer une case que si elle n'est pas utilisée par d'autres cases


## Conclusion

En résumé, ce projet de programmation par objet (PPO) avait pour but de développer les actions que l'on peut faire avec un classeur Excel usuel.Il était divisé en deux parties :
- La première, créée un noyeau avec differentes méthodes permettant d'effectuer et vérifier des actions comme la création, modification d'une case  avec des valeurs, opérations usuelles ou formules.
- La deuxième, de créer un interface.
Ces deux parties ont été réalisées ainsi que des tests permettant de fonctionner le fonctionnement.
ce projet nous a donc été bénéfique car, il nous a permis de pouvoir mettre en pratique nos connaisances tout en developpant des nouvelles.
Aussi, concernant les améliorations possibles , l'on pourrait envisager de pouvoir ajouter dans l'interface une option permettant de choisir la langue étant donné qu'actuellement l'on fait un choix d'affichage dans une langue et l'utilisateur ne peut la modifier mais, peut rentrer le nom de d'une fonction dans les deux langues, sera fonctionnera.