Model/include/iconector.h

   1
   2
   3 #ifndef _I_CONECTOR_H_
   4 #define _I_CONECTOR_H_
   5
   6 #include <list>
   7
   8 namespace PlaQui {
   9
  10 namespace Model {
  11 /** Conector genérico de elementos
  12  *
  13  *  El conector es un interfaz común que permite a objetos de distinto
  14  *  tipo comunicarse entre sí sin la necesidad de conocerse.
  15  *  Maneja una lista de elementos conectados a uno, que pueden estar
  16  *  tanto conectados a una entrada como a una salida.
  17  */
  18 class IConector {
  19 public:
  20         /** Constructor
  21          *
  22          *  \param in Cantidad de entradas
  23          *  \param out Cantidad de salidas
  24          */
  25         IConector(unsigned in, unsigned out);
  26         /// Destructor
  27         virtual ~IConector();
  28
  29         /** Envía un mensage a los elementos conectados
  30          *
  31          *  Envía un mensage a los elementos conectados a la entrada o
  32          *  a la salida.
  33          *  \param where Donde enviar el mensage, IConector::IN o IConector::OUT
  34          *  \param msg Mensage a enviar
  35          *  \param data Dato opcional a mandar, según el mensage que se envíe
  36          */
  37         void send_msg(int where, int msg, void *data=NULL);
  38
  39         /** Recibe un mensage
  40          *
  41          *  Este procedimiento atiende los mensages enviados por otros objetos.
  42          *  El mensage \e msg es enviado por \e who, quien puede enviar opcionalmente
  43          *  un dato en \e data. El campo \e data debe ser interpretado en forma
  44          *  correcta dependiendo del mensage enviado.
  45          *  El objeto que recibe un mensage puede, de ser necesario, responder al
  46          *  objeto que lo envió llamando directamente al método recieve_msg del objeto
  47          *  \e who. No se recomienda enviar un mensage mediante send_msg ya que puede
  48          *  ocacionar que objetos que no esten esperando una respuesta se comporte de
  49          *  manera indeterminada.
  50          *  \param msg ID del mensage enviado.
  51          *  \param who Objeto que envía el mensage.
  52          *  \param data Dato opcional a enviar.
  53          */
  54         virtual void recieve_msg(int msg, IConector *who, void *data);
  55
  56         /** Conecta un objeto con otro
  57          *
  58          *  \param place IConector::IN o IConecor::OUT para conectar a la entrada o salida.
  59          *  \param obj Objeto a conectar
  60          *  \return true si se pudo conectar
  61          */
  62         bool connect(IConector *obj, int place);
  63
  64         /// Constantes de posición donde conectar
  65         enum {
  66                 IN=0, ///< conectar a la entrada
  67                 OUT ///< conectar a la salida
  68         };
  69
  70         /** Mensages a este nivel
  71          *
  72          *  Las clases descendientes que quieran definir sus mensajes deben utilizar
  73          *  el valor de IConector::MSG_LAST como valor para el primer msg, a fin
  74          *  de evitar solapamiento de mensajes.
  75          *  Por ejemplo, si tenemos una clase B con un mensaje TEST se declararía
  76          *  como :
  77          *  \code
  78          *      class B:public IConector {
  79          *              enum {
  80          *                      MSG_TEST=IConector::MSG_LAST,
  81          *                      MSG_LAST
  82          *      };
  83          *  \endcode
  84          */
  85         enum {
  86                 MSG_DISCONECT=0, ///< Desconectar el objeto que envía el mensaje
  87                 MSG_LAST
  88         };
  89 protected:
  90         /// Lista de objetos conectados a las entradas
  91         std::list<IConector *> in_list;
  92         /// Lista de objetos conectados a las salidas
  93         std::list<IConector *> out_list;
  94         /// Cantidad de entradas disponibles
  95         unsigned int in_slots;
  96         /// Canitidad de salidas disponibles
  97         unsigned int out_slots;
  98
  99 private:
 100         // Oculto copia entre clases
 101         IConector() {}
 102         IConector(const IConector &) {}
 103         IConector &operator = (const IConector &) { return (*this); }
 104 };
 105
 106 } // namespace Model
 107 } // namespace PlaQui
 108
 109 #endif // _I_CONECTOR_H_
 110