Back to index

wims  3.65+svn20090927
NaryOperator2.java
Go to the documentation of this file.
00001 /*
00002 $Id: NaryOperator2.java,v 1.3 2003/02/18 11:48:47 sander Exp $
00003 */
00004 
00005 
00006 /*
00007 Copyright (C) 2001-2002 Mainline Project (I3S - ESSI - CNRS -UNSA)
00008 
00009 This library is free software; you can redistribute it and/or
00010 modify it under the terms of the GNU Lesser General Public
00011 License as published by the Free Software Foundation; either
00012 version 2.1 of the License, or (at your option) any later version.
00013 
00014 This library is distributed in the hope that it will be useful,
00015 but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017 Lesser General Public License for more details.
00018 
00019 You should have received a copy of the GNU Lesser General Public
00020 License along with this library; if not, write to the Free Software
00021 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022 
00023 For further information on the GNU Lesser General Public License,
00024 see: http://www.gnu.org/copyleft/lesser.html
00025 For further information on this library, contact: mainline@essi.fr
00026 */
00027 
00028 
00029 package fr.ove.openmath.jome.model;
00030 
00031 import java.util.*;
00032 import fr.ove.openmath.jome.model.*;
00033 import fr.ove.openmath.jome.model.events.ModelEvent;
00034 
00040 public class NaryOperator2 extends Operator {
00045     private String ending = ")";
00046         
00050     public String getEnding() {
00051         return ending;
00052     }
00053     
00058     public void setEnding(String ending) {
00059         this.ending = ending;
00060     }
00061     
00067     public FormulaTreeStructure insert(FormulaTreeStructure current) {
00068         ModelEvent modelEvent;
00069         
00070         if ((current.getFather() == null) && (current.getNbChildren() == 0)) {
00071             // On est dans ce cas là, seulement au tout début de la saisie de la 
00072             // formule. On est obligé de faire ce test à cause de la multiplication
00073             // implicite avec les parenthèses (Ex: (a+b)c ==> (a+b)*c, dans ce cas là,
00074             // current.getNbChildren() est != de 0)
00075             //On insère directement à la position courante
00076             current.addChild(this);
00077         } 
00078         else if ((current.getAsOperatorPriority() == resourcesManager.getAsOperatorPriority("constantPriorities")) &&
00079             current.isTemplate()) {
00080             // Le cas classique (on va même dire normal !!!)
00081             // La position d'insertion est un template.
00082             // On doit remplacer le template par l'instance courante
00083             int rank = current.getRank();
00084             FormulaTreeStructure father = (FormulaTreeStructure) current.getFather();
00085             father.addChild(this, rank);
00086             father.removeChild(current);
00087         }
00088         else { 
00089            // On est dans aucun des cas précédents, on créé donc une
00090             // multiplication implicite.
00091             current = (new Multiplication()).insert(current);
00092             current = insert(current);
00093             return current;
00094         }
00095         
00096         // Maintenant, on va rajouter un slot comme élément de l'opérateur
00097         Slot aSlot = new Slot();
00098         addChild(aSlot);
00099         aSlot.setNextSlot(this);
00100         
00101         // ...puis un template comme élément de ce slot
00102         VariableOrNumber template = new VariableOrNumber();
00103         aSlot.addChild(template);
00104         
00105         return template;
00106     }
00107     
00112     public FormulaTreeStructure addElement() {
00113         Slot aSlot = new Slot();
00114         addChild(aSlot);
00115         
00116         // ...puis un template comme élément de ce slot
00117         VariableOrNumber template = new VariableOrNumber();
00118         aSlot.addChild(template);
00119         
00120         aSlot.setNextSlot(this);
00121         ((Slot) getChild(getNbChildren()-2)).setNextSlot(template);
00122         
00123         return template;
00124     }
00125     
00129     public String createLinear(String linear) {
00130         FormulaTreeStructure child;
00131         
00132         // Là encore, avec ce genre d'opérateur, la saisie se fait globalement comme la saisie
00133         // d'une fonction. Ex : sum(i=0,n,i^n).
00134         // Ou alors c'est qque chose qui est encadré par des symboles par exemple une liste {1, 2, 3}.
00135         // Donc, l'opérateur est ce qui "ouvre" la syntaxe et l'ending, ce qui "ferme" la syntaxe.        
00136         linear += getTheOperator();
00137         for (int i = 0; i < getNbChildren(); i++) {
00138             child = (FormulaTreeStructure) getChild(i);
00139             if (i == 0)
00140                 linear += child.createLinear(linear);
00141             else {
00142                 linear += "," + child.createLinear(linear);
00143             }
00144         }
00145         return linear + ending;
00146     }
00147 
00151     public String evaluate() {
00152         return "";
00153     }
00154 }