El modelo ya carga el XML completo, completo (todos los items y sos

 propiedades) y ademas carga de forma correcta las conexiones de
 toooodddooossss los items y genera un modelo funcional y que simula :-)

 Esto es un paso importante, ya que si ahora sacamos el modelo entre hoy y
 mañana ya tenemos el TP terminado, salvando detalles y bugs que aparezcan.

diff --git a/Model/include/iconector.h b/Model/include/iconector.h
index d4e2465dfb9dfeb44b4366033e42c6501ddb8659..2abcbfe0f4bb5977c5da9ac0ac66a72657916091 100644 (file)
--- a/Model/include/iconector.h
+++ b/Model/include/iconector.h
@@ -63,7 +63,7 @@ public:
 
        /// Constantes de posición donde conectar
        enum {
-               IN, ///< conectar a la entrada
+               IN=0, ///< conectar a la entrada
                OUT ///< conectar a la salida
        };
 

diff --git a/Model/include/plantitem.h b/Model/include/plantitem.h
index 880864136b2f6084cb23a99564c169eca6a9728d..5c3e76272a391dada76347618e06d3d546287ea4 100644 (file)
--- a/Model/include/plantitem.h
+++ b/Model/include/plantitem.h
@@ -47,9 +47,9 @@ public:
        virtual void simulate() = 0;
 
        /// Setea el nuevo color del fluido
-       void setColor(const RGB &c) { fluid_color = c; }
+       void set_color(const RGB &c) { fluid_color = c; }
        /// Retorna el actual color del fluido
-       const RGB &getColor() { return fluid_color; }
+       const RGB &get_color() { return fluid_color; }
 
        /** Recive un mensage y lo procesa
         *  

diff --git a/Model/include/simulator.h b/Model/include/simulator.h
index cb86d15b869a33234b408e8d9a641157dbfb3242..cd68c051ae4caf51dfc65a48147ed79de81edc4e 100644 (file)
--- a/Model/include/simulator.h
+++ b/Model/include/simulator.h
@@ -24,12 +24,12 @@ public:
        Simulator(const std::string &filename);
        ~Simulator();
 
-       void add_pump(const std::string &name);
-       void add_union(const std::string &name);
-       void add_splitter(const std::string &name);
-       void add_conduct(const std::string &name);
-       void add_exclusa(const std::string &name);
-       void add_tank(const std::string &name);
+       void add_pump(const std::string &name, float max_flow, RGB color);
+       void add_union(const std::string &name, float max_flow);
+       void add_splitter(const std::string &name, float max_flow);
+       void add_conduct(const std::string &name, float max_flow);
+       void add_exclusa(const std::string &name, bool open);
+       void add_tank(const std::string &name, float capacity, float initial, RGB color);
        void add_drainage(const std::string &name);
 
        /** Retorna el estado de todos los items como un XML */
@@ -68,13 +68,16 @@ protected:
        // Utilidades
        IConector *find(const std::string &name);
 
+       // Conecta todos los items desde el XML
+       void do_connections(xmlNodePtr nodo);
+
        // Carga del XML
        void loadBomba(xmlNodePtr nodo);
-       void loadCodo(xmlNodePtr nodo);
        void loadConduct(xmlNodePtr nodo);
        void loadExclusa(xmlNodePtr nodo);
        void loadTank(xmlNodePtr nodo);
        void loadUnion(xmlNodePtr nodo);
+       void loadDrain(xmlNodePtr nodo);
 
        // Frame. Define el orden para los cuadros del XML
        unsigned long int frame;

diff --git a/Model/src/conduct.cpp b/Model/src/conduct.cpp
index 63cd7e953638a03d5fff4895a165d87b55b3b81d..02fe3a66d2899874266c3c1d6f2f5d4bc37b15f2 100644 (file)
--- a/Model/src/conduct.cpp
+++ b/Model/src/conduct.cpp
@@ -53,7 +53,7 @@ void Conduct::update(int dir)
        // Si ya me actualice, no lo tengo que hacer de nuevo
        if (updated) return;
        // Seteo mi actualizar en true para evitar entrar de nuevo
-//     actual_flow = 99999;
+       actual_flow = 99999;
        updated = true;
        switch (dir) {
                case IN:
@@ -67,12 +67,12 @@ void Conduct::update(int dir)
 void Conduct::simulate()
 {
        if (!updated) {
+               std::cout << name << "::sin actualizar!" << std::endl;
                return;
        }
 
        std::cout << name << "::Flujo actual = " << actual_flow << std::endl;
        updated = false;
-       actual_flow = 99999;
 }
 
 void Conduct::get_state_as_xml(std::stringstream &out)

diff --git a/Model/src/simulator.cpp b/Model/src/simulator.cpp
index 3f432b930a519544607f652cec36f12265de5ca5..3c81d341b708f82eb1d2b4d93d4f7eecd26408b7 100644 (file)
--- a/Model/src/simulator.cpp
+++ b/Model/src/simulator.cpp
@@ -23,9 +23,7 @@ Simulator::Simulator(const std::string &filename)
                        if (items->type == XML_ELEMENT_NODE) {
                                if (xmlStrcmp(items->name, BAD_CAST"bomba")==0) {
                                        loadBomba(items);
-                               } else if (xmlStrcmp(items->name, BAD_CAST"codo")==0) {
-                                       loadCodo(items);
-                               } else if (xmlStrcmp(items->name, BAD_CAST"tubo")==0) {
+                               } else if ((xmlStrcmp(items->name, BAD_CAST"tubo")==0)||(xmlStrcmp(items->name, BAD_CAST"codo")==0)) {
                                        loadConduct(items);
                                } else if (xmlStrcmp(items->name, BAD_CAST"exclusa")==0) {
                                        loadExclusa(items);
@@ -33,10 +31,14 @@ Simulator::Simulator(const std::string &filename)
                                        loadTank(items);
                                } else if (xmlStrcmp(items->name, BAD_CAST"empalme")==0) {
                                        loadUnion(items);
+                               } else if (xmlStrcmp(items->name, BAD_CAST"drenaje")==0) {
+                                       loadDrain(items);
                                }
                        }
                        items = items->next;
                }
+               // Bien, la planta esta cargada, conectemos todo!!
+               do_connections(nodo->children);
        }
 }
 
@@ -45,56 +47,58 @@ Simulator::~Simulator()
        // FIXME REMOVER TODOOOOOO
 }
 
-void Simulator::add_pump(const std::string &name)
+void Simulator::add_pump(const std::string &name, float max_flow, RGB color)
 {
        Pump *p = new Pump(name);
        // FIXME no va!!
-       p->set_max_flow(5);
+       p->set_max_flow(max_flow);
+       p->set_color(color);
        pump_lst.push_back(p);
        items.push_back(p);
 }
 
-void Simulator::add_union(const std::string &name)
+void Simulator::add_union(const std::string &name, float max_flow)
 {
        Union *u = new Union(name);
        // FIXME no va!!
-       u->set_max_flow(5);
+       u->set_max_flow(max_flow);
        union_lst.push_back(u);
        items.push_back(u);
 }
 
-void Simulator::add_splitter(const std::string &name)
+void Simulator::add_splitter(const std::string &name, float max_flow)
 {
        Splitter *p = new Splitter(name);
-       // FIXME no va!!
-       p->set_max_flow(5);
+       p->set_max_flow(max_flow);
        split_lst.push_back(p);
        items.push_back(p);
 }
 
-void Simulator::add_conduct(const std::string &name)
+void Simulator::add_conduct(const std::string &name, float flujo)
 {
        Conduct *p = new Conduct(name);
        // FIXME no va!!
-       p->set_max_flow(5);
+       p->set_max_flow(flujo);
        conduct_lst.push_back(p);
        items.push_back(p);
 }
 
-void Simulator::add_exclusa(const std::string &name)
+void Simulator::add_exclusa(const std::string &name, bool open)
 {
        Exclusa *p = new Exclusa(name);
-       // FIXME no va!!
+       if (!open)
+               p->close();
        exclusa_lst.push_back(p);
        items.push_back(p);
 }
 
-void Simulator::add_tank(const std::string &name)
+void Simulator::add_tank(const std::string &name, float capacity, float initial, RGB color)
 {
        Tank *p = new Tank(name);
-       p->set_capacity(100);
-       p->set_max_flow(10);
-       p->set_litros(10);
+       p->set_capacity(capacity);
+       p->set_max_flow(initial);
+       p->set_litros(initial);
+       p->set_color(color);
        tank_lst.push_back(p);
        items.push_back(p);
 }
@@ -102,7 +106,6 @@ void Simulator::add_tank(const std::string &name)
 void Simulator::add_drainage(const std::string &name)
 {
        Drainage *p = new Drainage(name);
-       // FIXME no va!!
        drainage_lst.push_back(p);
        items.push_back(p);
 }
@@ -172,6 +175,8 @@ void Simulator::loadBomba(xmlNodePtr nodo)
 {
        std::string name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
        int orientacion=0, x, y;
+       RGB color;
+       float flujo;
 
        nodo = nodo->children;
        while (nodo != NULL) {
@@ -182,18 +187,24 @@ void Simulator::loadBomba(xmlNodePtr nodo)
                                x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
                        } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
                                y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
+                       } else if (xmlStrcmp(nodo->name, BAD_CAST"entrega") == 0) {
+                               flujo = atof( (char *)XML_GET_CONTENT(nodo->children) );
+                       } else if (xmlStrcmp(nodo->name, BAD_CAST"color") == 0) {
+                               // FIXME !
+                               color = RGB();
                        }
                }
                nodo = nodo->next;
        }
 
-       add_pump(name);
+       add_pump(name, flujo, color);
 }
 
-void Simulator::loadCodo(xmlNodePtr nodo)
+void Simulator::loadConduct(xmlNodePtr nodo)
 {
        std::string name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
        int orientacion=0, x, y;
+       float flujo;
 
        nodo = nodo->children;
        while (nodo != NULL) {
@@ -204,18 +215,24 @@ void Simulator::loadCodo(xmlNodePtr nodo)
                                x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
                        } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
                                y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
+                       } else if (xmlStrcmp(nodo->name, BAD_CAST"caudal") == 0) {
+                               flujo = atof( (char *)XML_GET_CONTENT(nodo->children) );
                        }
+                       
+
                }
                nodo = nodo->next;
        }
 
-       add_conduct(name);
+       // listo, ya recolecte todos los datos, ahora creo el objeto!
+       add_conduct(name, flujo);
 }
 
-void Simulator::loadConduct(xmlNodePtr nodo)
+void Simulator::loadExclusa(xmlNodePtr nodo)
 {
        std::string name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
        int orientacion=0, x, y;
+       std::string open;
 
        nodo = nodo->children;
        while (nodo != NULL) {
@@ -226,19 +243,23 @@ void Simulator::loadConduct(xmlNodePtr nodo)
                                x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
                        } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
                                y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
+                       } else if (xmlStrcmp(nodo->name, BAD_CAST"estado") == 0) {
+                               open = (char *)XML_GET_CONTENT(nodo->children);
                        }
                }
                nodo = nodo->next;
        }
 
        // listo, ya recolecte todos los datos, ahora creo el objeto!
-       add_conduct(name);
+       add_exclusa(name, open == "1");
 }
 
-void Simulator::loadExclusa(xmlNodePtr nodo)
+void Simulator::loadTank(xmlNodePtr nodo)
 {
        std::string name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
        int orientacion=0, x, y;
+       float capacidad, inicial;
+       RGB color; // TODO
 
        nodo = nodo->children;
        while (nodo != NULL) {
@@ -249,19 +270,25 @@ void Simulator::loadExclusa(xmlNodePtr nodo)
                                x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
                        } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
                                y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
+                       } else if (xmlStrcmp(nodo->name, BAD_CAST"capacidad") == 0) {
+                               capacidad = atoi( (char *)XML_GET_CONTENT(nodo->children) );
+                       } else if (xmlStrcmp(nodo->name, BAD_CAST"inicial") == 0) {
+                               inicial = atof( (char *)XML_GET_CONTENT(nodo->children) );
                        }
                }
                nodo = nodo->next;
        }
 
        // listo, ya recolecte todos los datos, ahora creo el objeto!
-       add_exclusa(name);
+       add_tank(name, capacidad, inicial, color);
 }
 
-void Simulator::loadTank(xmlNodePtr nodo)
+void Simulator::loadUnion(xmlNodePtr nodo)
 {
        std::string name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
        int orientacion=0, x, y;
+       float flow;
+       std::string type;
 
        nodo = nodo->children;
        while (nodo != NULL) {
@@ -272,39 +299,101 @@ void Simulator::loadTank(xmlNodePtr nodo)
                                x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
                        } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
                                y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
+                       } else if (xmlStrcmp(nodo->name, BAD_CAST"caudal") == 0) {
+                               flow = atof( (char *)XML_GET_CONTENT(nodo->children) );
+                       } else if (xmlStrcmp(nodo->name, BAD_CAST"tipo") == 0) {
+                               type = (char *)XML_GET_CONTENT(nodo->children);
                        }
                }
                nodo = nodo->next;
        }
 
        // listo, ya recolecte todos los datos, ahora creo el objeto!
-       add_tank(name);
+       if (type == "union")
+               add_union(name, flow);
+       else
+               add_splitter(name, flow);
 }
 
-void Simulator::loadUnion(xmlNodePtr nodo)
+void Simulator::loadDrain(xmlNodePtr nodo)
 {
        std::string name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
-       int orientacion=0, x, y;
 
-       nodo = nodo->children;
+       add_drainage(name);
+}
+
+void Simulator::do_connections(xmlNodePtr nodo)
+{
+       // Intengo conectar los elementos :)
+       IConector *current_item, *to_connect;
+       xmlNodePtr props; // propiedades del item actual
+       xmlNodePtr conector1, conector2;
+
        while (nodo != NULL) {
-               if (nodo->type == XML_ELEMENT_NODE) {
-                       if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
-                               orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
-                       } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
-                               x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
-                       } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
-                               y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
+               if (nodo->type != XML_ELEMENT_NODE) {
+                       nodo = nodo->next;
+                       continue;
+               }
+               // obtengo el items actual por su nombre
+               current_item = find((char *)xmlGetProp(nodo, BAD_CAST"nombre"));
+               props = nodo->children;
+               conector2 = conector1 = NULL;
+               while (props != NULL) {
+                       if (nodo->type == XML_ELEMENT_NODE) {
+                               if (xmlStrcmp(props->name, BAD_CAST"conector") == 0) {
+                                       xmlNodePtr temp = props->children;
+                                       while ((temp != NULL) && (conector1 == NULL))
+                                               if (temp->type == XML_ELEMENT_NODE) {
+                                                       conector1 = temp;
+                                                       temp = temp->next;
+                                                       break;
+                                               } else {
+                                                       temp = temp->next;
+                                               }
+                                       while ((temp != NULL) && (conector2 == NULL))
+                                               if (temp->type == XML_ELEMENT_NODE) {
+                                                       conector2 = temp;
+                                                       temp = temp->next;
+                                                       break;
+                                               } else {
+                                                       temp = temp->next;
+                                               }
+                               }
+                       }
+                       props = props->next;
+               }
+               // Bien, conector1 y 2 deberian estar apuntando a <entrada> y/o <salida>
+               if (conector1 != NULL) {
+                       // si, aca hay un conector!, veamos cual es
+                       if (xmlStrcmp(conector1->name, BAD_CAST"entrada") == 0) {
+                               // bien, es a la entrada!, obtengo el item al cual lo tengo que conectar
+                               to_connect = find((char *)XML_GET_CONTENT(conector1->children));
+                               // y lo conecto
+                               current_item->connect(to_connect, IConector::IN);
+                       } else if (xmlStrcmp(conector1->name, BAD_CAST"salida") == 0) {
+                               // Era a salida, es casi lo mismo que arriba 
+                               to_connect = find((char *)XML_GET_CONTENT(conector1->children));
+                               current_item->connect(to_connect, IConector::OUT);
+                       }
+               }
+               if (conector2 != NULL) {
+                       // si, aca hay un conector!, veamos cual es
+                       if (xmlStrcmp(conector2->name, BAD_CAST"entrada") == 0) {
+                               // bien, es a la entrada!, obtengo el item al cual lo tengo que conectar
+                               to_connect = find((char *)XML_GET_CONTENT(conector2->children));
+                               // y lo conecto
+                               current_item->connect(to_connect, IConector::IN);
+                       } else if (xmlStrcmp(conector2->name, BAD_CAST"salida") == 0) {
+                               // Era a salida, es casi lo mismo que arriba 
+                               to_connect = find((char *)XML_GET_CONTENT(conector2->children));
+                               current_item->connect(to_connect, IConector::OUT);
                        }
                }
                nodo = nodo->next;
        }
-
-       // listo, ya recolecte todos los datos, ahora creo el objeto!
-       add_union(name);
+       // Fin de las conexiones
 }
 
-
 std::string Simulator::get_state_as_xml()
 {
        std::stringstream out;