GNU Radio 3.7.1-52 C++ API
block_gateway.h
Go to the documentation of this file.
1 /* -*- c++ -*- */
2 /*
3  * Copyright 2011-2013 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
18  * along with GNU Radio; see the file COPYING. If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street,
20  * Boston, MA 02110-1301, USA.
21  */
22 
23 #ifndef INCLUDED_RUNTIME_BLOCK_GATEWAY_H
24 #define INCLUDED_RUNTIME_BLOCK_GATEWAY_H
25 
26 #include <gnuradio/api.h>
27 #include <gnuradio/block.h>
28 #include <gnuradio/feval.h>
29 
30 namespace gr {
31 
32  /*!
33  * The work type enum tells the gateway what kind of block to
34  * implement. The choices are familiar gnuradio block overloads
35  * (sync, decim, interp).
36  */
42  };
43 
45  TPP_DONT = 0,
48  };
49 
50  /*!
51  * Shared message structure between python and gateway.
52  * Each action type represents a scheduler-called function.
53  */
55  enum action_type {
56  ACTION_GENERAL_WORK, //dispatch work
57  ACTION_WORK, //dispatch work
58  ACTION_FORECAST, //dispatch forecast
59  ACTION_START, //dispatch start
60  ACTION_STOP, //dispatch stop
61  };
62 
64 
67  std::vector<void *> general_work_args_input_items; //TODO this should be const void*, but swig cant int cast it right
68  std::vector<void *> general_work_args_output_items;
70 
73  std::vector<void *> work_args_input_items; //TODO this should be const void*, but swig cant int cast it right
74  std::vector<void *> work_args_output_items;
76 
79 
81 
83  };
84 
85  /*!
86  * The gateway block which performs all the magic.
87  *
88  * The gateway provides access to all the gr::block routines.
89  * The methods prefixed with gr::block__ are renamed
90  * to class methods without the prefix in python.
91  */
92  class GR_RUNTIME_API block_gateway : virtual public gr::block
93  {
94  public:
95  // gr::block_gateway::sptr
97 
98  /*!
99  * Make a new gateway block.
100  * \param handler the swig director object with callback
101  * \param name the name of the block (Ex: "Shirley")
102  * \param in_sig the input signature for this block
103  * \param out_sig the output signature for this block
104  * \param work_type the type of block overload to implement
105  * \param factor the decimation or interpolation factor
106  * \return a new gateway block
107  */
108  static sptr make(gr::feval_ll *handler,
109  const std::string &name,
110  gr::io_signature::sptr in_sig,
111  gr::io_signature::sptr out_sig,
112  const block_gw_work_type work_type,
113  const unsigned factor);
114 
115  //! Provide access to the shared message object
116  virtual block_gw_message_type &block_message(void) = 0;
117 
118  long block__unique_id(void) const {
119  return gr::block::unique_id();
120  }
121 
122  std::string block__name(void) const {
123  return gr::block::name();
124  }
125 
126  unsigned block__history(void) const {
127  return gr::block::history();
128  }
129 
130  void block__set_history(unsigned history) {
131  return gr::block::set_history(history);
132  }
133 
134  void block__set_fixed_rate(bool fixed_rate) {
135  return gr::block::set_fixed_rate(fixed_rate);
136  }
137 
138  bool block__fixed_rate(void) const {
139  return gr::block::fixed_rate();
140  }
141 
142  void block__set_output_multiple(int multiple) {
143  return gr::block::set_output_multiple(multiple);
144  }
145 
146  int block__output_multiple(void) const {
148  }
149 
150  void block__consume(int which_input, int how_many_items) {
151  return gr::block::consume(which_input, how_many_items);
152  }
153 
154  void block__consume_each(int how_many_items) {
155  return gr::block::consume_each(how_many_items);
156  }
157 
158  void block__produce(int which_output, int how_many_items) {
159  return gr::block::produce(which_output, how_many_items);
160  }
161 
162  void block__set_relative_rate(double relative_rate) {
163  return gr::block::set_relative_rate(relative_rate);
164  }
165 
166  double block__relative_rate(void) const {
167  return gr::block::relative_rate();
168  }
169 
170  uint64_t block__nitems_read(unsigned int which_input) {
171  return gr::block::nitems_read(which_input);
172  }
173 
174  uint64_t block__nitems_written(unsigned int which_output) {
175  return gr::block::nitems_written(which_output);
176  }
177 
180  }
181 
184  }
185 
186  void block__add_item_tag(unsigned int which_output,
187  const tag_t &tag)
188  {
189  return gr::block::add_item_tag(which_output, tag);
190  }
191 
192  void block__add_item_tag(unsigned int which_output,
193  uint64_t abs_offset,
194  const pmt::pmt_t &key,
195  const pmt::pmt_t &value,
196  const pmt::pmt_t &srcid=pmt::PMT_F)
197  {
198  return gr::block::add_item_tag(which_output, abs_offset,
199  key, value, srcid);
200  }
201 
202  std::vector<tag_t> block__get_tags_in_range(unsigned int which_input,
203  uint64_t abs_start,
204  uint64_t abs_end)
205  {
206  std::vector<gr::tag_t> tags;
207  gr::block::get_tags_in_range(tags, which_input, abs_start, abs_end);
208  return tags;
209  }
210 
211  std::vector<tag_t> block__get_tags_in_range(unsigned int which_input,
212  uint64_t abs_start,
213  uint64_t abs_end,
214  const pmt::pmt_t &key)
215  {
216  std::vector<gr::tag_t> tags;
217  gr::block::get_tags_in_range(tags, which_input, abs_start, abs_end, key);
218  return tags;
219  }
220 
221  /* Message passing interface */
224  }
225 
228  }
229 
231  gr::basic_block::message_port_pub(port_id, msg);
232  }
233 
235  gr::basic_block::message_port_sub(port_id, target);
236  }
237 
239  gr::basic_block::message_port_unsub(port_id, target);
240  }
241 
244  }
245 
248  }
249 
250  void set_msg_handler_feval(pmt::pmt_t which_port, gr::feval_p *msg_handler)
251  {
252  if(msg_queue.find(which_port) == msg_queue.end()) {
253  throw std::runtime_error("attempt to set_msg_handler_feval() on bad input message port!");
254  }
255  d_msg_handlers_feval[which_port] = msg_handler;
256  }
257 
258  protected:
259  typedef std::map<pmt::pmt_t, feval_p *, pmt::comperator> msg_handlers_feval_t;
261 
262  bool has_msg_handler(pmt::pmt_t which_port)
263  {
264  return (d_msg_handlers_feval.find(which_port) != d_msg_handlers_feval.end());
265  }
266 
267  void dispatch_msg(pmt::pmt_t which_port, pmt::pmt_t msg)
268  {
269  // Is there a handler?
270  if(d_msg_handlers_feval.find(which_port) != d_msg_handlers_feval.end()) {
271  d_msg_handlers_feval[which_port]->calleval(msg); // Yes, invoke it.
272  }
273  else {
274  // Pass to generic dispatcher if not found
275  gr::basic_block::dispatch_msg(which_port, msg);
276  }
277  }
278  };
279 
280 } /* namespace gr */
281 
282 #endif /* INCLUDED_RUNTIME_BLOCK_GATEWAY_H */