Model/src/simulator.cpp

   1
   2 #include "simulator.h"
   3
   4 using namespace PlaQui::Model;
   5
   6 Simulator::Simulator(const std::string &filename)
   7 {
   8         /* Parseo de ejemplo de un XML desde archivo */
   9         xmlDocPtr document;
  10         document = xmlParseFile(filename.c_str());
  11         if (document == NULL) {
  12                 return;
  13         }
  14
  15         /* bien, el archivo se parseo bien! */
  16         xmlNodePtr nodo, items;
  17         nodo = document->children;
  18
  19         if (strcmp((char *)nodo->name, "planta") == 0) {
  20                 items = nodo->children;
  21                 while (items != NULL) {
  22                         if (items->type == XML_ELEMENT_NODE) {
  23                                 if (xmlStrcmp(items->name, BAD_CAST"bomba")==0) {
  24                                         loadBomba(items);
  25                                 } else if (xmlStrcmp(items->name, BAD_CAST"codo")==0) {
  26                                         loadCodo(items);
  27                                 } else if (xmlStrcmp(items->name, BAD_CAST"tubo")==0) {
  28                                         loadConduct(items);
  29                                 } else if (xmlStrcmp(items->name, BAD_CAST"exclusa")==0) {
  30                                         loadExclusa(items);
  31                                 } else if (xmlStrcmp(items->name, BAD_CAST"tanque")==0) {
  32                                         loadTank(items);
  33                                 } else if (xmlStrcmp(items->name, BAD_CAST"empalme")==0) {
  34                                         loadUnion(items);
  35                                 }
  36                         }
  37                         items = items->next;
  38                 }
  39         }
  40 }
  41
  42 Simulator::~Simulator()
  43 {
  44         // FIXME REMOVER TODOOOOOO
  45 }
  46
  47 void Simulator::add_pump(const std::string &name)
  48 {
  49         Pump *p = new Pump(name);
  50         // FIXME no va!!
  51         p->set_max_flow(5);
  52         pump_lst.push_back(p);
  53         items.push_back(p);
  54 }
  55
  56 void Simulator::add_union(const std::string &name)
  57 {
  58         Union *u = new Union(name);
  59         // FIXME no va!!
  60         u->set_max_flow(5);
  61         union_lst.push_back(u);
  62         items.push_back(u);
  63 }
  64
  65 void Simulator::add_splitter(const std::string &name)
  66 {
  67         Splitter *p = new Splitter(name);
  68         // FIXME no va!!
  69         p->set_max_flow(5);
  70         split_lst.push_back(p);
  71         items.push_back(p);
  72 }
  73
  74 void Simulator::add_conduct(const std::string &name)
  75 {
  76         Conduct *p = new Conduct(name);
  77         // FIXME no va!!
  78         p->set_max_flow(5);
  79         conduct_lst.push_back(p);
  80         items.push_back(p);
  81 }
  82
  83 void Simulator::add_exclusa(const std::string &name)
  84 {
  85         Exclusa *p = new Exclusa(name);
  86         // FIXME no va!!
  87         exclusa_lst.push_back(p);
  88         items.push_back(p);
  89 }
  90
  91 void Simulator::add_tank(const std::string &name)
  92 {
  93         Tank *p = new Tank(name);
  94         p->set_capacity(100);
  95         p->set_max_flow(10);
  96         p->set_litros(10);
  97         tank_lst.push_back(p);
  98         items.push_back(p);
  99 }
 100
 101 void Simulator::add_drainage(const std::string &name)
 102 {
 103         Drainage *p = new Drainage(name);
 104         // FIXME no va!!
 105         drainage_lst.push_back(p);
 106         items.push_back(p);
 107 }
 108
 109 bool Simulator::connect(const std::string &name1, const std::string &name2, int flag)
 110 {
 111         IConector *o1, *o2;
 112         o1 = find(name1);
 113         o2 = find(name2);
 114
 115         if ((o1 == NULL) || (o2 == NULL)) {
 116                 // NO SE PUDO CONECTAR!, FALTAN ITEMS!!
 117                 return false;
 118         }
 119
 120         bool b;
 121         if (flag == IConector::OUT) {
 122                 b = o1->connect(o2, IConector::OUT);
 123                 b = b && o2->connect(o1, IConector::IN);
 124         } else {
 125                 b = o1->connect(o2, IConector::IN);
 126                 b = b && o2->connect(o1, IConector::OUT);
 127         }
 128
 129         return b;
 130 }
 131
 132 void Simulator::simulate()
 133 {
 134         // Actualizo
 135         std::list<Pump *>::iterator i1;
 136         for(i1=pump_lst.begin(); i1!=pump_lst.end(); i1++)
 137                 (*i1)->update();
 138
 139         // Simulo!
 140         std::list<PlantItem *>::iterator i2;
 141         for(i2=items.begin(); i2!=items.end(); i2++)
 142                 (*i2)->simulate();
 143 }
 144
 145 IConector *Simulator::find(const std::string &name)
 146 {
 147         // Busco el item, aca no me importa de que tipo es!
 148         std::list<PlantItem *>::iterator i;
 149         for(i=items.begin(); i!=items.end(); i++)
 150                 if ((*i)->get_name() == name)
 151                         return *i;
 152         return NULL;
 153 }
 154
 155 bool Simulator::pump_deactivate(const std::string &name)
 156 {
 157         // Busco el elemento, usando RTTI :-(
 158         Pump *pump = dynamic_cast<Pump *>(find(name));
 159
 160         if (!pump) {
 161                 // Ups!, "name" no era un Pump!!!
 162                 return false;
 163         }
 164         pump->deactivate();
 165         return true;
 166 }
 167
 168 void Simulator::loadBomba(xmlNodePtr nodo)
 169 {
 170         std::string name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 171         int orientacion=0, x, y;
 172
 173         nodo = nodo->children;
 174         while (nodo != NULL) {
 175                 if (nodo->type == XML_ELEMENT_NODE) {
 176                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 177                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 178                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 179                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 180                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 181                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 182                         }
 183                 }
 184                 nodo = nodo->next;
 185         }
 186
 187         add_pump(name);
 188 }
 189
 190 void Simulator::loadCodo(xmlNodePtr nodo)
 191 {
 192         std::string name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 193         int orientacion=0, x, y;
 194
 195         nodo = nodo->children;
 196         while (nodo != NULL) {
 197                 if (nodo->type == XML_ELEMENT_NODE) {
 198                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 199                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 200                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 201                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 202                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 203                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 204                         }
 205                 }
 206                 nodo = nodo->next;
 207         }
 208
 209         add_conduct(name);
 210 }
 211
 212 void Simulator::loadConduct(xmlNodePtr nodo)
 213 {
 214         std::string name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 215         int orientacion=0, x, y;
 216
 217         nodo = nodo->children;
 218         while (nodo != NULL) {
 219                 if (nodo->type == XML_ELEMENT_NODE) {
 220                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 221                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 222                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 223                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 224                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 225                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 226                         }
 227                 }
 228                 nodo = nodo->next;
 229         }
 230
 231         // listo, ya recolecte todos los datos, ahora creo el objeto!
 232         add_conduct(name);
 233 }
 234
 235 void Simulator::loadExclusa(xmlNodePtr nodo)
 236 {
 237         std::string name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 238         int orientacion=0, x, y;
 239
 240         nodo = nodo->children;
 241         while (nodo != NULL) {
 242                 if (nodo->type == XML_ELEMENT_NODE) {
 243                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 244                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 245                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 246                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 247                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 248                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 249                         }
 250                 }
 251                 nodo = nodo->next;
 252         }
 253
 254         // listo, ya recolecte todos los datos, ahora creo el objeto!
 255         add_exclusa(name);
 256 }
 257
 258 void Simulator::loadTank(xmlNodePtr nodo)
 259 {
 260         std::string name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 261         int orientacion=0, x, y;
 262
 263         nodo = nodo->children;
 264         while (nodo != NULL) {
 265                 if (nodo->type == XML_ELEMENT_NODE) {
 266                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 267                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 268                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 269                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 270                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 271                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 272                         }
 273                 }
 274                 nodo = nodo->next;
 275         }
 276
 277         // listo, ya recolecte todos los datos, ahora creo el objeto!
 278         add_tank(name);
 279 }
 280
 281 void Simulator::loadUnion(xmlNodePtr nodo)
 282 {
 283         std::string name = (char *)xmlGetProp(nodo, BAD_CAST"nombre");
 284         int orientacion=0, x, y;
 285
 286         nodo = nodo->children;
 287         while (nodo != NULL) {
 288                 if (nodo->type == XML_ELEMENT_NODE) {
 289                         if (xmlStrcmp(nodo->name, BAD_CAST"orientacion") == 0) {
 290                                 orientacion = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 291                         } else if (xmlStrcmp(nodo->name, BAD_CAST"x") == 0) {
 292                                 x = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 293                         } else if (xmlStrcmp(nodo->name, BAD_CAST"y") == 0) {
 294                                 y = atoi( (char *)XML_GET_CONTENT(nodo->children) );
 295                         }
 296                 }
 297                 nodo = nodo->next;
 298         }
 299
 300         // listo, ya recolecte todos los datos, ahora creo el objeto!
 301         add_union(name);
 302 }
 303