/home/ythoma/docs/math2mat/svn/wp1/framework/m2mGUI/src/m2m/backend/structure/IfThenElse.java

Go to the documentation of this file.

/******************************************************************************
 *                                                                                      IfThenElse
 ******************************************************************************
 * Auteur               : Trolliet Gregory
 * Date                 : 7 avr. 2009
 * Description :
 ******************************************************************************/
package m2m.backend.structure;

import java.util.Vector;

import m2m.backend.buildingblocks.BuildingBlock;
import m2m.backend.utils.XMLUtils;

import org.w3c.dom.Document;
import org.w3c.dom.Node;

public class IfThenElse extends Function {

        private Vector<Element> cond;
        private Vector<Element> bodyTrue;
        private Vector<Element> bodyFalse;

        public IfThenElse() {
                this.setName("ifthen");
                this.cond = new Vector<Element>();
                this.bodyTrue = new Vector<Element>();
                this.bodyFalse = new Vector<Element>();
        }

        public void modifyNumType(BuildingBlock.NumType type) {
                super.modifyNumType(type);
                for(Element e: bodyTrue) {
                        e.modifyNumType(type);
                }
                for(Element e: bodyFalse) {
                        e.modifyNumType(type);
                }
        }

        public String getXmlTagName() {
                return "IfThenElse";
        }

        public boolean insideFromXml(org.w3c.dom.Element el,Function newFunc) {
                super.insideFromXml(el,newFunc);
                
                name=XMLUtils.getTextValue(el,"Name","");
                monitor=XMLUtils.getBoolValue(el,"Monitor",false);

                Node node = el.getFirstChild();
                while(node!=null) {
                        if (node.getNodeName().equalsIgnoreCase("Cond")) {
                                org.w3c.dom.Element inputEl=(org.w3c.dom.Element)node;
                                Node nodeIn = inputEl.getFirstChild().getNextSibling();
                                while(nodeIn!=null) {
                                        if (nodeIn.getNodeType()==org.w3c.dom.Node.ELEMENT_NODE) {
                                                Element element=getElement((org.w3c.dom.Element)nodeIn,newFunc);
                                                if (element!=null)
                                                        cond.add(element);
                                        }
                                        nodeIn=nodeIn.getNextSibling();
                                }
                        }

                        if (node.getNodeName().equalsIgnoreCase("BodyTrue")) {
                                org.w3c.dom.Element inputEl=(org.w3c.dom.Element)node;
                                Node nodeIn = inputEl.getFirstChild().getNextSibling();
                                while(nodeIn!=null) {
                                        if (nodeIn.getNodeType()==org.w3c.dom.Node.ELEMENT_NODE) {
                                                Element element=getElement((org.w3c.dom.Element)nodeIn,newFunc);
                                                if (element!=null)
                                                        bodyTrue.add(element);
                                        }
                                        nodeIn=nodeIn.getNextSibling();
                                }
                        }

                        if (node.getNodeName().equalsIgnoreCase("BodyFalse")) {
                                org.w3c.dom.Element inputEl=(org.w3c.dom.Element)node;
                                if (inputEl!=null)
                                        if (inputEl.getFirstChild()!=null) {
                                                Node nodeIn = inputEl.getFirstChild().getNextSibling();
                                                while(nodeIn!=null) {
                                                        if (nodeIn.getNodeType()==org.w3c.dom.Node.ELEMENT_NODE) {
                                                                Element element=getElement((org.w3c.dom.Element)nodeIn,newFunc);
                                                                if (element!=null)
                                                                        bodyFalse.add(element);
                                                        }
                                                        nodeIn=nodeIn.getNextSibling();
                                                }
                                        }
                                
                        }

                        node=node.getNextSibling();
                }
                return false;
        }
        
        public void insideToXml(org.w3c.dom.Element el,Document dom,boolean shortRef) {
                super.insideToXml(el,dom,shortRef);
                org.w3c.dom.Element condEl=dom.createElement("Cond");
                for(Element e: cond) {
                        condEl.appendChild(e.toXml(dom,false));
                }
                el.appendChild(condEl);
                org.w3c.dom.Element bodyTEl=dom.createElement("BodyTrue");
                for(Element e: bodyTrue) {
                        bodyTEl.appendChild(e.toXml(dom,false));
                }
                el.appendChild(bodyTEl);
                org.w3c.dom.Element bodyFEl=dom.createElement("BodyFalse");
                for(Element e: bodyFalse) {
                        bodyFEl.appendChild(e.toXml(dom,false));
                }
                el.appendChild(bodyFEl);
        }



        @Override
        public Element copy(Function newFunc) {
                IfThenElse newIf=new IfThenElse();
                super.copyTo(newIf,newFunc);
                
                for(Element e : cond)
                        newIf.cond.add((Element)e.copy(newFunc));
                for(Element e : bodyTrue)
                        newIf.bodyTrue.add((Element)e.copy(newFunc));
                for(Element e : bodyFalse)
                        newIf.bodyFalse.add((Element)e.copy(newFunc));
                return newIf;
        }

        public void setBodyTrue(Vector<Element> body) {
                this.bodyTrue = body;
        }

        public Vector<Element> getBodyTrue() {
                return this.bodyTrue;
        }

        public void setBodyFalse(Vector<Element> body) {
                this.bodyFalse = body;
        }

        public Vector<Element> getBodyFalse() {
                return this.bodyFalse;
        }

        public void setCond(Vector<Element> cond) {
                this.cond = cond;
        }

        public Vector<Element> getCond() {
                return this.cond;
        }

        @Override
        public String toString(int level) {
                String s = new String();
                s += tab(level) + "[IfThenElse]\tName: " + this.name;
                s += "\n" + this.toStringParam(level+1);
                s += "\n" + tab(level) + ">>===COND===<<";
                for (Element el : this.cond) {
                        s += "\n" + el.toString(level + 1);
                }
                s += "\n" + tab(level) + ">>===TRUE===<<";
                for (Element el : this.bodyTrue) {
                        s += "\n" + el.toString(level + 1);
                }
                if (!this.bodyFalse.isEmpty()) {
                        s += "\n" + tab(level) + ">>===FALSE==<<";
                        for (Element el : this.bodyFalse) {
                                s += "\n" + el.toString(level + 1);
                        }
                }
                return s;
        }


        @Override
        public String toSchematic(int level, String prefix,
                          String boxFormat, String color) {
                String s = new String();
                int cpt = 0;
                s += super.toSchematic(level, prefix, "box", color);
                if (!this.cond.isEmpty()) {
                        cpt = 0;
                        for (Element el : this.cond) {
                                s += "\n" + el.toSchematic(level, prefix + "_cond_"
                                                  + cpt, "box", GraphParams.defaultColor);
                                s += "\n" + tab(level) + prefix + " -> " + prefix + "_cond_" + cpt;
                                cpt++;
                        }
                }
                if (!this.bodyTrue.isEmpty()) {
                        cpt = 0;
                        for (Element el : this.bodyTrue) {
                                s += "\n" + el.toSchematic(level, prefix + "_bodyTrue_"
                                                  + cpt, "box", GraphParams.defaultColor);
                                s += "\n" + tab(level) + prefix + " -> " + prefix
                                                  + "_bodyTrue_" + cpt + "[label = \"bodyTrue\"]";
                                cpt++;
                        }
                }
                if (!this.bodyFalse.isEmpty()) {
                        cpt = 0;
                        for (Element el : this.bodyFalse) {
                                s += "\n" + el.toSchematic(level, prefix + "_bodyFalse_"
                                                  + cpt, "box", GraphParams.defaultColor);
                                        s += "\n" + tab(level) + prefix + " -> " + prefix
                                                          + "_bodyFalse_" + cpt + "[label = \"bodyFalse\"]";
                                cpt++;
                        }
                }
                return s;
        }

        @Override
        public String toOctave(int level) {
                String sOctave = new String();
                for (Element e : this.cond) {
                        sOctave += e.toOctave(level) + "\n";
                }
                sOctave += tab(level) + "if (";
                if (this.cond.lastElement() instanceof Operation) {
                        sOctave += ((Operation) this.cond.lastElement()).getOutput().firstElement().getName();
                } else if (this.cond.lastElement() instanceof Variable) {
                        sOctave += this.cond.lastElement().getName();
                }
                sOctave += ")\n";
                for (Element e : this.bodyTrue) {
                        sOctave += e.toOctave(level + 1) + "\n";
                }
                if (!this.bodyFalse.isEmpty()) {
                        sOctave += tab(level) + "else\n";
                        for (Element e : this.bodyFalse) {
                                sOctave += e.toOctave(level + 1) + "\n";
                        }
                }
                sOctave += tab(level) + "end";
                return sOctave;
        }
}