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