1 package fr.ove.openmath.jome.model;
2
3 import java.util.*;
4 import fr.ove.openmath.jome.model.*;
5 import fr.ove.openmath.jome.model.evaluation.*;
6
7 /***
8 * The operator "-", which is the binary substraction.
9 * Because the substraction is defines as the addition of the opposite,
10 * <CODE>@see Substraction</CODE> doesn't represent a node in the formula tree structure.
11 * During its creation, it's in fact a <CODE>@see Addition</CODE> instance which is created
12 * and serves as a node in the formula tree structure, and an <CODE>@see UnaryMinus</CODE>
13 * instance is added as a child.
14 *
15 * @author © 2000 DIRAT Laurent
16 * @version 2.1 10/01/200
17 */
18 public class Substraction extends BinaryOperator {
19 /***
20 * Inserts the operator instance in the formula tree, from the current insertion position.
21 * (checks the priorities and goes up in the tree if necessary).
22 *
23 * @param current the current insertion position.
24 * @return the new insertion position.
25 */
26 public FormulaTreeStructure insert(FormulaTreeStructure current) {
27 // On cherche la position d'insertion de notre "-"
28 current = findLocation(current);
29 int currentAsOperandPriority = current.getAsOperandPriority();
30 int currentAsOperatorPriority = current.getAsOperatorPriority();
31
32 if (currentAsOperatorPriority == getAsOperandPriority()) {
33 // On a dÈj? tapÈ dans la formule un "-", on va donc insÈrer un nouveau
34 // "-" dans le prÈcÈdent ==> cas particuliers.
35 if ((currentAsOperandPriority == resourcesManager.getAsOperandPriority("unaryPlusPriorities")) ||
36 (currentAsOperandPriority == resourcesManager.getAsOperandPriority("unaryMinusPriorities"))) {
37 // Si on est en prÈcense de ce cas l?, la position d'insertion est
38 // sur un op. unaire ("+" ou "-"). Il faut rÈcupÈrer le pËre de l'op.
39 // en question, i.e. une instance d'Addition que l'on a insÈrÈ auparavant
40 // dansla FST.
41 FormulaTreeStructure father = (FormulaTreeStructure) current.getFather();
42
43 // Si notre position d'insertion est un "+" unaire, alors on va l'Èliminer
44 // pour ne garder que son opÈrande. Ainsi, au lieu d'avoir +a-b, on aura a-b.
45 if (currentAsOperandPriority == resourcesManager.getAsOperandPriority("unaryPlusPriorities")) {
46 FormulaTreeStructure operand = (FormulaTreeStructure) current.getChild(0);
47 int rank = current.getRank();
48
49 father.addChild(operand, rank);
50 father.removeChild(current);
51 }
52
53 // On ajoute notre op. "-".
54 // (Rappel : "-" unaire ? cause de la def. de la soustraction)
55 father = (new UnaryMinus()).insert(father);
56
57 // On retourne la refÈrence de notre dernier point d'insertion.
58 return father;
59 }
60
61 // L?, on est dans le cas o? l'on a tapÈ une sÈrie de "+" ou de "-", et donc
62 // la position d'insertion est une instance d'Addition que l'on a insÈrÈ
63 // auparavant dans la FST. (tjrs le mÍme rappel quand aux defs.)
64 current = (new UnaryMinus()).insert(current);
65
66 // On retourne la refÈrence de notre dernier point d'insertion.
67 return current;
68 }
69 else { // PremiËre entrÈe d'une soustraction (et mÍme, aucune addition n'a ÈtÈ
70 // saisie auparavant)
71
72 // On ajoute une instance d'Addition comme fils ? l'opÈrateur courant
73 FormulaTreeStructure addition = new Addition();
74 current.addChild(addition);
75
76 if (current.getNbChildren() > 1) {
77 // Il faut que l'on fasse la distinction entre le fait de vouloir saisir une soustraction
78 // ou un moins unaire.
79 // Donc on vient d'ajouter une instance d'addition ? current.
80 // Si on est l?, 2 solutions, le fils de current qui a pour rank, le rank de
81 // l'instance d'addition -1 :
82 // * est un template ==> on saisi un moins unaire
83 // * n'est pas un template ==> on saisi une soustraction
84 FormulaTreeStructure fts = (FormulaTreeStructure) current.getChild(addition.getRank() - 1);
85
86 // Quelque soit le cas, on enlËve fts de current.
87 // Dans le cas du moins unaire, (fts est un template) un template sera rajoutÈ avec
88 // l'insertion du UnaryMinus
89 // Dans le cas de la soustraction, fts sera ajoutÈ ? l'instance d'addition
90 current.removeChild(fts);
91
92 if (!((fts.getAsOperatorPriority() == resourcesManager.getAsOperatorPriority("constantPriorities")) &&
93 fts.isTemplate())) {
94 // Donc, c'est une soustraction, fts est l'Èlement ? qui on va soustraire qque chose.
95 // On l'ajoute donc comme fils (en fait ce sera la premier) ? l'instance d'addition.
96 addition.addChild(fts);
97 }
98
99 // Par dÈfinition de la soustraction, on ajoute un opÈrateur "-"
100 // unaire comme fils ? l'instance d'Addition.
101 addition = (new UnaryMinus()).insert(addition);
102
103 // On retourne la rÈfÈrence de notre dernier point d'insertion
104 return addition;
105 }
106 else { // on est dans le cas du moins unaire
107 // On ajoute un opÈrateur "-" unaire comme fils ? l'instance d'Addition.
108 addition = (new UnaryMinus()).insert(addition);
109
110 // On retourne la refÈrence de notre dernier point d'insertion.
111 return addition;
112 }
113 }
114 }
115 }