Server/include/plaqui/server/plant.h

   1 // vim: set noexpandtab tabstop=4 shiftwidth=4:
   2 //----------------------------------------------------------------------------
   3 //                                  PlaQui
   4 //----------------------------------------------------------------------------
   5 // This file is part of PlaQui.
   6 //
   7 // PlaQui is free software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the Free Software
   9 // Foundation; either version 2 of the License, or (at your option) any later
  10 // version.
  11 //
  12 // PlaQui is distributed in the hope that it will be useful, but WITHOUT ANY
  13 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  14 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  15 // details.
  16 //
  17 // You should have received a copy of the GNU General Public License along
  18 // with PlaQui; if not, write to the Free Software Foundation, Inc., 59 Temple
  19 // Place, Suite 330, Boston, MA  02111-1307  USA
  20 //----------------------------------------------------------------------------
  21 // Creado:  sáb nov 15 17:29:44 ART 2003
  22 // Autores: Leandro Lucarella <llucare@fi.uba.ar>
  23 //----------------------------------------------------------------------------
  24 //
  25 // $Id$
  26 //
  27
  28 #ifndef PLAQUI_PLANT_H
  29 #define PLAQUI_PLANT_H
  30
  31 #include "plaqui/server/runnable.h"
  32 #include "plaqui/server/transmitter.h"
  33 #include "simulator.h"
  34 #include <sigc++/signal.h>
  35
  36 namespace PlaQui {
  37
  38 namespace Server {
  39
  40         /// Planta Química.
  41         class Plant: public Runnable {
  42
  43                 /////////////////////////////////////////////////////////////////////
  44                 // Constantes.
  45
  46                 private:
  47
  48                         /// Tiempo por defecto a esperar entre iteraciones de la simulación.
  49                         static const unsigned DEFAULT_WAIT_TIME = 300000u; // 0,3 segundos
  50
  51                 /////////////////////////////////////////////////////////////////////
  52                 // Tipos.
  53
  54                 private:
  55
  56                         /// Lista de conexiones de control.
  57                         typedef std::list<Transmitter*> TransmitterList;
  58
  59                 /////////////////////////////////////////////////////////////////////
  60                 // Atributos.
  61
  62                 private:
  63
  64                         /// Transmisiones del estado de las plantas.
  65                         TransmitterList transmissions;
  66
  67                         /// Mutex para las transmisiones.
  68                         Glib::Mutex transmissions_mutex;
  69
  70                         /// Simulador usado para calcular el estado de la planta.
  71                         Model::Simulator simulator;
  72
  73                         /// Mutex para el simulador.
  74                         Glib::Mutex simulator_mutex;
  75
  76                         /// Nombre del archivo donde esta el XML de la planta.
  77                         std::string filename;
  78
  79                         /// Tiempo que espera entre cada iteración de la simulación.
  80                         unsigned wait_time;
  81
  82                         /// Mutex para el tiempo de espera.
  83                         Glib::Mutex wait_time_mutex;
  84
  85                         /// Indica si la planta está pausada o simulando.
  86                         bool paused;
  87
  88                         /// Mutex para el indicador de pausa.
  89                         Glib::Mutex paused_mutex;
  90
  91                 /////////////////////////////////////////////////////////////////////
  92                 // Métodos.
  93
  94                 protected:
  95
  96                         /**
  97                          * Corre la planta (la monitorea o la simula).
  98                          */
  99                         virtual void real_run(void) throw();
 100
 101                 public:
 102
 103                         /**
 104                          * Destructor.
 105                          */
 106                         virtual ~Plant(void);
 107
 108                         /**
 109                          * Constructor desde un archivo.
 110                          *
 111                          * \param filename Nombre del archivo de donde obtener la planta.
 112                          */
 113                         Plant(const std::string& filename);
 114
 115                         /**
 116                          * Comienza una transmisión del estado de la planta.
 117                          *
 118                          * \return true si comenzó la transmisión, false si hubo problemas.
 119                          */
 120                         bool transmission_start(string& host, Connection::Port& port);
 121
 122                         /**
 123                          * Comienza una transmisión del estado de la planta.
 124                          *
 125                          * \return true si detuvo la transmisión, false si no existía.
 126                          */
 127                         bool transmission_stop(const string& host,
 128                                         const Connection::Port& port);
 129
 130                         /**
 131                          * Borra una transmisión de la lista de transmisiones al finalizar.
 132                          *
 133                          * \param transmission Transmisión a eliminar.
 134                          */
 135                         void on_transmission_finished(Transmitter* transmission);
 136
 137                         /**
 138                          * Abre (o cierra) un elemento de la planta.
 139                          *
 140                          * Sólo la bomba y la exclusa pueden ser abiertos y cerrados.
 141                          *
 142                          * \param element Nombre del elemento a abrir o cerrar.
 143                          * \param open    true si se quiere abrir el elemento, false si se
 144                          *                lo quiere cerrar.
 145                          *
 146                          * \return true si se abrió o cerró el elemento, false si no existía
 147                          *         o si no era una bomba o exclusa.
 148                          */
 149                         bool set_open(const std::string& element, bool open = true);
 150
 151                         /**
 152                          * Setea la frecuencia de refresco de la simulación.
 153                          * Si se setea a cero, se usa el tiempo por omisión.
 154                          *
 155                          * \param hz Cantidad de veces por segundo que debe refrescarse la
 156                          *           simulación.
 157                          */
 158                         void set_frequency(unsigned hz = 0u);
 159
 160                         /**
 161                          * Pausa (o reanuda) la simulación.
 162                          *
 163                          * \param paused true si se la quiere pausar, false para reanudar.
 164                          */
 165                         void set_paused(bool paused = true);
 166
 167                         /**
 168                          * Obtiene el XML de la planta.
 169                          */
 170                         const std::string get_xml(void) const;
 171
 172         };
 173
 174 }
 175
 176 }
 177
 178 #endif // PLAQUI_PLANT_H