git.gag.com Git - debian/gnuradio/blob - mblock/src/lib/mb_port_simple.cc

   1 /* -*- c++ -*- */
   2 /*
   3  * Copyright 2007,2008 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GNU Radio
   6  *
   7  * GNU Radio is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3, or (at your option)
  10  * any later version.
  11  *
  12  * GNU Radio is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <mb_port_simple.h>
  27 #include <mblock/msg_accepter.h>
  28 #include <mblock/exception.h>
  29 #include <mblock/mblock.h>
  30 #include <mb_mblock_impl.h>
  31 #include <assert.h>
  32 #include <mbi_runtime_lock.h>
  33
  34
  35 mb_port_simple::mb_port_simple(mb_mblock *mblock,
  36                                const std::string &port_name,
  37                                const std::string &protocol_class_name,
  38                                bool conjugated,
  39                                mb_port::port_type_t port_type)
  40   : mb_port(mblock, port_name, protocol_class_name, conjugated, port_type),
  41     d_cache_valid(false)
  42 {
  43 }
  44
  45 mb_port_simple::~mb_port_simple()
  46 {
  47   // nop
  48 }
  49
  50 void
  51 mb_port_simple::send(pmt_t signal, pmt_t data, pmt_t metadata, mb_pri_t priority)
  52 {
  53   if (port_type() == mb_port::RELAY)  // Can't send directly to a RELAY port
  54     throw mbe_invalid_port_type(mblock(), mblock()->instance_name(), port_name());
  55
  56   mb_msg_accepter_sptr  accepter = find_accepter(this);
  57   if (accepter)
  58     (*accepter)(signal, data, metadata, priority);
  59 }
  60
  61
  62 mb_msg_accepter_sptr
  63 mb_port_simple::find_accepter(mb_port_simple *start)
  64 {
  65   mb_port_simple        *p = start;
  66   mb_port_simple        *pp = 0;
  67   mb_mblock             *context = 0;
  68   mb_endpoint           peer_ep;
  69   mb_msg_accepter_sptr  r;
  70
  71   if (start->d_cache_valid)
  72     return start->d_cached_accepter;
  73
  74   mbi_runtime_lock      l(p->mblock());
  75
  76   // Set up initial context.
  77
  78   switch(p->port_type()){
  79   case mb_port::INTERNAL:       // binding is in our name space
  80     context = p->mblock();
  81     break;
  82
  83   case mb_port::EXTERNAL:       // binding is in parent's name space
  84     context = p->mblock()->parent();
  85     if (!context)                       // can't be bound if there's no parent
  86       return mb_msg_accepter_sptr();    // not bound
  87     break;
  88
  89   default:
  90     throw std::logic_error("Can't happen: mb_port_simple::find_accepter [1]");
  91   }
  92
  93
  94  traverse:
  95
  96   if (!context->impl()->lookup_other_endpoint(p, &peer_ep))
  97     return mb_msg_accepter_sptr();      // not bound
  98
  99   pp = dynamic_cast<mb_port_simple *>(peer_ep.port().get());    // peer port
 100   assert(pp);
 101
 102   switch (pp->port_type()){
 103   case mb_port::INTERNAL:       // Terminate here.
 104   case mb_port::EXTERNAL:
 105     r = pp->make_accepter();
 106
 107     // cache the result
 108
 109     start->d_cached_accepter = r;
 110     start->d_cache_valid = true;
 111     return r;
 112
 113   case mb_port::RELAY:          // Traverse to other side of relay port.
 114     if (peer_ep.inside_of_relay_port_p()){
 115       // We're on inside of relay port, headed out.
 116       p = pp;
 117       context = p->mblock()->parent();
 118
 119       // Corner case: we're attempting to traverse a relay port on the border
 120       // of the top block...
 121       if (!context)
 122         return mb_msg_accepter_sptr();  // not bound
 123
 124       goto traverse;
 125     }
 126     else {
 127       // We're on the outside of relay port, headed in.
 128       p = pp;
 129       context = p->mblock();
 130       goto traverse;
 131     }
 132     break;
 133
 134   default:
 135     throw std::logic_error("Can't happen: mb_port_simple::find_accepter [2]");
 136   }
 137 }
 138
 139
 140 mb_msg_accepter_sptr
 141 mb_port_simple::make_accepter()
 142 {
 143   return d_mblock->impl()->make_accepter(port_symbol());
 144 }
 145
 146 void
 147 mb_port_simple::invalidate_cache()
 148 {
 149   d_cache_valid = false;
 150   d_cached_accepter.reset();
 151 }