Model/src/splitter.cpp

   1
   2 #include "splitter.h"
   3 #include <iostream>
   4
   5 using namespace PlaQui::Model;
   6
   7 Splitter::Splitter(const std::string &_name):Transport(_name)
   8 {
   9         in_slots = 1;
  10         out_slots = 2;
  11         max_flow = actual_flow = 0.0f;
  12         updated = true;
  13         out_on_zero = out_ready = 0;
  14 }
  15
  16 Splitter::~Splitter()
  17 {
  18 }
  19
  20 void Splitter::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                         if (updated) {
  33                                 who->recieve_msg(MSG_RESPONSE_MAX_FLOW, this, &actual_flow);
  34                         }
  35                         // Me preguntan por el flujo máximo.
  36                         // Primero me actualizo, y luego respondo
  37                         float tmp = *((float *)data);
  38
  39                         if (tmp < actual_flow) actual_flow = tmp;
  40
  41                         if (max_flow < actual_flow) actual_flow = max_flow;
  42
  43                         if (out_on_zero == 0)
  44                                 actual_flow /= 2.0f;
  45
  46                         if (actual_flow == 0) {
  47                                 out_ready = 2;
  48                         }
  49                         send_msg(OUT, MSG_QUERY_MAX_FLOW_OUT, &actual_flow);
  50
  51                         // Listo, mi flujo ahora es el doble de lo que me pueden
  52                         // dar las salidas
  53                         actual_flow *= 2.0f;
  54                         who->recieve_msg(MSG_RESPONSE_MAX_FLOW, this, &actual_flow);
  55                         updated = true;
  56                 }
  57                 break;
  58                 case MSG_RESPONSE_MAX_FLOW: {
  59                         float max = *((float *)data);
  60                         if (out_ready == 2) break;
  61 #ifdef DEBUG
  62                         std::cout << name << ":Split " << max << std::endl;
  63 #endif
  64                         if (pos == OUT) {
  65                                 if (max == 0) {
  66                                         out_on_zero++;
  67                                         switch (out_on_zero) {
  68                                                 case 1:
  69                                                         if (out_ready == 0) {
  70                                                                 actual_flow = max_flow;
  71                                                         }
  72                                                 break;
  73                                                 case 2:
  74                                                         actual_flow = 0.0;
  75                                         }
  76                                 } else {
  77                                         if (max < actual_flow)  actual_flow = max;
  78                                         if (max_flow < actual_flow) actual_flow = max_flow;
  79                                 }
  80                                 out_ready++;
  81                         } else {
  82                                         if (((2*max) < actual_flow) && (max != 0))
  83                                                 actual_flow = 2*max;
  84                         }
  85                 }
  86                 break;
  87                 default:
  88                         Transport::recieve_msg(msg, who, data);
  89         }
  90 }
  91
  92 void Splitter::update(int dir)
  93 {
  94         // Si ya me actualice, no lo tengo que hacer de nuevo
  95         if (updated) return;
  96         // Seteo mi actualizar en true para evitar entrar de nuevo
  97         actual_flow = INFINITO;
  98         updated = true;
  99         switch (dir) {
 100                 case IN:
 101                         send_msg(IN, MSG_QUERY_MAX_FLOW_IN, (void *)&max_flow);
 102                 break;
 103                 case OUT:
 104                         send_msg(OUT, MSG_QUERY_MAX_FLOW_OUT, (void *)&max_flow);
 105         }
 106 }
 107
 108 void Splitter::simulate()
 109 {
 110         if (!updated) {
 111                 return;
 112         }
 113
 114 #ifdef DEBUG
 115         std::cout << name << "::Flujo actual = " << actual_flow << std::endl;
 116 #endif
 117         updated = false;
 118         color_updated = false;
 119         out_on_zero = out_ready = 0;
 120 }
 121