* Se agrega el TIP de luca

[z.facultad/75.42/plaqui.git] / Model / include / iconector.h

diff --git a/Model/include/iconector.h b/Model/include/iconector.h
index bbb3c258339db5d4978c168ff229d7e705aa29cc..98455fca00c0fae6564c56fa489b5559f91c0af9 100644 (file)
--- a/Model/include/iconector.h
+++ b/Model/include/iconector.h
@@ -7,27 +7,51 @@
 
 namespace PlaQui {
 
+namespace Model {
 /** Conector genérico de elementos
+ *
+ *  El conector es un interfaz común que permite a objetos de distinto
+ *  tipo comunicarse entre sí sin la necesidad de conocerse.
+ *  Maneja una lista de elementos conectados a uno, que pueden estar
+ *  tanto conectados a una entrada como a una salida.
  */
 class IConector {
 public:
-       /// Constructor
-       IConector();
+       /** Constructor
+        *
+        *  \param in Cantidad de entradas
+        *  \param out Cantidad de salidas
+        */
+       IConector(unsigned in, unsigned out);
        /// Destructor
        virtual ~IConector();
 
        /** Envía un mensage a los elementos conectados
         *
-        *  Esvía un mensage a los elementos conectados a la entrada o
+        *  Envía un mensage a los elementos conectados a la entrada o
         *  a la salida.
         *  \param where Donde enviar el mensage, IConector::IN o IConector::OUT
         *  \param msg Mensage a enviar
-        *  \return Respuesta al mensage. Se interpreta dependiendo del mensage
+        *  \param data Dato opcional a mandar, según el mensage que se envíe
         */
-       int send_msg(int where, int msg);
+       void send_msg(int where, int msg, void *data=NULL);
        
-       /// Recive un mensage
-       virtual void recieve_msg(int msg, IConector *who);
+       /** Recibe un mensage
+        *
+        *  Este procedimiento atiende los mensages enviados por otros objetos.
+        *  El mensage \e msg es enviado por \e who, quien puede enviar opcionalmente
+        *  un dato en \e data. El campo \e data debe ser interpretado en forma
+        *  correcta dependiendo del mensage enviado.
+        *  El objeto que recibe un mensage puede, de ser necesario, responder al
+        *  objeto que lo envió llamando directamente al método recieve_msg del objeto
+        *  \e who. No se recomienda enviar un mensage mediante send_msg ya que puede
+        *  ocacionar que objetos que no esten esperando una respuesta se comporte de
+        *  manera indeterminada.
+        *  \param msg ID del mensage enviado.
+        *  \param who Objeto que envía el mensage.
+        *  \param data Dato opcional a enviar.
+        */
+       virtual void recieve_msg(int msg, IConector *who, void *data);
 
        /** Conecta un objeto con otro
         *
@@ -39,7 +63,7 @@ public:
 
        /// Constantes de posición donde conectar
        enum {
-               IN, ///< conectar a la entrada
+               IN=0, ///< conectar a la entrada
                OUT ///< conectar a la salida
        };
 
@@ -50,25 +74,37 @@ public:
         *  de evitar solapamiento de mensajes.
         *  Por ejemplo, si tenemos una clase B con un mensaje TEST se declararía
         *  como :
-        *  \verbatim
+        *  \code
         *      class B:public IConector {
         *              enum {
         *                      MSG_TEST=IConector::MSG_LAST,
         *                      MSG_LAST
         *      };
-        *  \endverbatim
+        *  \endcode
         */
        enum {
                MSG_DISCONECT=0, ///< Desconectar el objeto que envía el mensaje
                MSG_LAST
        };
 protected:
-       std::list<IConector *> entradas;
-       std::list<IConector *> salidas;
-       unsigned int cant_entradas;
-       unsigned int cant_salidas;
+       /// Lista de objetos conectados a las entradas
+       std::list<IConector *> in_list;
+       /// Lista de objetos conectados a las salidas
+       std::list<IConector *> out_list;
+       /// Cantidad de entradas disponibles
+       unsigned int in_slots;
+       /// Canitidad de salidas disponibles
+       unsigned int out_slots;
+
+private:
+       // Oculto copia entre clases
+       IConector() {}
+       IConector(const IConector &) {}
+       IConector &operator = (const IConector &) { return (*this); }
 };
 
-}
+} // namespace Model
+} // namespace PlaQui
 
 #endif // _I_CONECTOR_H_
+