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

Go to the documentation of this file.

/******************************************************************************
 *                                                                                      LoopFor
 ******************************************************************************
 * Auteur               : Trolliet Gregory
 * Date                 : 4 mars 2009
 * Description :
 ******************************************************************************/
package m2m.backend.structure;

import java.util.Vector;

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

public class LoopFor extends Function {

        private SimpleVariable start;
        private SimpleVariable incr;
        private SimpleVariable end;
        private Vector<SimpleVariable> loopVariables;
        private Operation iterOperation;
        

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


        public boolean insideFromXml(org.w3c.dom.Element el,Function newFunc) {
                super.insideFromXml(el,newFunc);
                
                Node node = el.getFirstChild();
                while(node!=null) {
                        if (node.getNodeName().equalsIgnoreCase("Start")) {
                                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,this);
                                                if (element!=null)
                                                        start=(SimpleVariable)element;
                                        }
                                        nodeIn=nodeIn.getNextSibling();
                                }
                        }

                        if (node.getNodeName().equalsIgnoreCase("Incr")) {
                                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,this);
                                                if (element!=null)
                                                        incr=(SimpleVariable)element;
                                        }
                                        nodeIn=nodeIn.getNextSibling();
                                }
                        }

                        if (node.getNodeName().equalsIgnoreCase("End")) {
                                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,this);
                                                if (element!=null)
                                                        end=(SimpleVariable)element;
                                        }
                                        nodeIn=nodeIn.getNextSibling();
                                }
                        }

                        if (node.getNodeName().equalsIgnoreCase("IterOp")) {
                                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,this);
                                                if (element!=null)
                                                        iterOperation=(Operation)element;
                                        }
                                        nodeIn=nodeIn.getNextSibling();
                                }
                        }

                        node=node.getNextSibling();
                }
                return false;
        }
        
        public void insideToXml(org.w3c.dom.Element el,Document dom,boolean shortRef) {
                // This function replaces the one of Function, so we call Element instead
                // of function
//              superInsideToXml(el,dom,shortRef);
                super.insideToXml(el, dom, shortRef);
                
                org.w3c.dom.Element startEl=dom.createElement("Start");
                startEl.appendChild(start.toXml(dom,false));
                el.appendChild(startEl);
                org.w3c.dom.Element incrEl=dom.createElement("Incr");
                incrEl.appendChild(incr.toXml(dom,false));
                el.appendChild(incrEl);
                org.w3c.dom.Element endEl=dom.createElement("End");
                endEl.appendChild(end.toXml(dom,false));
                el.appendChild(endEl);
                org.w3c.dom.Element iterEl=dom.createElement("IterOp");
                iterEl.appendChild(iterOperation.toXml(dom,false));
                el.appendChild(iterEl);
        }

        public LoopFor() {
                this.setName("loopfor");
                this.start = new SimpleVariable("", 1.0);
                this.incr = new SimpleVariable("", 1.0);
                this.end = new SimpleVariable("", 1.0);
        }
        

        @Override
        public Element copy(Function newFunc) {
                LoopFor newLoop=new LoopFor();
                super.copyTo(newLoop,newFunc);
                newLoop.start = (SimpleVariable)this.start.copy(newFunc);
                newLoop.incr = (SimpleVariable)this.incr.copy(newFunc);
                newLoop.end = (SimpleVariable)this.end.copy(newFunc);
                return newLoop;
        }

        public void setStart(SimpleVariable start) {
                this.start = start;
        }

        public SimpleVariable getStart() {
                return this.start;
        }

        public void setIncr(SimpleVariable incr) {
                this.incr = incr;
        }

        public SimpleVariable getIncr() {
                return this.incr;
        }

        public void setEnd(SimpleVariable end) {
                this.end = end;
        }

        public SimpleVariable getEnd() {
                return this.end;
        }
        
        public void setLoopVariables(Vector<SimpleVariable> vector) {
                loopVariables = vector;
        }
        
        public Vector<SimpleVariable> getLoopVariables() {
                return loopVariables;
        }

        public void setIterOperation(Operation op) {
                iterOperation = op;
        }
        
        public Operation getIterOperation() {
                return iterOperation;   
        }
        
        @Override
        public String toString(int level) {
                String s = new String();
                s += tab(level) + "[LoopFor]\tName: " + this.name;
                s += "\tInterval: ";
                if (this.start.getType().equals("const")) {
                        s += this.start.getVal();
                } else {
                        s += this.start.getName();
                }
                s += " -> ";
                if (this.incr.getType().equals("const")) {
                        s += this.incr.getVal();
                } else {
                        s += this.incr.getName();
                }
                s += " -> ";
                if (this.end.getType().equals("const")) {
                        s += this.end.getVal();
                } else {
                        s += this.end.getName();
                }
                s += "\n" + this.toStringParam(level + 1);
                s += "\n" + tab(level) + ">>==========<<";
                for (Element el : this.body) {
                        s += "\n" + el.toString(level + 1);
                }
                return s;
        }


        @Override
        public String toSchematic(int level, String prefix, String boxFormat, String color) {
                String s = new String();
                s += super.toSchematic(level, prefix, "box", color);
                s += this.start.toSchematic(level, prefix + "_start", "box", GraphParams.loopIndColor);
                s += "\n" + tab(level) + prefix + " -> " + prefix + "_start [label = \"start\"]";
                s += this.incr.toSchematic(level, prefix + "_incr", "box", GraphParams.loopIndColor);
                s += "\n" + tab(level) + prefix + " -> " + prefix + "_incr [label = \"incr\"]";
                s += this.end.toSchematic(level, prefix + "_end", "box", GraphParams.loopIndColor);
                s += "\n" + tab(level) + prefix + " -> " + prefix + "_end [label = \"end\"]";
                return s;
        }

        @Override
        public String toOctave(int level) {
                String sOctave = new String();
                sOctave += tab(level) + "for ";
                sOctave += this.internalVars.firstElement().getName() + "=";
                sOctave += ((this.start.getType().equals("const")) ? this.start.getVal() : this.start.getName());
                sOctave += ":" + ((this.incr.getType().equals("const")) ? this.incr.getVal() : this.incr.getName());
                sOctave += ":" + ((this.end.getType().equals("const")) ? this.end.getVal() : this.end.getName()) + "\n";
                /*if (this.output.size() == 1) {
                if (this.output.firstElement() instanceof SimpleVariable) {
                sOctave += this.output.firstElement().getName();
                }
                } else {
                sOctave += "[";
                boolean first = true;
                for (Element e : this.output) {
                if (e instanceof SimpleVariable) {
                sOctave += ((first) ? "" : ", ") + e.getName();
                first = false;
                }
                }
                sOctave += "]";
                }
                sOctave += "=" + this.getName() + "(";
                boolean first = true;
                for (Element e : this.input) {
                if (e instanceof SimpleVariable) {
                sOctave += ((first) ? "" : ", ") + e.getName();
                first = false;
                }
                }
                sOctave += ")\n";*/
                for (Element e : this.body) {
                        sOctave += e.toOctave(level + 1) + "\n";
                }
                sOctave += tab(level) + "endfor;";
                return sOctave;
        }
        
        
        public SimpleVariable getLoopVariable(SimpleVariable var) 
        {       
                for(Element e : body) {
                        if(e instanceof IfThenElse && e.getName().contains("loopfor"))
                                if(((IfThenElse)e).getOutput().firstElement().equals(var))
                                        return ((SimpleVariable)((Assignment)((IfThenElse)e).getBodyFalse().firstElement()).getInputAt(0));
                }
                        
                return null;
        }
        
        public SimpleVariable getInitVariable(SimpleVariable var) 
        {       
                for(Element e : body) {
                        if(e instanceof IfThenElse && e.getName().contains("loopfor"))
                                if(((IfThenElse)e).getOutput().firstElement().equals(var))
                                        return ((SimpleVariable)((Assignment)((IfThenElse)e).getBodyTrue().firstElement()).getInputAt(0));
                }
                        
                return null;
        }
}