# Copyright 2010-2012 Free Software Foundation, Inc.

    ${CMAKE_BINARY_DIR}/gruel/src/swig

    gr_block_gateway

 * Copyright 2004-2012 Free Software Foundation, Inc.

%include "gr_block_gateway.i"

/*

 * Copyright 2011-2012 Free Software Foundation, Inc.

 *

 * This file is part of GNU Radio

 *

 * GNU Radio is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 3, or (at your option)

 * any later version.

 *

 * GNU Radio is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with GNU Radio; see the file COPYING.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street,

 * Boston, MA 02110-1301, USA.

 */

#include <gr_block_gateway.h>

#include <gr_io_signature.h>

#include <iostream>

#include <boost/bind.hpp>

/***********************************************************************

 * Helper routines

 **********************************************************************/

template <typename OutType, typename InType>

void copy_pointers(OutType &out, const InType &in){

    out.resize(in.size());

    for (size_t i = 0; i < in.size(); i++){

        out[i] = (void *)(in[i]);

    }

}

/***********************************************************************

 * The gr_block gateway implementation class

 **********************************************************************/

class gr_block_gateway_impl : public gr_block_gateway{

public:

    gr_block_gateway_impl(

        gr_feval_ll *handler,

        const std::string &name,

        gr_io_signature_sptr in_sig,

        gr_io_signature_sptr out_sig,

        const gr_block_gw_work_type work_type,

        const unsigned factor

    ):

        gr_block(name, in_sig, out_sig),

        _handler(handler),

        _work_type(work_type)

    {

        switch(_work_type){

        case GR_BLOCK_GW_WORK_GENERAL:

            _decim = 1; //not relevant, but set anyway

            _interp = 1; //not relevant, but set anyway

            break;

        case GR_BLOCK_GW_WORK_SYNC:

            _decim = 1;

            _interp = 1;

            this->set_fixed_rate(true);

            break;

        case GR_BLOCK_GW_WORK_DECIM:

            _decim = factor;

            _interp = 1;

            break;

        case GR_BLOCK_GW_WORK_INTERP:

            _decim = 1;

            _interp = factor;

            this->set_output_multiple(_interp);

            break;

        }

    }

    /*******************************************************************

     * Overloads for various scheduler-called functions

     ******************************************************************/

    void forecast(

        int noutput_items,

        gr_vector_int &ninput_items_required

    ){

        switch(_work_type){

        case GR_BLOCK_GW_WORK_GENERAL:

            _message.action = gr_block_gw_message_type::ACTION_FORECAST;

            _message.forecast_args_noutput_items = noutput_items;

            _message.forecast_args_ninput_items_required = ninput_items_required;

            _handler->calleval(0);

            ninput_items_required = _message.forecast_args_ninput_items_required;

            return;

        default:

            unsigned ninputs = ninput_items_required.size();

            for (unsigned i = 0; i < ninputs; i++)

                ninput_items_required[i] = fixed_rate_noutput_to_ninput(noutput_items);

            return;

        }

    }

    int general_work(

        int noutput_items,

        gr_vector_int &ninput_items,

        gr_vector_const_void_star &input_items,

        gr_vector_void_star &output_items

    ){

        switch(_work_type){

        case GR_BLOCK_GW_WORK_GENERAL:

            _message.action = gr_block_gw_message_type::ACTION_GENERAL_WORK;

            _message.general_work_args_noutput_items = noutput_items;

            _message.general_work_args_ninput_items = ninput_items;

            copy_pointers(_message.general_work_args_input_items, input_items);

            _message.general_work_args_output_items = output_items;

            _handler->calleval(0);

            return _message.general_work_args_return_value;

        default:

            int r = work (noutput_items, input_items, output_items);

            if (r > 0) consume_each(r*_decim/_interp);

            return r;

        }

    }

    int work(

        int noutput_items,

        gr_vector_const_void_star &input_items,

        gr_vector_void_star &output_items

    ){

        _message.action = gr_block_gw_message_type::ACTION_WORK;

        _message.work_args_ninput_items = fixed_rate_noutput_to_ninput(noutput_items);

        if (_message.work_args_ninput_items == 0) return -1;

        _message.work_args_noutput_items = noutput_items;

        copy_pointers(_message.work_args_input_items, input_items);

        _message.work_args_output_items = output_items;

        _handler->calleval(0);

        return _message.work_args_return_value;

    }

    int fixed_rate_noutput_to_ninput(int noutput_items){

        return (noutput_items*_decim/_interp) + history() - 1;

    }

    int fixed_rate_ninput_to_noutput(int ninput_items){

        return std::max(0, ninput_items - (int)history() + 1)*_interp/_decim;

    }

    bool start(void){

        _message.action = gr_block_gw_message_type::ACTION_START;

        _handler->calleval(0);

        return _message.start_args_return_value;

    }

    bool stop(void){

        _message.action = gr_block_gw_message_type::ACTION_STOP;

        _handler->calleval(0);

        return _message.stop_args_return_value;

    }

    gr_block_gw_message_type &gr_block_message(void){

        return _message;

    }

private:

    gr_feval_ll *_handler;

    gr_block_gw_message_type _message;

    const gr_block_gw_work_type _work_type;

    unsigned _decim, _interp;

};

boost::shared_ptr<gr_block_gateway> gr_make_block_gateway(

    gr_feval_ll *handler,

    const std::string &name,

    gr_io_signature_sptr in_sig,

    gr_io_signature_sptr out_sig,

    const gr_block_gw_work_type work_type,

    const unsigned factor

){

    return boost::shared_ptr<gr_block_gateway>(

        new gr_block_gateway_impl(handler, name, in_sig, out_sig, work_type, factor)

    );

}

/*

 * Copyright 2011-2012 Free Software Foundation, Inc.

 *

 * This file is part of GNU Radio

 *

 * GNU Radio is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 3, or (at your option)

 * any later version.

 *

 * GNU Radio is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with GNU Radio; see the file COPYING.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street,

 * Boston, MA 02110-1301, USA.

 */

#ifndef INCLUDED_GRBLOCK_GATEWAY_H

#define INCLUDED_GRBLOCK_GATEWAY_H

#include <gr_core_api.h>

#include <gr_block.h>

#include <gr_feval.h>

/*!

 * The work type enum tells the gateway what kind of block to implement.

 * The choices are familiar gnuradio block overloads (sync, decim, interp).

 */

enum gr_block_gw_work_type{

    GR_BLOCK_GW_WORK_GENERAL,

    GR_BLOCK_GW_WORK_SYNC,

    GR_BLOCK_GW_WORK_DECIM,

    GR_BLOCK_GW_WORK_INTERP,

};

/*!

 * Shared message structure between python and gateway.

 * Each action type represents a scheduler-called function.

 */

struct gr_block_gw_message_type{

    enum action_type{

        ACTION_GENERAL_WORK, //dispatch work

        ACTION_WORK, //dispatch work

        ACTION_FORECAST, //dispatch forecast

        ACTION_START, //dispatch start

        ACTION_STOP, //dispatch stop

    };

    action_type action;

    int general_work_args_noutput_items;

    std::vector<int> general_work_args_ninput_items;

    std::vector<void *> general_work_args_input_items; //TODO this should be const void*, but swig cant int cast it right

    std::vector<void *> general_work_args_output_items;

    int general_work_args_return_value;

    int work_args_ninput_items;

    int work_args_noutput_items;

    std::vector<void *> work_args_input_items; //TODO this should be const void*, but swig cant int cast it right

    std::vector<void *> work_args_output_items;

    int work_args_return_value;

    int forecast_args_noutput_items;

    std::vector<int> forecast_args_ninput_items_required;

    bool start_args_return_value;

    bool stop_args_return_value;

};

/*!

 * The gateway block which performs all the magic.

 *

 * The gateway provides access to all the gr_block routines.

 * The methods prefixed with gr_block__ are renamed

 * to class methods without the prefix in python.

 */

class GR_CORE_API gr_block_gateway : virtual public gr_block{

public:

    //! Provide access to the shared message object

    virtual gr_block_gw_message_type &gr_block_message(void) = 0;

    long gr_block__unique_id(void) const{

        return gr_block::unique_id();

    }

    std::string gr_block__name(void) const{

        return gr_block::name();

    }

    unsigned gr_block__history(void) const{

        return gr_block::history();

    }

    void gr_block__set_history(unsigned history){

        return gr_block::set_history(history);

    }

    void gr_block__set_fixed_rate(bool fixed_rate){

        return gr_block::set_fixed_rate(fixed_rate);

    }

    bool gr_block__fixed_rate(void) const{

        return gr_block::fixed_rate();

    }

    void gr_block__set_output_multiple(int multiple){

        return gr_block::set_output_multiple(multiple);

    }

    int gr_block__output_multiple(void) const{

        return gr_block::output_multiple();

    }

    void gr_block__consume(int which_input, int how_many_items){

        return gr_block::consume(which_input, how_many_items);

    }

    void gr_block__consume_each(int how_many_items){

        return gr_block::consume_each(how_many_items);

    }

    void gr_block__produce(int which_output, int how_many_items){

        return gr_block::produce(which_output, how_many_items);

    }

    void gr_block__set_relative_rate(double relative_rate){

        return gr_block::set_relative_rate(relative_rate);

    }

    double gr_block__relative_rate(void) const{

        return gr_block::relative_rate();

    }

    uint64_t gr_block__nitems_read(unsigned int which_input){

        return gr_block::nitems_read(which_input);

    }

    uint64_t gr_block__nitems_written(unsigned int which_output){

        return gr_block::nitems_written(which_output);

    }

    gr_block::tag_propagation_policy_t gr_block__tag_propagation_policy(void){

        return gr_block::tag_propagation_policy();

    }

    void gr_block__set_tag_propagation_policy(gr_block::tag_propagation_policy_t p){

        return gr_block::set_tag_propagation_policy(p);

    }

    void gr_block__add_item_tag(

        unsigned int which_output, const gr_tag_t &tag

    ){

        return gr_block::add_item_tag(which_output, tag);

    }

    void gr_block__add_item_tag(

        unsigned int which_output,

        uint64_t abs_offset,

        const pmt::pmt_t &key,

        const pmt::pmt_t &value,

        const pmt::pmt_t &srcid=pmt::PMT_F

    ){

        return gr_block::add_item_tag(which_output, abs_offset, key, value, srcid);

    }

    std::vector<gr_tag_t> gr_block__get_tags_in_range(

        unsigned int which_input,

        uint64_t abs_start,

        uint64_t abs_end

    ){

        std::vector<gr_tag_t> tags;

        gr_block::get_tags_in_range(tags, which_input, abs_start, abs_end);

        return tags;

    }

    std::vector<gr_tag_t> gr_block__get_tags_in_range(

        unsigned int which_input,

        uint64_t abs_start,

        uint64_t abs_end,

        const pmt::pmt_t &key

    ){

        std::vector<gr_tag_t> tags;

        gr_block::get_tags_in_range(tags, which_input, abs_start, abs_end, key);

        return tags;

    }

};

/*!

 * Make a new gateway block.

 * \param handler the swig director object with callback

 * \param name the name of the block (Ex: "Shirley")

 * \param in_sig the input signature for this block

 * \param out_sig the output signature for this block

 * \param work_type the type of block overload to implement

 * \param factor the decimation or interpolation factor

 * \return a new gateway block

 */

GR_CORE_API boost::shared_ptr<gr_block_gateway> gr_make_block_gateway(

    gr_feval_ll *handler,

    const std::string &name,

    gr_io_signature_sptr in_sig,

    gr_io_signature_sptr out_sig,

    const gr_block_gw_work_type work_type,

    const unsigned factor

);

#endif /* INCLUDED_GRBLOCK_GATEWAY_H */

/*

 * Copyright 2011-2012 Free Software Foundation, Inc.

 *

 * This file is part of GNU Radio

 *

 * GNU Radio is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 3, or (at your option)

 * any later version.

 *

 * GNU Radio is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with GNU Radio; see the file COPYING.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street,

 * Boston, MA 02110-1301, USA.

 */

////////////////////////////////////////////////////////////////////////

// standard includes

////////////////////////////////////////////////////////////////////////

%include <gnuradio.i>

%include <gr_tags.i>

%include <gr_feval.i>

////////////////////////////////////////////////////////////////////////

// block headers

////////////////////////////////////////////////////////////////////////

%{

#include <gr_block_gateway.h>

%}

////////////////////////////////////////////////////////////////////////

// data type support

////////////////////////////////////////////////////////////////////////

%template(int_vector_t) std::vector<int>;

%template(void_star_vector_t) std::vector<void *>;

////////////////////////////////////////////////////////////////////////

// block magic

////////////////////////////////////////////////////////////////////////

GR_SWIG_BLOCK_MAGIC(gr,block_gateway);

%include <gr_block_gateway.h>

    gateway.py

        ${CMAKE_SOURCE_DIR}/gruel/src/python

        ${CMAKE_BINARY_DIR}/gruel/src/swig

# Copyright 2003-2012 Free Software Foundation, Inc.

from gateway import basic_block, sync_block, decim_block, interp_block

#

# Copyright 2011-2012 Free Software Foundation, Inc.

#

# This file is part of GNU Radio

#

# GNU Radio is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 3, or (at your option)

# any later version.

#

# GNU Radio is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with GNU Radio; see the file COPYING.  If not, write to

# the Free Software Foundation, Inc., 51 Franklin Street,

# Boston, MA 02110-1301, USA.

#

import gnuradio_core as gr_core

from gnuradio_core import io_signature, io_signaturev

from gnuradio_core import gr_block_gw_message_type

from gnuradio_core import block_gateway

import numpy

########################################################################

# Magic to turn pointers into numpy arrays

# http://docs.scipy.org/doc/numpy/reference/arrays.interface.html

########################################################################

def pointer_to_ndarray(addr, dtype, nitems):

    class array_like:

        __array_interface__ = {

            'data' : (int(addr), False),

            'typestr' : dtype.base.str,

            'descr' : dtype.base.descr,

            'shape' : (nitems,) + dtype.shape,

            'strides' : None,

            'version' : 3

        }

    return numpy.asarray(array_like()).view(dtype.base)

########################################################################

# Handler that does callbacks from C++

########################################################################

class gateway_handler(gr_core.feval_ll):

    #dont put a constructor, it wont work

    def init(self, callback):

        self._callback = callback

    def eval(self, arg):

        try: self._callback()

        except Exception as ex:

            print("handler caught exception: %s"%ex)

            import traceback; traceback.print_exc()

            raise ex

        return 0

########################################################################

# The guts that make this into a gr block

########################################################################

class gateway_block(object):

    def __init__(self, name, in_sig, out_sig, work_type, factor):

        #ensure that the sigs are iterable dtypes

        def sig_to_dtype_sig(sig):

            if sig is None: sig = ()

            return map(numpy.dtype, sig)

        self.__in_sig = sig_to_dtype_sig(in_sig)

        self.__out_sig = sig_to_dtype_sig(out_sig)

        #cache the ranges to iterate when dispatching work

        self.__in_indexes = range(len(self.__in_sig))

        self.__out_indexes = range(len(self.__out_sig))

        #convert the signatures into gr.io_signatures

        def sig_to_gr_io_sigv(sig):

            if not len(sig): return io_signature(0, 0, 0)

            return io_signaturev(len(sig), len(sig), [s.itemsize for s in sig])

        gr_in_sig = sig_to_gr_io_sigv(self.__in_sig)

        gr_out_sig = sig_to_gr_io_sigv(self.__out_sig)

        #create internal gateway block

        self.__handler = gateway_handler()

        self.__handler.init(self.__gr_block_handle)

        self.__gateway = block_gateway(

            self.__handler, name, gr_in_sig, gr_out_sig, work_type, factor)

        self.__message = self.__gateway.gr_block_message()

        #register gr_block functions

        prefix = 'gr_block__'

        for attr in [x for x in dir(self.__gateway) if x.startswith(prefix)]:

            setattr(self, attr.replace(prefix, ''), getattr(self.__gateway, attr))

        self.pop_msg_queue = lambda: gr_core.gr_block_gw_pop_msg_queue_safe(self.__gateway)

    def to_basic_block(self):

        """

        Makes this block connectable by hier/top block python

        """

        return self.__gateway.to_basic_block()

    def __gr_block_handle(self):

        """

        Dispatch tasks according to the action type specified in the message.

        """

        if self.__message.action == gr_block_gw_message_type.ACTION_GENERAL_WORK:

            self.__message.general_work_args_return_value = self.general_work(

                input_items=[pointer_to_ndarray(

                    self.__message.general_work_args_input_items[i],

                    self.__in_sig[i],

                    self.__message.general_work_args_ninput_items[i]

                ) for i in self.__in_indexes],

                output_items=[pointer_to_ndarray(

                    self.__message.general_work_args_output_items[i],

                    self.__out_sig[i],

                    self.__message.general_work_args_noutput_items

                ) for i in self.__out_indexes],

            )

        elif self.__message.action == gr_block_gw_message_type.ACTION_WORK:

            self.__message.work_args_return_value = self.work(

                input_items=[pointer_to_ndarray(

                    self.__message.work_args_input_items[i],

                    self.__in_sig[i],

                    self.__message.work_args_ninput_items

                ) for i in self.__in_indexes],

                output_items=[pointer_to_ndarray(

                    self.__message.work_args_output_items[i],

                    self.__out_sig[i],

                    self.__message.work_args_noutput_items

                ) for i in self.__out_indexes],

            )

        elif self.__message.action == gr_block_gw_message_type.ACTION_FORECAST:

            self.forecast(

                noutput_items=self.__message.forecast_args_noutput_items,

                ninput_items_required=self.__message.forecast_args_ninput_items_required,

            )

        elif self.__message.action == gr_block_gw_message_type.ACTION_START:

            self.__message.start_args_return_value = self.start()

        elif self.__message.action == gr_block_gw_message_type.ACTION_STOP:

            self.__message.stop_args_return_value = self.stop()

    def forecast(self, noutput_items, ninput_items_required):

        """

        forecast is only called from a general block

        this is the default implementation

        """

        for ninput_item in ninput_items_required:

            ninput_item = noutput_items + self.history() - 1;

        return

    def general_work(self, *args, **kwargs):

        """general work to be overloaded in a derived class"""

        raise NotImplementedError("general work not implemented")

    def work(self, *args, **kwargs):

        """work to be overloaded in a derived class"""

        raise NotImplementedError("work not implemented")

    def start(self): return True

    def stop(self): return True

########################################################################

# Wrappers for the user to inherit from

########################################################################

class basic_block(gateway_block):

    def __init__(self, name, in_sig, out_sig):

        gateway_block.__init__(self,

            name=name,

            in_sig=in_sig,

            out_sig=out_sig,

            work_type=gr_core.GR_BLOCK_GW_WORK_GENERAL,

            factor=1, #not relevant factor

        )

class sync_block(gateway_block):

    def __init__(self, name, in_sig, out_sig):

        gateway_block.__init__(self,

            name=name,

            in_sig=in_sig,

            out_sig=out_sig,

            work_type=gr_core.GR_BLOCK_GW_WORK_SYNC,

            factor=1,

        )

class decim_block(gateway_block):

    def __init__(self, name, in_sig, out_sig, decim):

        gateway_block.__init__(self,

            name=name,

            in_sig=in_sig,

            out_sig=out_sig,

            work_type=gr_core.GR_BLOCK_GW_WORK_DECIM,

            factor=decim,

        )

class interp_block(gateway_block):

    def __init__(self, name, in_sig, out_sig, interp):

        gateway_block.__init__(self,

            name=name,

            in_sig=in_sig,

            out_sig=out_sig,

            work_type=gr_core.GR_BLOCK_GW_WORK_INTERP,

            factor=interp,

        )

#

# Copyright 2011-2012 Free Software Foundation, Inc.

#

# This file is part of GNU Radio

#

# GNU Radio is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 3, or (at your option)

# any later version.

#

# GNU Radio is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with GNU Radio; see the file COPYING.  If not, write to

# the Free Software Foundation, Inc., 51 Franklin Street,

# Boston, MA 02110-1301, USA.

#

from gnuradio import gr, gr_unittest

import pmt #from gruel import pmt

import numpy

class add_2_f32_1_f32(gr.sync_block):

    def __init__(self):

        gr.sync_block.__init__(

            self,

            name = "add 2 f32",

            in_sig = [numpy.float32, numpy.float32],

            out_sig = [numpy.float32],

        )

    def work(self, input_items, output_items):

        output_items[0][:] = input_items[0] + input_items[1]

        return len(output_items[0])

class add_2_fc32_1_fc32(gr.sync_block):

    def __init__(self):

        gr.sync_block.__init__(

            self,

            name = "add 2 fc32",

            in_sig = [numpy.complex64, numpy.complex64],

            out_sig = [numpy.complex64],

        )

    def work(self, input_items, output_items):

        output_items[0][:] = input_items[0] + input_items[1]

        return len(output_items[0])

class convolve(gr.sync_block):

    """

    A demonstration using block history to properly perform a convolution.

    """

    def __init__(self):

        gr.sync_block.__init__(

            self,

            name = "convolve",

            in_sig = [numpy.float32],

            out_sig = [numpy.float32]

        )

        self._taps = [1, 0, 0, 0]

        self.set_history(len(self._taps))

    def work(self, input_items, output_items):

        output_items[0][:] = numpy.convolve(input_items[0], self._taps, mode='valid')

        return len(output_items[0])

class decim2x(gr.decim_block):

    def __init__(self):

        gr.decim_block.__init__(

            self,

            name = "decim2x",

            in_sig = [numpy.float32],

            out_sig = [numpy.float32],

            decim = 2

        )

    def work(self, input_items, output_items):

        output_items[0][:] = input_items[0][::2]

        return len(output_items[0])

class interp2x(gr.interp_block):

    def __init__(self):

        gr.interp_block.__init__(

            self,

            name = "interp2x",

            in_sig = [numpy.float32],

            out_sig = [numpy.float32],

            interp = 2

        )

    def work(self, input_items, output_items):

        output_items[0][1::2] = input_items[0]

        output_items[0][::2] = input_items[0]

        return len(output_items[0])

class tag_source(gr.sync_block):

    def __init__(self):

        gr.sync_block.__init__(

            self,

            name = "tag source",

            in_sig = None,

            out_sig = [numpy.float32],

        )

    def work(self, input_items, output_items):

        num_output_items = len(output_items[0])

        #put code here to fill the output items...

        #make a new tag on the middle element every time work is called

        count = self.nitems_written(0) + num_output_items/2

        key = pmt.pmt_string_to_symbol("example_key")

        value = pmt.pmt_string_to_symbol("example_value")

        self.add_item_tag(0, count, key, value)

        return num_output_items

class tag_sink(gr.sync_block):

    def __init__(self):

        gr.sync_block.__init__(

            self,

            name = "tag sink",

            in_sig = [numpy.float32],

            out_sig = None,

        )

        self.key = None

    def work(self, input_items, output_items):

        num_input_items = len(input_items[0])

        #put code here to process the input items...

        #print all the tags received in this work call

        nread = self.nitems_read(0)

        tags = self.get_tags_in_range(0, nread, nread+num_input_items)

        for tag in tags:

            print tag.offset

            print pmt.pmt_symbol_to_string(tag.key)

            print pmt.pmt_symbol_to_string(tag.value)

            self.key = pmt.pmt_symbol_to_string(tag.key)

        return num_input_items

class fc32_to_f32_2(gr.sync_block):

    def __init__(self):

        gr.sync_block.__init__(

            self,

            name = "fc32_to_f32_2",

            in_sig = [numpy.complex64],

            out_sig = [(numpy.float32, 2)],

        )

    def work(self, input_items, output_items):

        output_items[0][::,0] = numpy.real(input_items[0])

        output_items[0][::,1] = numpy.imag(input_items[0])

        return len(output_items[0])

class test_block_gateway(gr_unittest.TestCase):

    def test_add_f32(self):

        tb = gr.top_block()

        src0 = gr.vector_source_f([1, 3, 5, 7, 9], False)

        src1 = gr.vector_source_f([0, 2, 4, 6, 8], False)

        adder = add_2_f32_1_f32()

        sink = gr.vector_sink_f()

        tb.connect((src0, 0), (adder, 0))

        tb.connect((src1, 0), (adder, 1))

        tb.connect(adder, sink)

        tb.run()

        self.assertEqual(sink.data(), (1, 5, 9, 13, 17))

    def test_add_fc32(self):

        tb = gr.top_block()

        src0 = gr.vector_source_c([1, 3j, 5, 7j, 9], False)

        src1 = gr.vector_source_c([0, 2j, 4, 6j, 8], False)

        adder = add_2_fc32_1_fc32()

        sink = gr.vector_sink_c()

        tb.connect((src0, 0), (adder, 0))

        tb.connect((src1, 0), (adder, 1))

        tb.connect(adder, sink)

        tb.run()

        self.assertEqual(sink.data(), (1, 5j, 9, 13j, 17))

    def test_convolve(self):

        tb = gr.top_block()

        src = gr.vector_source_f([1, 2, 3, 4, 5, 6, 7, 8], False)

        cv = convolve()

        sink = gr.vector_sink_f()

        tb.connect(src, cv, sink)

        tb.run()

        self.assertEqual(sink.data(), (1, 2, 3, 4, 5, 6, 7, 8))

    def test_decim2x(self):

        tb = gr.top_block()

        src = gr.vector_source_f([1, 2, 3, 4, 5, 6, 7, 8], False)

        d2x = decim2x()

        sink = gr.vector_sink_f()

        tb.connect(src, d2x, sink)

        tb.run()

        self.assertEqual(sink.data(), (1, 3, 5, 7))

    def test_interp2x(self):

        tb = gr.top_block()

        src = gr.vector_source_f([1, 3, 5, 7, 9], False)

        i2x = interp2x()

        sink = gr.vector_sink_f()

        tb.connect(src, i2x, sink)

        tb.run()

        self.assertEqual(sink.data(), (1, 1, 3, 3, 5, 5, 7, 7, 9, 9))

    def test_tags(self):

        src = tag_source()

        sink = tag_sink()

        head = gr.head(gr.sizeof_float, 50000) #should be enough items to get a tag through

        tb = gr.top_block()

        tb.connect(src, head, sink)

        tb.run()

        self.assertEqual(sink.key, "example_key")

    def test_fc32_to_f32_2(self):

        tb = gr.top_block()

        src = gr.vector_source_c([1+2j, 3+4j, 5+6j, 7+8j, 9+10j], False)

        convert = fc32_to_f32_2()

        v2s = gr.vector_to_stream(gr.sizeof_float, 2)

        sink = gr.vector_sink_f()

        tb.connect(src, convert, v2s, sink)

        tb.run()

        self.assertEqual(sink.data(), (1, 2, 3, 4, 5, 6, 7, 8, 9, 10))

if __name__ == '__main__':

    gr_unittest.run(test_block_gateway, "test_block_gateway.xml")