Model/src/union.cpp

   1
   2 #include "union.h"
   3 #include <iostream>
   4
   5 using namespace PlaQui::Model;
   6
   7 Union::Union(const std::string &_name):Transport(_name)
   8 {
   9         in_slots = 2;
  10         out_slots = 1;
  11         max_flow = actual_flow = 0.0f;
  12         in_on_zero = 0;
  13         in_ready = 0;
  14 }
  15
  16 Union::~Union()
  17 {
  18 }
  19
  20 void Union::recieve_msg(int msg, IConector *who, void *data)
  21 {
  22         int pos = OUT;
  23
  24         // Verifico si esta conectado a mi entrada
  25         std::list<IConector *>::iterator i;
  26         for(i=in_list.begin(); i!=in_list.end(); i++) {
  27                 if ((*i) == who) pos = IN;
  28         }
  29
  30         switch (msg) {
  31                 case MSG_QUERY_MAX_FLOW_OUT: {
  32                         // Me preguntan por el flujo máximo.
  33                         // Primero me actualizo, y luego respondo
  34                         float m_data =  *((float *)data)*2;
  35
  36                         if (m_data == 0) {
  37                                 in_on_zero++;
  38                         }
  39
  40                         float tmp;
  41                         switch (in_on_zero) {
  42                                 case 0:
  43                                         actual_flow = (m_data<max_flow)?m_data:max_flow;
  44                                 break;
  45                                 case 1:
  46                                         actual_flow = max_flow/2.0f;
  47                                 break;
  48                                 case 2:
  49                                         actual_flow = 0;
  50                         }
  51                         send_msg(OUT, MSG_QUERY_MAX_FLOW_OUT, &actual_flow);
  52
  53                         // FIXME hay que resolver el problema de avisar a las
  54                         // entradas el flujo correcto que deben enviar
  55                         tmp = (in_on_zero==0)?actual_flow/2.0f:actual_flow;
  56                         who->recieve_msg(MSG_RESPONSE_MAX_FLOW, this, &tmp);
  57                         updated = true;
  58                 }
  59                 break;
  60                 case MSG_RESPONSE_MAX_FLOW: {
  61                         float max = *((float *)data);
  62                         if (pos == OUT) {
  63                                 if (max < actual_flow)  actual_flow = max;
  64                         } else {
  65                                         if (((2*max) < actual_flow) && (max != 0))
  66                                                 actual_flow = 2*max;
  67                         }
  68                 }
  69                 break;
  70                 default:
  71                         Transport::recieve_msg(msg, who, data);
  72         }
  73 }
  74
  75 void Union::update(int dir)
  76 {
  77         // Si ya me actualice, no lo tengo que hacer de nuevo
  78         if (updated) return;
  79         // Seteo mi actualizar en true para evitar entrar de nuevo
  80 //      actual_flow = 99999;
  81         updated = true;
  82         switch (dir) {
  83                 case IN:
  84                         send_msg(IN, MSG_QUERY_MAX_FLOW_IN, (void *)&max_flow);
  85                 break;
  86                 case OUT:
  87                         send_msg(OUT, MSG_QUERY_MAX_FLOW_OUT, (void *)&max_flow);
  88         }
  89 }
  90
  91 void Union::simulate()
  92 {
  93         if (!updated) {
  94                 return;
  95         }
  96
  97         std::cout << name << "::Flujo actual = " << actual_flow << std::endl;
  98         updated = false;
  99         actual_flow = 99999;
 100         in_on_zero = 0;
 101         in_ready = 0;
 102 }
 103