Model/include/simulator.h

   1
   2
   3 #ifndef _SIMULADOR_H_
   4 #define _SIMULADOR_H_
   5
   6 #include <list>
   7 #include <string>
   8 #include <sstream>
   9 #include "pump.h"
  10 #include "splitter.h"
  11 #include "union.h"
  12 #include "conduct.h"
  13 #include "tank.h"
  14 #include "exclusa.h"
  15 #include "drainage.h"
  16 #include "iconector.h"
  17 #include "libxml/parser.h"
  18 #include "not.h"
  19 #include "or.h"
  20 #include "and.h"
  21
  22 namespace PlaQui {
  23 namespace Model {
  24
  25 class Simulator {
  26 public:
  27         Simulator(const std::string &filename);
  28         ~Simulator();
  29
  30         void add_pump(const std::string &name, float max_flow, RGB color);
  31         void add_union(const std::string &name, float max_flow);
  32         void add_splitter(const std::string &name, float max_flow);
  33         void add_conduct(const std::string &name, float max_flow);
  34         void add_exclusa(const std::string &name, bool open);
  35         void add_tank(const std::string &name, float capacity, float initial, RGB color);
  36         void add_drainage(const std::string &name);
  37
  38         /** Retorna el estado de todos los items como un XML */
  39         std::string get_state_as_xml();
  40
  41         /** Conecta 2 elementos
  42          *
  43          *  Esta funcion conecta el elemanto name1 con el elemento name2.
  44          *  El parámetro flag define donde se conecta name2 respecto de name1.
  45          *  Es decir, si flag = IConector::OUT, name2 se conecta a la salida de
  46          *  name1
  47          *  \return true si se pudo conectar
  48          */
  49         bool connect(const std::string &name1, const std::string &name2, int flag);
  50
  51         void simulate();
  52
  53         /// Tipos de elementos
  54         enum {PUMP, UNION, SPLITTER, CONDUCT, EXCLUSA, TANK, DRAINAGE};
  55
  56         bool set_open(const std::string &name, bool open = true);
  57
  58         /// Dice si el simulador está simulando una planta
  59         bool is_ok() { return is_load_ok; }
  60 protected:
  61         // Los mantengo en listas separadas para ahorrar
  62         // CPU y no tener que usar dinamic_cast
  63         std::list<Pump *> pump_lst;
  64         std::list<Union *> union_lst;
  65         std::list<Splitter *> split_lst;
  66         std::list<Conduct *> conduct_lst;
  67         std::list<Tank *> tank_lst;
  68         std::list<Drainage *> drainage_lst;
  69         std::list<Exclusa *> exclusa_lst;
  70         std::list<LogicControl *> control_lst;
  71
  72         // Tambien tengo una lista generica!
  73         std::list<PlantItem *> items;
  74
  75         // Utilidades
  76         IConector *find(const std::string &name);
  77         LogicControl *find_logic(const std::string &name);
  78
  79         // Conecta todos los items desde el XML
  80         void do_connections(xmlNodePtr nodo);
  81         void do_logic_connetions(xmlNodePtr nodo);
  82         void connect_logic(LogicControl *current, xmlNodePtr);
  83
  84         // Carga del XML
  85         void loadBomba(xmlNodePtr nodo);
  86         void loadConduct(xmlNodePtr nodo);
  87         void loadExclusa(xmlNodePtr nodo);
  88         void loadTank(xmlNodePtr nodo);
  89         void loadUnion(xmlNodePtr nodo);
  90         void loadDrain(xmlNodePtr nodo);
  91         void loadNot(xmlNodePtr nodo);
  92         void loadOr(xmlNodePtr nodo);
  93         void loadAnd(xmlNodePtr nodo);
  94
  95         RGB loadRGB(xmlNodePtr nodo);
  96
  97         // Frame. Define el orden para los cuadros del XML
  98         unsigned long int frame;
  99         bool is_load_ok;
 100 };
 101
 102 }
 103 }
 104
 105 #endif // _SIMULADOR_H_
 106