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

Go to the documentation of this file.

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

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Vector;

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

import org.w3c.dom.*;

public class Function extends Element {

        protected Vector<Element> inputVars;
        protected Vector<Element> outputVars;
        protected Vector<Element> internalVars;
        protected Vector<Element> body;
        protected int maxCost;
        protected int maxRelativeCost;
        
        public Function() {
                this.inputVars = new Vector<Element>();
                this.outputVars = new Vector<Element>();
                this.internalVars = new Vector<Element>();
                this.body = new Vector<Element>();
        }
        
        public void modifyNumType(BuildingBlock.NumType type) {
                for(Element e: body) {
                        e.modifyNumType(type);
                }
        }
        
        public String getXmlTagName() {
                return "Function";
        }

        public boolean fromXml(org.w3c.dom.Element el) {
                insideFromXml(el,this);
                return true;
                /*
                NodeList nl = el.getElementsByTagName("Function");
                if(nl != null && nl.getLength() > 0) {
                        org.w3c.dom.Element e = (org.w3c.dom.Element)nl.item(0);
                        if (e!=null) {
                                return insideFromXml(el);
                        }
                }
                return false;
                */
        }
        
        
        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);

                if (name.isEmpty())
                        return true;
                
                Node node = el.getFirstChild();
                while(node!=null) {
                        if (node.getNodeName().equalsIgnoreCase("Input")) {
                                org.w3c.dom.Element inputEl=(org.w3c.dom.Element)node;
                                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)
                                                                inputVars.add(element);
                                                }
                                                nodeIn=nodeIn.getNextSibling();
                                        }
                                }
                        }

                        if (node.getNodeName().equalsIgnoreCase("Output")) {
                                org.w3c.dom.Element inputEl=(org.w3c.dom.Element)node;
                                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)
                                                                outputVars.add(element);
                                                }
                                                nodeIn=nodeIn.getNextSibling();
                                        }
                                }
                        }

                        if (node.getNodeName().equalsIgnoreCase("Internals")) {
                                org.w3c.dom.Element inputEl=(org.w3c.dom.Element)node;
                                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)
                                                                internalVars.add(element);
                                                }
                                                nodeIn=nodeIn.getNextSibling();
                                        }
                                }
                        }

                        if (node.getNodeName().equalsIgnoreCase("Body")) {
                                org.w3c.dom.Element inputEl=(org.w3c.dom.Element)node;
                                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,this);
                                                        if (element!=null)
                                                                body.add(element);
                                                }
                                                nodeIn=nodeIn.getNextSibling();
                                        }
                                }
                        }
                        node=node.getNextSibling();
                }
                return false;
        }
        
        
        public void superInsideToXml(org.w3c.dom.Element el,Document dom,boolean shortRef) {
                super.insideToXml(el,dom,shortRef);
        }
        
        public void insideToXml(org.w3c.dom.Element el,Document dom,boolean shortRef) {
                super.insideToXml(el,dom,shortRef);
                org.w3c.dom.Element inputEl=dom.createElement("Input");
                for(Element e: inputVars) {
                        inputEl.appendChild(e.toXml(dom,false));
                }
                el.appendChild(inputEl);
                org.w3c.dom.Element outputEl=dom.createElement("Output");
                for(Element e: outputVars) {
                        outputEl.appendChild(e.toXml(dom,false));
                }
                el.appendChild(outputEl);
                org.w3c.dom.Element statEl=dom.createElement("Internals");
                for(Element e: internalVars) {
                        statEl.appendChild(e.toXml(dom,false));
                }
                el.appendChild(statEl);
                org.w3c.dom.Element bodyEl=dom.createElement("Body");
                for(Element e: body) {
                        bodyEl.appendChild(e.toXml(dom,true));
                }
                el.appendChild(bodyEl);
        }

        @Override
        public Element copy(Function newFunc) {
                Function fcopy=new Function();
                copyTo(fcopy,fcopy);
                return fcopy;
        }
        
        public void copyTo(Element to, Function newFunc) {
                Function fcopy=(Function) to;
                super.copyTo(fcopy,newFunc);

                for(Element e : inputVars)
                        fcopy.inputVars.add((Element)e.copy(newFunc));
                for(Element e : outputVars)
                        fcopy.outputVars.add((Element)e.copy(newFunc));
                for(Element e : internalVars)
                        fcopy.internalVars.add((Element)e.copy(newFunc));
                for(Element e : body)
                        fcopy.body.add((Element)e.copy(newFunc));
        }
        
        public Element findElement(String name) {
                for(Element e : inputVars)
                        if (e.getName().equals(name))
                                return e;
                for(Element e : outputVars)
                        if (e.getName().equals(name))
                                return e;
                for(Element e : internalVars)
                        if (e.getName().equals(name))
                                return e;
                for(Element e : body)
                        if (e.findElement(name)!=null)
                                return e.findElement(name);
                return null;
        }
        
        public void modifAllNames(String prefix) {

                this.setName(prefix+this.getName());
                for(Element e : inputVars)
                        e.setName(prefix+e.getName());
                for(Element e : outputVars)
                        e.setName(prefix+e.getName());
                for(Element e : internalVars)
                        e.setName(prefix+e.getName());
                for(Element e : body)
                        e.setName(prefix+e.getName());
        }
        

        public void addInput(Element var) {
                this.inputVars.add(var);
        }

        public void setInput(Vector<Element> in) {
                this.inputVars = in;
        }

        public Vector<Element> getInput() {
                return this.inputVars;
        }

        public void addOutput(Element var) {
                this.outputVars.add(var);
        }

        public void setOutput(Vector<Element> out) {
                this.outputVars = out;
        }

        public Vector<Element> getOutput() {
                return this.outputVars;
        }

        public void addInternalVar(Element var) {
                this.internalVars.add(var);
        }

        public void setInternalVars(Vector<Element> list) {
                this.internalVars = list;
        }

        public Vector<Element> getInternalVars() {
                return this.internalVars;
        }

        public Vector<Element> getMonitoringElement() 
        {
                /* Use to get all nodes */
                Element element;
                LinkedList<Element> tempElementList = new LinkedList<Element>();
                Iterator<Element> iterElement;
                Vector<Element> elementList = new Vector<Element>();
                
                /* Initialize the nodes list and the node iterator */
                tempElementList.addAll(getBody());
                
                for(Element e : getInternalVars())
                        if(e.getMonitor() && !elementList.contains(e))
                                elementList.add(e);
                        
                /* Get all the node and connection inside the schema */
                iterElement = tempElementList.iterator();
                while (iterElement.hasNext()) 
                {
                        element = iterElement.next();
                                        
                        /* Check if the node has children */
                        if(element instanceof Function) 
                        {
                                tempElementList.addAll(((Function)element).getBody());
                                for(Element e : ((Function)element).getInternalVars())
                                        if(e.getMonitor() && !elementList.contains(e))
                                                elementList.add(e);
                        }

                        tempElementList.remove(tempElementList.indexOf(element));
                        iterElement = tempElementList.iterator();       
                }
                
                return elementList;
        }
        
        
        public void addBody(Element el) {
                this.body.add(el);
        }

        public void addBody(Vector<Element> vec) {
                this.body.addAll(vec);
        }

        public void addBodyToTop(Element el) {
                this.body.add(0, el);
        }

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

        public Vector<Element> getBody() {
                return this.body;
        }

        @Override
        public String toString(int level) {
                String s = new String();
                s += tab(level) + "[Function]\tName: " + this.name;
                s += "\n" + this.toStringParam(level + 1);
                s += "\n" + tab(level) + ">>==========<<";
                for (Element el : this.body) {
                        s += "\n" + el.toString(level + 1);
                }
                return s;
        }

        protected String toStringParam(int level) {
                String s = new String();
                boolean first = true;
                if (!this.inputVars.isEmpty()) {
                        first = false;
                        s += tab(level) + "Input:";
                        for (Element el : this.inputVars) {
                                s += "\n" + el.toString(level + 1);
                        }
                }
                if (!this.outputVars.isEmpty()) {
                        if (!first) {
                                s += "\n";
                        }
                        first = false;
                        s += tab(level) + "Output:";
                        for (Element el : this.outputVars) {
                                s += "\n" + el.toString(level + 1);
                        }
                }
                if (!this.internalVars.isEmpty()) {
                        if (!first) {
                                s += "\n";
                        }
                        first = false;
                        s += tab(level) + "Internal:";
                        for (Element el : this.internalVars) {
                                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;
                if (prefix.isEmpty()) {
                        prefix = "top";
                }
                if (color.isEmpty()) {
                        color = GraphParams.defaultColor;
                }
                s += tab(level) + prefix + "[shape = " + boxFormat + ", label = \""
                                  + this.getName() + "\" color=\"" + color + "\" style=\"filled\"]";
                if (!this.inputVars.isEmpty()) {
                        cpt = 0;
                        for (Element var : this.inputVars) {
                                s += var.toSchematic(level, prefix + "_i_" + cpt,
                                                  GraphParams.inputShape, GraphParams.inputColor);
                                s += "\n" + tab(level) + prefix + " -> " + prefix + "_i_" + cpt;
                                cpt++;
                        }
                }
                if (!this.outputVars.isEmpty()) {
                        cpt = 0;
                        for (Element var : this.outputVars) {
                                s += var.toSchematic(level, prefix + "_o_" + cpt,
                                                  GraphParams.outputShape,
                                                  GraphParams.outputColor);
                                s += "\n" + tab(level) + prefix + " -> " + prefix + "_o_" + cpt;
                                cpt++;
                        }
                }
                if (!this.internalVars.isEmpty()) {
                        cpt = 0;
                        for (Element var : this.internalVars) {
                                s += var.toSchematic(level, prefix + "_s_" + cpt,
                                                  GraphParams.internalShape,
                                                  GraphParams.internalColor);
                                s += "\n" + tab(level) + prefix + " -> " + prefix + "_s_" + cpt;
                                cpt++;
                        }
                }
                if (!this.body.isEmpty()) {
                        cpt = 0;
                        for (Element el : this.body) {
                                s += "\n" + el.toSchematic(level, prefix + "_" + cpt, "box",
                                                  GraphParams.defaultColor);
                                s += "\n" + tab(level) + prefix + " -> " + prefix + "_" + cpt;
                                cpt++;
                        }
                }
                return s;
        }

        @Override
        public String toOctave(int level) {
                String sOctave = new String();
                sOctave += tab(level) + "function ";
                if (this.outputVars.size() == 1) {
                        if (this.outputVars.firstElement() instanceof SimpleVariable) {
                                sOctave += this.outputVars.firstElement().getName();
                        }
                } else {
                        sOctave += "[";
                        boolean first = true;
                        for (Element e : this.outputVars) {
                                if (e instanceof SimpleVariable) {
                                        sOctave += ((first) ? "" : ", ") + e.getName();
                                        first = false;
                                }
                        }
                        sOctave += "]";
                }
                sOctave += "=" + this.getName() + "(";
                boolean first = true;
                for (Element e : this.inputVars) {
                        if (e instanceof SimpleVariable) {
                                sOctave += ((first) ? "" : ", ") + e.getName();
                                first = false;
                        }
                }
                
                if(getMonitoringElement().size() != 0)
                {
                        sOctave += ", i_m2m_regen)\n";
                        sOctave += "global interns;\n";
                }
                else
                        sOctave += ")\n";
                
                for (Element e : this.body) {
                        sOctave += e.toOctave(level + 1) + "\n";
                }
                sOctave += tab(level) + "endfunction;";
                return sOctave;
        }
        
        
        public boolean isInput(Element element)
        {
                if(element instanceof SimpleVariable){
                        String trueName = StructTreatment.getTrueName(element.getName());
                        for(Element e : getInput()) {
                                if(e.getName().equals(trueName))
                                        return true;
                        }
                }
                
                return false;
        }
        
        
        public boolean containsOuputName(String name)
        {
                for(Element e : outputVars)
                        if(e.getName().equals(name))
                                return true;
                
                return false;
        }
        
        
        public boolean containsInputName(String name)
        {
                for(Element e : outputVars)
                        if(e.getName().equals(name))
                                return true;
                
                return false;
        }
        
        
        public void setMaxCost(int cost) {
                maxCost = cost;
        }
        
        
        public int getMaxCost(){
                return maxCost;
        }
        
        
        public void setRelativeMaxCost() {
                int tmpMaxCost = 0;
                for(Element e : inputVars) {
                        tmpMaxCost = tmpMaxCost < ((SimpleVariable)e).getCost() ? ((SimpleVariable)e).getCost() : tmpMaxCost;
                }
                maxRelativeCost = maxCost-tmpMaxCost+1;
        }
        
        
        public int getRelativeMaxCost(){
                return maxRelativeCost;
        }
}