# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.5
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.





from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_blocks_swig1', [dirname(__file__)])
        except ImportError:
            import _blocks_swig1
            return _blocks_swig1
        if fp is not None:
            try:
                _mod = imp.load_module('_blocks_swig1', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _blocks_swig1 = swig_import_helper()
    del swig_import_helper
else:
    import _blocks_swig1
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0



def _swig_setattr_nondynamic_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr



def high_res_timer_now():
    """high_res_timer_now() -> gr::high_res_timer_type"""
    return _blocks_swig1.high_res_timer_now()

def high_res_timer_now_perfmon():
    """high_res_timer_now_perfmon() -> gr::high_res_timer_type"""
    return _blocks_swig1.high_res_timer_now_perfmon()

def high_res_timer_tps():
    """high_res_timer_tps() -> gr::high_res_timer_type"""
    return _blocks_swig1.high_res_timer_tps()

def high_res_timer_epoch():
    """high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _blocks_swig1.high_res_timer_epoch()
class skiphead(object):
    """Proxy of C++ gr::blocks::skiphead class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(itemsize, nitems_to_skip):
        """make(size_t itemsize, uint64_t nitems_to_skip) -> skiphead_sptr"""
        return _blocks_swig1.skiphead_make(itemsize, nitems_to_skip)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig1.delete_skiphead
    __del__ = lambda self: None
skiphead_swigregister = _blocks_swig1.skiphead_swigregister
skiphead_swigregister(skiphead)

def skiphead_make(itemsize, nitems_to_skip):
    """skiphead_make(size_t itemsize, uint64_t nitems_to_skip) -> skiphead_sptr"""
    return _blocks_swig1.skiphead_make(itemsize, nitems_to_skip)

class stream_mux(object):
    """Proxy of C++ gr::blocks::stream_mux class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(itemsize, lengths):
        """make(size_t itemsize, std::vector< int,std::allocator< int > > const & lengths) -> stream_mux_sptr"""
        return _blocks_swig1.stream_mux_make(itemsize, lengths)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig1.delete_stream_mux
    __del__ = lambda self: None
stream_mux_swigregister = _blocks_swig1.stream_mux_swigregister
stream_mux_swigregister(stream_mux)

def stream_mux_make(itemsize, lengths):
    """stream_mux_make(size_t itemsize, std::vector< int,std::allocator< int > > const & lengths) -> stream_mux_sptr"""
    return _blocks_swig1.stream_mux_make(itemsize, lengths)

class stream_to_streams(object):
    """Proxy of C++ gr::blocks::stream_to_streams class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(itemsize, nstreams):
        """make(size_t itemsize, size_t nstreams) -> stream_to_streams_sptr"""
        return _blocks_swig1.stream_to_streams_make(itemsize, nstreams)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig1.delete_stream_to_streams
    __del__ = lambda self: None
stream_to_streams_swigregister = _blocks_swig1.stream_to_streams_swigregister
stream_to_streams_swigregister(stream_to_streams)

def stream_to_streams_make(itemsize, nstreams):
    """stream_to_streams_make(size_t itemsize, size_t nstreams) -> stream_to_streams_sptr"""
    return _blocks_swig1.stream_to_streams_make(itemsize, nstreams)

class stream_to_tagged_stream(object):
    """Proxy of C++ gr::blocks::stream_to_tagged_stream class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(itemsize, vlen, packet_len, len_tag_key):
        """make(size_t itemsize, int vlen, unsigned int packet_len, std::string const & len_tag_key) -> stream_to_tagged_stream_sptr"""
        return _blocks_swig1.stream_to_tagged_stream_make(itemsize, vlen, packet_len, len_tag_key)

    make = staticmethod(make)

    def set_packet_len(self, packet_len):
        """set_packet_len(stream_to_tagged_stream self, unsigned int packet_len)"""
        return _blocks_swig1.stream_to_tagged_stream_set_packet_len(self, packet_len)


    def set_packet_len_pmt(self, packet_len):
        """set_packet_len_pmt(stream_to_tagged_stream self, unsigned int packet_len)"""
        return _blocks_swig1.stream_to_tagged_stream_set_packet_len_pmt(self, packet_len)

    __swig_destroy__ = _blocks_swig1.delete_stream_to_tagged_stream
    __del__ = lambda self: None
stream_to_tagged_stream_swigregister = _blocks_swig1.stream_to_tagged_stream_swigregister
stream_to_tagged_stream_swigregister(stream_to_tagged_stream)

def stream_to_tagged_stream_make(itemsize, vlen, packet_len, len_tag_key):
    """stream_to_tagged_stream_make(size_t itemsize, int vlen, unsigned int packet_len, std::string const & len_tag_key) -> stream_to_tagged_stream_sptr"""
    return _blocks_swig1.stream_to_tagged_stream_make(itemsize, vlen, packet_len, len_tag_key)

class stream_to_vector(object):
    """Proxy of C++ gr::blocks::stream_to_vector class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(itemsize, nitems_per_block):
        """make(size_t itemsize, size_t nitems_per_block) -> stream_to_vector_sptr"""
        return _blocks_swig1.stream_to_vector_make(itemsize, nitems_per_block)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig1.delete_stream_to_vector
    __del__ = lambda self: None
stream_to_vector_swigregister = _blocks_swig1.stream_to_vector_swigregister
stream_to_vector_swigregister(stream_to_vector)

def stream_to_vector_make(itemsize, nitems_per_block):
    """stream_to_vector_make(size_t itemsize, size_t nitems_per_block) -> stream_to_vector_sptr"""
    return _blocks_swig1.stream_to_vector_make(itemsize, nitems_per_block)

class streams_to_stream(object):
    """Proxy of C++ gr::blocks::streams_to_stream class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(itemsize, nstreams):
        """make(size_t itemsize, size_t nstreams) -> streams_to_stream_sptr"""
        return _blocks_swig1.streams_to_stream_make(itemsize, nstreams)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig1.delete_streams_to_stream
    __del__ = lambda self: None
streams_to_stream_swigregister = _blocks_swig1.streams_to_stream_swigregister
streams_to_stream_swigregister(streams_to_stream)

def streams_to_stream_make(itemsize, nstreams):
    """streams_to_stream_make(size_t itemsize, size_t nstreams) -> streams_to_stream_sptr"""
    return _blocks_swig1.streams_to_stream_make(itemsize, nstreams)

class streams_to_vector(object):
    """Proxy of C++ gr::blocks::streams_to_vector class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(itemsize, nstreams):
        """make(size_t itemsize, size_t nstreams) -> streams_to_vector_sptr"""
        return _blocks_swig1.streams_to_vector_make(itemsize, nstreams)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig1.delete_streams_to_vector
    __del__ = lambda self: None
streams_to_vector_swigregister = _blocks_swig1.streams_to_vector_swigregister
streams_to_vector_swigregister(streams_to_vector)

def streams_to_vector_make(itemsize, nstreams):
    """streams_to_vector_make(size_t itemsize, size_t nstreams) -> streams_to_vector_sptr"""
    return _blocks_swig1.streams_to_vector_make(itemsize, nstreams)

class tag_debug(object):
    """Proxy of C++ gr::blocks::tag_debug class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(*args, **kwargs):
        """make(size_t sizeof_stream_item, std::string const & name, std::string const & key_filter) -> tag_debug_sptr"""
        return _blocks_swig1.tag_debug_make(*args, **kwargs)

    make = staticmethod(make)

    def current_tags(self):
        """current_tags(tag_debug self) -> tags_vector_t"""
        return _blocks_swig1.tag_debug_current_tags(self)


    def num_tags(self):
        """num_tags(tag_debug self) -> int"""
        return _blocks_swig1.tag_debug_num_tags(self)


    def set_display(self, d):
        """set_display(tag_debug self, bool d)"""
        return _blocks_swig1.tag_debug_set_display(self, d)


    def set_key_filter(self, key_filter):
        """set_key_filter(tag_debug self, std::string const & key_filter)"""
        return _blocks_swig1.tag_debug_set_key_filter(self, key_filter)


    def key_filter(self):
        """key_filter(tag_debug self) -> std::string"""
        return _blocks_swig1.tag_debug_key_filter(self)

    __swig_destroy__ = _blocks_swig1.delete_tag_debug
    __del__ = lambda self: None
tag_debug_swigregister = _blocks_swig1.tag_debug_swigregister
tag_debug_swigregister(tag_debug)

def tag_debug_make(*args, **kwargs):
    """tag_debug_make(size_t sizeof_stream_item, std::string const & name, std::string const & key_filter) -> tag_debug_sptr"""
    return _blocks_swig1.tag_debug_make(*args, **kwargs)

class tagged_file_sink(object):
    """Proxy of C++ gr::blocks::tagged_file_sink class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(itemsize, samp_rate):
        """make(size_t itemsize, double samp_rate) -> tagged_file_sink_sptr"""
        return _blocks_swig1.tagged_file_sink_make(itemsize, samp_rate)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig1.delete_tagged_file_sink
    __del__ = lambda self: None
tagged_file_sink_swigregister = _blocks_swig1.tagged_file_sink_swigregister
tagged_file_sink_swigregister(tagged_file_sink)

def tagged_file_sink_make(itemsize, samp_rate):
    """tagged_file_sink_make(size_t itemsize, double samp_rate) -> tagged_file_sink_sptr"""
    return _blocks_swig1.tagged_file_sink_make(itemsize, samp_rate)

class tsb_vector_sink_b(object):
    """Proxy of C++ gr::blocks::tsb_vector_sink_b class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def reset(self):
        """reset(tsb_vector_sink_b self)"""
        return _blocks_swig1.tsb_vector_sink_b_reset(self)


    def data(self):
        """data(tsb_vector_sink_b self) -> std::vector< std::vector< unsigned char,std::allocator< unsigned char > >,std::allocator< std::vector< unsigned char,std::allocator< unsigned char > > > >"""
        return _blocks_swig1.tsb_vector_sink_b_data(self)


    def tags(self):
        """tags(tsb_vector_sink_b self) -> tags_vector_t"""
        return _blocks_swig1.tsb_vector_sink_b_tags(self)


    def make(*args, **kwargs):
        """make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_b_sptr"""
        return _blocks_swig1.tsb_vector_sink_b_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig1.delete_tsb_vector_sink_b
    __del__ = lambda self: None
tsb_vector_sink_b_swigregister = _blocks_swig1.tsb_vector_sink_b_swigregister
tsb_vector_sink_b_swigregister(tsb_vector_sink_b)

def tsb_vector_sink_b_make(*args, **kwargs):
    """tsb_vector_sink_b_make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_b_sptr"""
    return _blocks_swig1.tsb_vector_sink_b_make(*args, **kwargs)

class tsb_vector_sink_c(object):
    """Proxy of C++ gr::blocks::tsb_vector_sink_c class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def reset(self):
        """reset(tsb_vector_sink_c self)"""
        return _blocks_swig1.tsb_vector_sink_c_reset(self)


    def data(self):
        """data(tsb_vector_sink_c self) -> gr_vector_vector_complexf"""
        return _blocks_swig1.tsb_vector_sink_c_data(self)


    def tags(self):
        """tags(tsb_vector_sink_c self) -> tags_vector_t"""
        return _blocks_swig1.tsb_vector_sink_c_tags(self)


    def make(*args, **kwargs):
        """make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_c_sptr"""
        return _blocks_swig1.tsb_vector_sink_c_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig1.delete_tsb_vector_sink_c
    __del__ = lambda self: None
tsb_vector_sink_c_swigregister = _blocks_swig1.tsb_vector_sink_c_swigregister
tsb_vector_sink_c_swigregister(tsb_vector_sink_c)

def tsb_vector_sink_c_make(*args, **kwargs):
    """tsb_vector_sink_c_make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_c_sptr"""
    return _blocks_swig1.tsb_vector_sink_c_make(*args, **kwargs)

class tsb_vector_sink_f(object):
    """Proxy of C++ gr::blocks::tsb_vector_sink_f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def reset(self):
        """reset(tsb_vector_sink_f self)"""
        return _blocks_swig1.tsb_vector_sink_f_reset(self)


    def data(self):
        """data(tsb_vector_sink_f self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _blocks_swig1.tsb_vector_sink_f_data(self)


    def tags(self):
        """tags(tsb_vector_sink_f self) -> tags_vector_t"""
        return _blocks_swig1.tsb_vector_sink_f_tags(self)


    def make(*args, **kwargs):
        """make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_f_sptr"""
        return _blocks_swig1.tsb_vector_sink_f_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig1.delete_tsb_vector_sink_f
    __del__ = lambda self: None
tsb_vector_sink_f_swigregister = _blocks_swig1.tsb_vector_sink_f_swigregister
tsb_vector_sink_f_swigregister(tsb_vector_sink_f)

def tsb_vector_sink_f_make(*args, **kwargs):
    """tsb_vector_sink_f_make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_f_sptr"""
    return _blocks_swig1.tsb_vector_sink_f_make(*args, **kwargs)

class tsb_vector_sink_i(object):
    """Proxy of C++ gr::blocks::tsb_vector_sink_i class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def reset(self):
        """reset(tsb_vector_sink_i self)"""
        return _blocks_swig1.tsb_vector_sink_i_reset(self)


    def data(self):
        """data(tsb_vector_sink_i self) -> std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >"""
        return _blocks_swig1.tsb_vector_sink_i_data(self)


    def tags(self):
        """tags(tsb_vector_sink_i self) -> tags_vector_t"""
        return _blocks_swig1.tsb_vector_sink_i_tags(self)


    def make(*args, **kwargs):
        """make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_i_sptr"""
        return _blocks_swig1.tsb_vector_sink_i_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig1.delete_tsb_vector_sink_i
    __del__ = lambda self: None
tsb_vector_sink_i_swigregister = _blocks_swig1.tsb_vector_sink_i_swigregister
tsb_vector_sink_i_swigregister(tsb_vector_sink_i)

def tsb_vector_sink_i_make(*args, **kwargs):
    """tsb_vector_sink_i_make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_i_sptr"""
    return _blocks_swig1.tsb_vector_sink_i_make(*args, **kwargs)

class tsb_vector_sink_s(object):
    """Proxy of C++ gr::blocks::tsb_vector_sink_s class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def reset(self):
        """reset(tsb_vector_sink_s self)"""
        return _blocks_swig1.tsb_vector_sink_s_reset(self)


    def data(self):
        """data(tsb_vector_sink_s self) -> std::vector< std::vector< short,std::allocator< short > >,std::allocator< std::vector< short,std::allocator< short > > > >"""
        return _blocks_swig1.tsb_vector_sink_s_data(self)


    def tags(self):
        """tags(tsb_vector_sink_s self) -> tags_vector_t"""
        return _blocks_swig1.tsb_vector_sink_s_tags(self)


    def make(*args, **kwargs):
        """make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_s_sptr"""
        return _blocks_swig1.tsb_vector_sink_s_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig1.delete_tsb_vector_sink_s
    __del__ = lambda self: None
tsb_vector_sink_s_swigregister = _blocks_swig1.tsb_vector_sink_s_swigregister
tsb_vector_sink_s_swigregister(tsb_vector_sink_s)

def tsb_vector_sink_s_make(*args, **kwargs):
    """tsb_vector_sink_s_make(int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_s_sptr"""
    return _blocks_swig1.tsb_vector_sink_s_make(*args, **kwargs)

class throttle(object):
    """Proxy of C++ gr::blocks::throttle class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(itemsize, samples_per_sec, ignore_tags=True):
        """make(size_t itemsize, double samples_per_sec, bool ignore_tags=True) -> throttle_sptr"""
        return _blocks_swig1.throttle_make(itemsize, samples_per_sec, ignore_tags)

    make = staticmethod(make)

    def set_sample_rate(self, rate):
        """set_sample_rate(throttle self, double rate)"""
        return _blocks_swig1.throttle_set_sample_rate(self, rate)


    def sample_rate(self):
        """sample_rate(throttle self) -> double"""
        return _blocks_swig1.throttle_sample_rate(self)

    __swig_destroy__ = _blocks_swig1.delete_throttle
    __del__ = lambda self: None
throttle_swigregister = _blocks_swig1.throttle_swigregister
throttle_swigregister(throttle)

def throttle_make(itemsize, samples_per_sec, ignore_tags=True):
    """throttle_make(size_t itemsize, double samples_per_sec, bool ignore_tags=True) -> throttle_sptr"""
    return _blocks_swig1.throttle_make(itemsize, samples_per_sec, ignore_tags)

class vector_map(object):
    """Proxy of C++ gr::blocks::vector_map class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(item_size, in_vlens, mapping):
        """make(size_t item_size, gr_vsize_t in_vlens, gr_vvvsize_t mapping) -> vector_map_sptr"""
        return _blocks_swig1.vector_map_make(item_size, in_vlens, mapping)

    make = staticmethod(make)

    def set_mapping(self, mapping):
        """set_mapping(vector_map self, gr_vvvsize_t mapping)"""
        return _blocks_swig1.vector_map_set_mapping(self, mapping)

    __swig_destroy__ = _blocks_swig1.delete_vector_map
    __del__ = lambda self: None
vector_map_swigregister = _blocks_swig1.vector_map_swigregister
vector_map_swigregister(vector_map)

def vector_map_make(item_size, in_vlens, mapping):
    """vector_map_make(size_t item_size, gr_vsize_t in_vlens, gr_vvvsize_t mapping) -> vector_map_sptr"""
    return _blocks_swig1.vector_map_make(item_size, in_vlens, mapping)

class vector_to_stream(object):
    """Proxy of C++ gr::blocks::vector_to_stream class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(itemsize, nitems_per_block):
        """make(size_t itemsize, size_t nitems_per_block) -> vector_to_stream_sptr"""
        return _blocks_swig1.vector_to_stream_make(itemsize, nitems_per_block)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig1.delete_vector_to_stream
    __del__ = lambda self: None
vector_to_stream_swigregister = _blocks_swig1.vector_to_stream_swigregister
vector_to_stream_swigregister(vector_to_stream)

def vector_to_stream_make(itemsize, nitems_per_block):
    """vector_to_stream_make(size_t itemsize, size_t nitems_per_block) -> vector_to_stream_sptr"""
    return _blocks_swig1.vector_to_stream_make(itemsize, nitems_per_block)

class vector_to_streams(object):
    """Proxy of C++ gr::blocks::vector_to_streams class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def make(itemsize, nstreams):
        """make(size_t itemsize, size_t nstreams) -> vector_to_streams_sptr"""
        return _blocks_swig1.vector_to_streams_make(itemsize, nstreams)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig1.delete_vector_to_streams
    __del__ = lambda self: None
vector_to_streams_swigregister = _blocks_swig1.vector_to_streams_swigregister
vector_to_streams_swigregister(vector_to_streams)

def vector_to_streams_make(itemsize, nstreams):
    """vector_to_streams_make(size_t itemsize, size_t nstreams) -> vector_to_streams_sptr"""
    return _blocks_swig1.vector_to_streams_make(itemsize, nstreams)

class vector_insert_b(object):
    """Proxy of C++ gr::blocks::vector_insert_b class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(data, periodicity, offset=0):
        """make(std::vector< unsigned char,std::allocator< unsigned char > > const & data, int periodicity, int offset=0) -> vector_insert_b_sptr"""
        return _blocks_swig1.vector_insert_b_make(data, periodicity, offset)

    make = staticmethod(make)

    def rewind(self):
        """rewind(vector_insert_b self)"""
        return _blocks_swig1.vector_insert_b_rewind(self)


    def set_data(self, data):
        """set_data(vector_insert_b self, std::vector< unsigned char,std::allocator< unsigned char > > const & data)"""
        return _blocks_swig1.vector_insert_b_set_data(self, data)

    __swig_destroy__ = _blocks_swig1.delete_vector_insert_b
    __del__ = lambda self: None
vector_insert_b_swigregister = _blocks_swig1.vector_insert_b_swigregister
vector_insert_b_swigregister(vector_insert_b)

def vector_insert_b_make(data, periodicity, offset=0):
    """vector_insert_b_make(std::vector< unsigned char,std::allocator< unsigned char > > const & data, int periodicity, int offset=0) -> vector_insert_b_sptr"""
    return _blocks_swig1.vector_insert_b_make(data, periodicity, offset)

class vector_insert_s(object):
    """Proxy of C++ gr::blocks::vector_insert_s class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(data, periodicity, offset=0):
        """make(std::vector< short,std::allocator< short > > const & data, int periodicity, int offset=0) -> vector_insert_s_sptr"""
        return _blocks_swig1.vector_insert_s_make(data, periodicity, offset)

    make = staticmethod(make)

    def rewind(self):
        """rewind(vector_insert_s self)"""
        return _blocks_swig1.vector_insert_s_rewind(self)


    def set_data(self, data):
        """set_data(vector_insert_s self, std::vector< short,std::allocator< short > > const & data)"""
        return _blocks_swig1.vector_insert_s_set_data(self, data)

    __swig_destroy__ = _blocks_swig1.delete_vector_insert_s
    __del__ = lambda self: None
vector_insert_s_swigregister = _blocks_swig1.vector_insert_s_swigregister
vector_insert_s_swigregister(vector_insert_s)

def vector_insert_s_make(data, periodicity, offset=0):
    """vector_insert_s_make(std::vector< short,std::allocator< short > > const & data, int periodicity, int offset=0) -> vector_insert_s_sptr"""
    return _blocks_swig1.vector_insert_s_make(data, periodicity, offset)

class vector_insert_i(object):
    """Proxy of C++ gr::blocks::vector_insert_i class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(data, periodicity, offset=0):
        """make(std::vector< int,std::allocator< int > > const & data, int periodicity, int offset=0) -> vector_insert_i_sptr"""
        return _blocks_swig1.vector_insert_i_make(data, periodicity, offset)

    make = staticmethod(make)

    def rewind(self):
        """rewind(vector_insert_i self)"""
        return _blocks_swig1.vector_insert_i_rewind(self)


    def set_data(self, data):
        """set_data(vector_insert_i self, std::vector< int,std::allocator< int > > const & data)"""
        return _blocks_swig1.vector_insert_i_set_data(self, data)

    __swig_destroy__ = _blocks_swig1.delete_vector_insert_i
    __del__ = lambda self: None
vector_insert_i_swigregister = _blocks_swig1.vector_insert_i_swigregister
vector_insert_i_swigregister(vector_insert_i)

def vector_insert_i_make(data, periodicity, offset=0):
    """vector_insert_i_make(std::vector< int,std::allocator< int > > const & data, int periodicity, int offset=0) -> vector_insert_i_sptr"""
    return _blocks_swig1.vector_insert_i_make(data, periodicity, offset)

class vector_insert_f(object):
    """Proxy of C++ gr::blocks::vector_insert_f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(data, periodicity, offset=0):
        """make(pmt_vector_float data, int periodicity, int offset=0) -> vector_insert_f_sptr"""
        return _blocks_swig1.vector_insert_f_make(data, periodicity, offset)

    make = staticmethod(make)

    def rewind(self):
        """rewind(vector_insert_f self)"""
        return _blocks_swig1.vector_insert_f_rewind(self)


    def set_data(self, data):
        """set_data(vector_insert_f self, pmt_vector_float data)"""
        return _blocks_swig1.vector_insert_f_set_data(self, data)

    __swig_destroy__ = _blocks_swig1.delete_vector_insert_f
    __del__ = lambda self: None
vector_insert_f_swigregister = _blocks_swig1.vector_insert_f_swigregister
vector_insert_f_swigregister(vector_insert_f)

def vector_insert_f_make(data, periodicity, offset=0):
    """vector_insert_f_make(pmt_vector_float data, int periodicity, int offset=0) -> vector_insert_f_sptr"""
    return _blocks_swig1.vector_insert_f_make(data, periodicity, offset)

class vector_insert_c(object):
    """Proxy of C++ gr::blocks::vector_insert_c class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(data, periodicity, offset=0):
        """make(pmt_vector_cfloat data, int periodicity, int offset=0) -> vector_insert_c_sptr"""
        return _blocks_swig1.vector_insert_c_make(data, periodicity, offset)

    make = staticmethod(make)

    def rewind(self):
        """rewind(vector_insert_c self)"""
        return _blocks_swig1.vector_insert_c_rewind(self)


    def set_data(self, data):
        """set_data(vector_insert_c self, pmt_vector_cfloat data)"""
        return _blocks_swig1.vector_insert_c_set_data(self, data)

    __swig_destroy__ = _blocks_swig1.delete_vector_insert_c
    __del__ = lambda self: None
vector_insert_c_swigregister = _blocks_swig1.vector_insert_c_swigregister
vector_insert_c_swigregister(vector_insert_c)

def vector_insert_c_make(data, periodicity, offset=0):
    """vector_insert_c_make(pmt_vector_cfloat data, int periodicity, int offset=0) -> vector_insert_c_sptr"""
    return _blocks_swig1.vector_insert_c_make(data, periodicity, offset)

class vector_sink_b(object):
    """Proxy of C++ gr::blocks::vector_sink_b class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(vlen=1):
        """make(int vlen=1) -> vector_sink_b_sptr"""
        return _blocks_swig1.vector_sink_b_make(vlen)

    make = staticmethod(make)

    def reset(self):
        """reset(vector_sink_b self)"""
        return _blocks_swig1.vector_sink_b_reset(self)


    def data(self):
        """data(vector_sink_b self) -> std::vector< unsigned char,std::allocator< unsigned char > >"""
        return _blocks_swig1.vector_sink_b_data(self)


    def tags(self):
        """tags(vector_sink_b self) -> tags_vector_t"""
        return _blocks_swig1.vector_sink_b_tags(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_sink_b
    __del__ = lambda self: None
vector_sink_b_swigregister = _blocks_swig1.vector_sink_b_swigregister
vector_sink_b_swigregister(vector_sink_b)

def vector_sink_b_make(vlen=1):
    """vector_sink_b_make(int vlen=1) -> vector_sink_b_sptr"""
    return _blocks_swig1.vector_sink_b_make(vlen)

class vector_sink_s(object):
    """Proxy of C++ gr::blocks::vector_sink_s class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(vlen=1):
        """make(int vlen=1) -> vector_sink_s_sptr"""
        return _blocks_swig1.vector_sink_s_make(vlen)

    make = staticmethod(make)

    def reset(self):
        """reset(vector_sink_s self)"""
        return _blocks_swig1.vector_sink_s_reset(self)


    def data(self):
        """data(vector_sink_s self) -> std::vector< short,std::allocator< short > >"""
        return _blocks_swig1.vector_sink_s_data(self)


    def tags(self):
        """tags(vector_sink_s self) -> tags_vector_t"""
        return _blocks_swig1.vector_sink_s_tags(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_sink_s
    __del__ = lambda self: None
vector_sink_s_swigregister = _blocks_swig1.vector_sink_s_swigregister
vector_sink_s_swigregister(vector_sink_s)

def vector_sink_s_make(vlen=1):
    """vector_sink_s_make(int vlen=1) -> vector_sink_s_sptr"""
    return _blocks_swig1.vector_sink_s_make(vlen)

class vector_sink_i(object):
    """Proxy of C++ gr::blocks::vector_sink_i class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(vlen=1):
        """make(int vlen=1) -> vector_sink_i_sptr"""
        return _blocks_swig1.vector_sink_i_make(vlen)

    make = staticmethod(make)

    def reset(self):
        """reset(vector_sink_i self)"""
        return _blocks_swig1.vector_sink_i_reset(self)


    def data(self):
        """data(vector_sink_i self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_sink_i_data(self)


    def tags(self):
        """tags(vector_sink_i self) -> tags_vector_t"""
        return _blocks_swig1.vector_sink_i_tags(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_sink_i
    __del__ = lambda self: None
vector_sink_i_swigregister = _blocks_swig1.vector_sink_i_swigregister
vector_sink_i_swigregister(vector_sink_i)

def vector_sink_i_make(vlen=1):
    """vector_sink_i_make(int vlen=1) -> vector_sink_i_sptr"""
    return _blocks_swig1.vector_sink_i_make(vlen)

class vector_sink_f(object):
    """Proxy of C++ gr::blocks::vector_sink_f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(vlen=1):
        """make(int vlen=1) -> vector_sink_f_sptr"""
        return _blocks_swig1.vector_sink_f_make(vlen)

    make = staticmethod(make)

    def reset(self):
        """reset(vector_sink_f self)"""
        return _blocks_swig1.vector_sink_f_reset(self)


    def data(self):
        """data(vector_sink_f self) -> pmt_vector_float"""
        return _blocks_swig1.vector_sink_f_data(self)


    def tags(self):
        """tags(vector_sink_f self) -> tags_vector_t"""
        return _blocks_swig1.vector_sink_f_tags(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_sink_f
    __del__ = lambda self: None
vector_sink_f_swigregister = _blocks_swig1.vector_sink_f_swigregister
vector_sink_f_swigregister(vector_sink_f)

def vector_sink_f_make(vlen=1):
    """vector_sink_f_make(int vlen=1) -> vector_sink_f_sptr"""
    return _blocks_swig1.vector_sink_f_make(vlen)

class vector_sink_c(object):
    """Proxy of C++ gr::blocks::vector_sink_c class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(vlen=1):
        """make(int vlen=1) -> vector_sink_c_sptr"""
        return _blocks_swig1.vector_sink_c_make(vlen)

    make = staticmethod(make)

    def reset(self):
        """reset(vector_sink_c self)"""
        return _blocks_swig1.vector_sink_c_reset(self)


    def data(self):
        """data(vector_sink_c self) -> pmt_vector_cfloat"""
        return _blocks_swig1.vector_sink_c_data(self)


    def tags(self):
        """tags(vector_sink_c self) -> tags_vector_t"""
        return _blocks_swig1.vector_sink_c_tags(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_sink_c
    __del__ = lambda self: None
vector_sink_c_swigregister = _blocks_swig1.vector_sink_c_swigregister
vector_sink_c_swigregister(vector_sink_c)

def vector_sink_c_make(vlen=1):
    """vector_sink_c_make(int vlen=1) -> vector_sink_c_sptr"""
    return _blocks_swig1.vector_sink_c_make(vlen)

class vector_source_b(object):
    """Proxy of C++ gr::blocks::vector_source_b class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(*args, **kwargs):
        """make(std::vector< unsigned char,std::allocator< unsigned char > > const & data, bool repeat=False, int vlen=1, tags_vector_t tags) -> vector_source_b_sptr"""
        return _blocks_swig1.vector_source_b_make(*args, **kwargs)

    make = staticmethod(make)

    def rewind(self):
        """rewind(vector_source_b self)"""
        return _blocks_swig1.vector_source_b_rewind(self)


    def set_data(self, *args, **kwargs):
        """set_data(vector_source_b self, std::vector< unsigned char,std::allocator< unsigned char > > const & data, tags_vector_t tags)"""
        return _blocks_swig1.vector_source_b_set_data(self, *args, **kwargs)

    __swig_destroy__ = _blocks_swig1.delete_vector_source_b
    __del__ = lambda self: None
vector_source_b_swigregister = _blocks_swig1.vector_source_b_swigregister
vector_source_b_swigregister(vector_source_b)

def vector_source_b_make(*args, **kwargs):
    """vector_source_b_make(std::vector< unsigned char,std::allocator< unsigned char > > const & data, bool repeat=False, int vlen=1, tags_vector_t tags) -> vector_source_b_sptr"""
    return _blocks_swig1.vector_source_b_make(*args, **kwargs)

class vector_source_s(object):
    """Proxy of C++ gr::blocks::vector_source_s class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(*args, **kwargs):
        """make(std::vector< short,std::allocator< short > > const & data, bool repeat=False, int vlen=1, tags_vector_t tags) -> vector_source_s_sptr"""
        return _blocks_swig1.vector_source_s_make(*args, **kwargs)

    make = staticmethod(make)

    def rewind(self):
        """rewind(vector_source_s self)"""
        return _blocks_swig1.vector_source_s_rewind(self)


    def set_data(self, *args, **kwargs):
        """set_data(vector_source_s self, std::vector< short,std::allocator< short > > const & data, tags_vector_t tags)"""
        return _blocks_swig1.vector_source_s_set_data(self, *args, **kwargs)

    __swig_destroy__ = _blocks_swig1.delete_vector_source_s
    __del__ = lambda self: None
vector_source_s_swigregister = _blocks_swig1.vector_source_s_swigregister
vector_source_s_swigregister(vector_source_s)

def vector_source_s_make(*args, **kwargs):
    """vector_source_s_make(std::vector< short,std::allocator< short > > const & data, bool repeat=False, int vlen=1, tags_vector_t tags) -> vector_source_s_sptr"""
    return _blocks_swig1.vector_source_s_make(*args, **kwargs)

class vector_source_i(object):
    """Proxy of C++ gr::blocks::vector_source_i class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(*args, **kwargs):
        """make(std::vector< int,std::allocator< int > > const & data, bool repeat=False, int vlen=1, tags_vector_t tags) -> vector_source_i_sptr"""
        return _blocks_swig1.vector_source_i_make(*args, **kwargs)

    make = staticmethod(make)

    def rewind(self):
        """rewind(vector_source_i self)"""
        return _blocks_swig1.vector_source_i_rewind(self)


    def set_data(self, *args, **kwargs):
        """set_data(vector_source_i self, std::vector< int,std::allocator< int > > const & data, tags_vector_t tags)"""
        return _blocks_swig1.vector_source_i_set_data(self, *args, **kwargs)

    __swig_destroy__ = _blocks_swig1.delete_vector_source_i
    __del__ = lambda self: None
vector_source_i_swigregister = _blocks_swig1.vector_source_i_swigregister
vector_source_i_swigregister(vector_source_i)

def vector_source_i_make(*args, **kwargs):
    """vector_source_i_make(std::vector< int,std::allocator< int > > const & data, bool repeat=False, int vlen=1, tags_vector_t tags) -> vector_source_i_sptr"""
    return _blocks_swig1.vector_source_i_make(*args, **kwargs)

class vector_source_f(object):
    """Proxy of C++ gr::blocks::vector_source_f class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(*args, **kwargs):
        """make(pmt_vector_float data, bool repeat=False, int vlen=1, tags_vector_t tags) -> vector_source_f_sptr"""
        return _blocks_swig1.vector_source_f_make(*args, **kwargs)

    make = staticmethod(make)

    def rewind(self):
        """rewind(vector_source_f self)"""
        return _blocks_swig1.vector_source_f_rewind(self)


    def set_data(self, *args, **kwargs):
        """set_data(vector_source_f self, pmt_vector_float data, tags_vector_t tags)"""
        return _blocks_swig1.vector_source_f_set_data(self, *args, **kwargs)

    __swig_destroy__ = _blocks_swig1.delete_vector_source_f
    __del__ = lambda self: None
vector_source_f_swigregister = _blocks_swig1.vector_source_f_swigregister
vector_source_f_swigregister(vector_source_f)

def vector_source_f_make(*args, **kwargs):
    """vector_source_f_make(pmt_vector_float data, bool repeat=False, int vlen=1, tags_vector_t tags) -> vector_source_f_sptr"""
    return _blocks_swig1.vector_source_f_make(*args, **kwargs)

class vector_source_c(object):
    """Proxy of C++ gr::blocks::vector_source_c class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(*args, **kwargs):
        """make(pmt_vector_cfloat data, bool repeat=False, int vlen=1, tags_vector_t tags) -> vector_source_c_sptr"""
        return _blocks_swig1.vector_source_c_make(*args, **kwargs)

    make = staticmethod(make)

    def rewind(self):
        """rewind(vector_source_c self)"""
        return _blocks_swig1.vector_source_c_rewind(self)


    def set_data(self, *args, **kwargs):
        """set_data(vector_source_c self, pmt_vector_cfloat data, tags_vector_t tags)"""
        return _blocks_swig1.vector_source_c_set_data(self, *args, **kwargs)

    __swig_destroy__ = _blocks_swig1.delete_vector_source_c
    __del__ = lambda self: None
vector_source_c_swigregister = _blocks_swig1.vector_source_c_swigregister
vector_source_c_swigregister(vector_source_c)

def vector_source_c_make(*args, **kwargs):
    """vector_source_c_make(pmt_vector_cfloat data, bool repeat=False, int vlen=1, tags_vector_t tags) -> vector_source_c_sptr"""
    return _blocks_swig1.vector_source_c_make(*args, **kwargs)

class wavfile_sink(object):
    """Proxy of C++ gr::blocks::wavfile_sink class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(filename, n_channels, sample_rate, bits_per_sample=16):
        """make(char const * filename, int n_channels, unsigned int sample_rate, int bits_per_sample=16) -> wavfile_sink_sptr"""
        return _blocks_swig1.wavfile_sink_make(filename, n_channels, sample_rate, bits_per_sample)

    make = staticmethod(make)

    def open(self, filename):
        """open(wavfile_sink self, char const * filename) -> bool"""
        return _blocks_swig1.wavfile_sink_open(self, filename)


    def close(self):
        """close(wavfile_sink self)"""
        return _blocks_swig1.wavfile_sink_close(self)


    def set_sample_rate(self, sample_rate):
        """set_sample_rate(wavfile_sink self, unsigned int sample_rate)"""
        return _blocks_swig1.wavfile_sink_set_sample_rate(self, sample_rate)


    def set_bits_per_sample(self, bits_per_sample):
        """set_bits_per_sample(wavfile_sink self, int bits_per_sample)"""
        return _blocks_swig1.wavfile_sink_set_bits_per_sample(self, bits_per_sample)

    __swig_destroy__ = _blocks_swig1.delete_wavfile_sink
    __del__ = lambda self: None
wavfile_sink_swigregister = _blocks_swig1.wavfile_sink_swigregister
wavfile_sink_swigregister(wavfile_sink)

def wavfile_sink_make(filename, n_channels, sample_rate, bits_per_sample=16):
    """wavfile_sink_make(char const * filename, int n_channels, unsigned int sample_rate, int bits_per_sample=16) -> wavfile_sink_sptr"""
    return _blocks_swig1.wavfile_sink_make(filename, n_channels, sample_rate, bits_per_sample)

class wavfile_source(object):
    """Proxy of C++ gr::blocks::wavfile_source class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def make(filename, repeat=False):
        """make(char const * filename, bool repeat=False) -> wavfile_source_sptr"""
        return _blocks_swig1.wavfile_source_make(filename, repeat)

    make = staticmethod(make)

    def sample_rate(self):
        """sample_rate(wavfile_source self) -> unsigned int"""
        return _blocks_swig1.wavfile_source_sample_rate(self)


    def bits_per_sample(self):
        """bits_per_sample(wavfile_source self) -> int"""
        return _blocks_swig1.wavfile_source_bits_per_sample(self)


    def channels(self):
        """channels(wavfile_source self) -> int"""
        return _blocks_swig1.wavfile_source_channels(self)

    __swig_destroy__ = _blocks_swig1.delete_wavfile_source
    __del__ = lambda self: None
wavfile_source_swigregister = _blocks_swig1.wavfile_source_swigregister
wavfile_source_swigregister(wavfile_source)

def wavfile_source_make(filename, repeat=False):
    """wavfile_source_make(char const * filename, bool repeat=False) -> wavfile_source_sptr"""
    return _blocks_swig1.wavfile_source_make(filename, repeat)

class skiphead_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::skiphead)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::skiphead)> self) -> skiphead_sptr
        __init__(boost::shared_ptr<(gr::blocks::skiphead)> self, skiphead p) -> skiphead_sptr
        """
        this = _blocks_swig1.new_skiphead_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(skiphead_sptr self) -> skiphead"""
        return _blocks_swig1.skiphead_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_skiphead_sptr
    __del__ = lambda self: None

    def make(self, itemsize, nitems_to_skip):
        """make(skiphead_sptr self, size_t itemsize, uint64_t nitems_to_skip) -> skiphead_sptr"""
        return _blocks_swig1.skiphead_sptr_make(self, itemsize, nitems_to_skip)


    def history(self):
        """history(skiphead_sptr self) -> unsigned int"""
        return _blocks_swig1.skiphead_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(skiphead_sptr self, int which, int delay)
        declare_sample_delay(skiphead_sptr self, unsigned int delay)
        """
        return _blocks_swig1.skiphead_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(skiphead_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.skiphead_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(skiphead_sptr self) -> int"""
        return _blocks_swig1.skiphead_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(skiphead_sptr self) -> double"""
        return _blocks_swig1.skiphead_sptr_relative_rate(self)


    def start(self):
        """start(skiphead_sptr self) -> bool"""
        return _blocks_swig1.skiphead_sptr_start(self)


    def stop(self):
        """stop(skiphead_sptr self) -> bool"""
        return _blocks_swig1.skiphead_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(skiphead_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.skiphead_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(skiphead_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.skiphead_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(skiphead_sptr self) -> int"""
        return _blocks_swig1.skiphead_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(skiphead_sptr self, int m)"""
        return _blocks_swig1.skiphead_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(skiphead_sptr self)"""
        return _blocks_swig1.skiphead_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(skiphead_sptr self) -> bool"""
        return _blocks_swig1.skiphead_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(skiphead_sptr self, int m)"""
        return _blocks_swig1.skiphead_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(skiphead_sptr self) -> int"""
        return _blocks_swig1.skiphead_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(skiphead_sptr self, int i) -> long"""
        return _blocks_swig1.skiphead_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(skiphead_sptr self, long max_output_buffer)
        set_max_output_buffer(skiphead_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.skiphead_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(skiphead_sptr self, int i) -> long"""
        return _blocks_swig1.skiphead_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(skiphead_sptr self, long min_output_buffer)
        set_min_output_buffer(skiphead_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.skiphead_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(skiphead_sptr self) -> float"""
        return _blocks_swig1.skiphead_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(skiphead_sptr self) -> float"""
        return _blocks_swig1.skiphead_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(skiphead_sptr self) -> float"""
        return _blocks_swig1.skiphead_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(skiphead_sptr self) -> float"""
        return _blocks_swig1.skiphead_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(skiphead_sptr self) -> float"""
        return _blocks_swig1.skiphead_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(skiphead_sptr self) -> float"""
        return _blocks_swig1.skiphead_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(skiphead_sptr self, int which) -> float
        pc_input_buffers_full(skiphead_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.skiphead_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(skiphead_sptr self, int which) -> float
        pc_input_buffers_full_avg(skiphead_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.skiphead_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(skiphead_sptr self, int which) -> float
        pc_input_buffers_full_var(skiphead_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.skiphead_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(skiphead_sptr self, int which) -> float
        pc_output_buffers_full(skiphead_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.skiphead_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(skiphead_sptr self, int which) -> float
        pc_output_buffers_full_avg(skiphead_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.skiphead_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(skiphead_sptr self, int which) -> float
        pc_output_buffers_full_var(skiphead_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.skiphead_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(skiphead_sptr self) -> float"""
        return _blocks_swig1.skiphead_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(skiphead_sptr self) -> float"""
        return _blocks_swig1.skiphead_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(skiphead_sptr self) -> float"""
        return _blocks_swig1.skiphead_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(skiphead_sptr self) -> float"""
        return _blocks_swig1.skiphead_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(skiphead_sptr self) -> float"""
        return _blocks_swig1.skiphead_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(skiphead_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.skiphead_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(skiphead_sptr self)"""
        return _blocks_swig1.skiphead_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(skiphead_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.skiphead_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(skiphead_sptr self) -> int"""
        return _blocks_swig1.skiphead_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(skiphead_sptr self) -> int"""
        return _blocks_swig1.skiphead_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(skiphead_sptr self, int priority) -> int"""
        return _blocks_swig1.skiphead_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(skiphead_sptr self) -> std::string"""
        return _blocks_swig1.skiphead_sptr_name(self)


    def symbol_name(self):
        """symbol_name(skiphead_sptr self) -> std::string"""
        return _blocks_swig1.skiphead_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(skiphead_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.skiphead_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(skiphead_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.skiphead_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(skiphead_sptr self) -> long"""
        return _blocks_swig1.skiphead_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(skiphead_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.skiphead_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(skiphead_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.skiphead_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(skiphead_sptr self) -> std::string"""
        return _blocks_swig1.skiphead_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(skiphead_sptr self, std::string name)"""
        return _blocks_swig1.skiphead_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(skiphead_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.skiphead_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(skiphead_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.skiphead_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(skiphead_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.skiphead_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(skiphead_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.skiphead_sptr_message_subscribers(self, which_port)

skiphead_sptr_swigregister = _blocks_swig1.skiphead_sptr_swigregister
skiphead_sptr_swigregister(skiphead_sptr)

skiphead_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
skiphead = skiphead.make;

class stream_mux_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::stream_mux)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::stream_mux)> self) -> stream_mux_sptr
        __init__(boost::shared_ptr<(gr::blocks::stream_mux)> self, stream_mux p) -> stream_mux_sptr
        """
        this = _blocks_swig1.new_stream_mux_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(stream_mux_sptr self) -> stream_mux"""
        return _blocks_swig1.stream_mux_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_stream_mux_sptr
    __del__ = lambda self: None

    def make(self, itemsize, lengths):
        """make(stream_mux_sptr self, size_t itemsize, std::vector< int,std::allocator< int > > const & lengths) -> stream_mux_sptr"""
        return _blocks_swig1.stream_mux_sptr_make(self, itemsize, lengths)


    def history(self):
        """history(stream_mux_sptr self) -> unsigned int"""
        return _blocks_swig1.stream_mux_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(stream_mux_sptr self, int which, int delay)
        declare_sample_delay(stream_mux_sptr self, unsigned int delay)
        """
        return _blocks_swig1.stream_mux_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(stream_mux_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.stream_mux_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(stream_mux_sptr self) -> int"""
        return _blocks_swig1.stream_mux_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(stream_mux_sptr self) -> double"""
        return _blocks_swig1.stream_mux_sptr_relative_rate(self)


    def start(self):
        """start(stream_mux_sptr self) -> bool"""
        return _blocks_swig1.stream_mux_sptr_start(self)


    def stop(self):
        """stop(stream_mux_sptr self) -> bool"""
        return _blocks_swig1.stream_mux_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(stream_mux_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.stream_mux_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(stream_mux_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.stream_mux_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(stream_mux_sptr self) -> int"""
        return _blocks_swig1.stream_mux_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(stream_mux_sptr self, int m)"""
        return _blocks_swig1.stream_mux_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(stream_mux_sptr self)"""
        return _blocks_swig1.stream_mux_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(stream_mux_sptr self) -> bool"""
        return _blocks_swig1.stream_mux_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(stream_mux_sptr self, int m)"""
        return _blocks_swig1.stream_mux_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(stream_mux_sptr self) -> int"""
        return _blocks_swig1.stream_mux_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(stream_mux_sptr self, int i) -> long"""
        return _blocks_swig1.stream_mux_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(stream_mux_sptr self, long max_output_buffer)
        set_max_output_buffer(stream_mux_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.stream_mux_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(stream_mux_sptr self, int i) -> long"""
        return _blocks_swig1.stream_mux_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(stream_mux_sptr self, long min_output_buffer)
        set_min_output_buffer(stream_mux_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.stream_mux_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(stream_mux_sptr self) -> float"""
        return _blocks_swig1.stream_mux_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(stream_mux_sptr self) -> float"""
        return _blocks_swig1.stream_mux_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(stream_mux_sptr self) -> float"""
        return _blocks_swig1.stream_mux_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(stream_mux_sptr self) -> float"""
        return _blocks_swig1.stream_mux_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(stream_mux_sptr self) -> float"""
        return _blocks_swig1.stream_mux_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(stream_mux_sptr self) -> float"""
        return _blocks_swig1.stream_mux_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(stream_mux_sptr self, int which) -> float
        pc_input_buffers_full(stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_mux_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(stream_mux_sptr self, int which) -> float
        pc_input_buffers_full_avg(stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_mux_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(stream_mux_sptr self, int which) -> float
        pc_input_buffers_full_var(stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_mux_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(stream_mux_sptr self, int which) -> float
        pc_output_buffers_full(stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_mux_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(stream_mux_sptr self, int which) -> float
        pc_output_buffers_full_avg(stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_mux_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(stream_mux_sptr self, int which) -> float
        pc_output_buffers_full_var(stream_mux_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_mux_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(stream_mux_sptr self) -> float"""
        return _blocks_swig1.stream_mux_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(stream_mux_sptr self) -> float"""
        return _blocks_swig1.stream_mux_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(stream_mux_sptr self) -> float"""
        return _blocks_swig1.stream_mux_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(stream_mux_sptr self) -> float"""
        return _blocks_swig1.stream_mux_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(stream_mux_sptr self) -> float"""
        return _blocks_swig1.stream_mux_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(stream_mux_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.stream_mux_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(stream_mux_sptr self)"""
        return _blocks_swig1.stream_mux_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(stream_mux_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.stream_mux_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(stream_mux_sptr self) -> int"""
        return _blocks_swig1.stream_mux_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(stream_mux_sptr self) -> int"""
        return _blocks_swig1.stream_mux_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(stream_mux_sptr self, int priority) -> int"""
        return _blocks_swig1.stream_mux_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(stream_mux_sptr self) -> std::string"""
        return _blocks_swig1.stream_mux_sptr_name(self)


    def symbol_name(self):
        """symbol_name(stream_mux_sptr self) -> std::string"""
        return _blocks_swig1.stream_mux_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(stream_mux_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.stream_mux_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(stream_mux_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.stream_mux_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(stream_mux_sptr self) -> long"""
        return _blocks_swig1.stream_mux_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(stream_mux_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.stream_mux_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(stream_mux_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.stream_mux_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(stream_mux_sptr self) -> std::string"""
        return _blocks_swig1.stream_mux_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(stream_mux_sptr self, std::string name)"""
        return _blocks_swig1.stream_mux_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(stream_mux_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.stream_mux_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(stream_mux_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.stream_mux_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(stream_mux_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.stream_mux_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(stream_mux_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.stream_mux_sptr_message_subscribers(self, which_port)

stream_mux_sptr_swigregister = _blocks_swig1.stream_mux_sptr_swigregister
stream_mux_sptr_swigregister(stream_mux_sptr)

stream_mux_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
stream_mux = stream_mux.make;

class stream_to_streams_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::stream_to_streams)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::stream_to_streams)> self) -> stream_to_streams_sptr
        __init__(boost::shared_ptr<(gr::blocks::stream_to_streams)> self, stream_to_streams p) -> stream_to_streams_sptr
        """
        this = _blocks_swig1.new_stream_to_streams_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(stream_to_streams_sptr self) -> stream_to_streams"""
        return _blocks_swig1.stream_to_streams_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_stream_to_streams_sptr
    __del__ = lambda self: None

    def make(self, itemsize, nstreams):
        """make(stream_to_streams_sptr self, size_t itemsize, size_t nstreams) -> stream_to_streams_sptr"""
        return _blocks_swig1.stream_to_streams_sptr_make(self, itemsize, nstreams)


    def history(self):
        """history(stream_to_streams_sptr self) -> unsigned int"""
        return _blocks_swig1.stream_to_streams_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(stream_to_streams_sptr self, int which, int delay)
        declare_sample_delay(stream_to_streams_sptr self, unsigned int delay)
        """
        return _blocks_swig1.stream_to_streams_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(stream_to_streams_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.stream_to_streams_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(stream_to_streams_sptr self) -> int"""
        return _blocks_swig1.stream_to_streams_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(stream_to_streams_sptr self) -> double"""
        return _blocks_swig1.stream_to_streams_sptr_relative_rate(self)


    def start(self):
        """start(stream_to_streams_sptr self) -> bool"""
        return _blocks_swig1.stream_to_streams_sptr_start(self)


    def stop(self):
        """stop(stream_to_streams_sptr self) -> bool"""
        return _blocks_swig1.stream_to_streams_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(stream_to_streams_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.stream_to_streams_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(stream_to_streams_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.stream_to_streams_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(stream_to_streams_sptr self) -> int"""
        return _blocks_swig1.stream_to_streams_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(stream_to_streams_sptr self, int m)"""
        return _blocks_swig1.stream_to_streams_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(stream_to_streams_sptr self)"""
        return _blocks_swig1.stream_to_streams_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(stream_to_streams_sptr self) -> bool"""
        return _blocks_swig1.stream_to_streams_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(stream_to_streams_sptr self, int m)"""
        return _blocks_swig1.stream_to_streams_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(stream_to_streams_sptr self) -> int"""
        return _blocks_swig1.stream_to_streams_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(stream_to_streams_sptr self, int i) -> long"""
        return _blocks_swig1.stream_to_streams_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(stream_to_streams_sptr self, long max_output_buffer)
        set_max_output_buffer(stream_to_streams_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.stream_to_streams_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(stream_to_streams_sptr self, int i) -> long"""
        return _blocks_swig1.stream_to_streams_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(stream_to_streams_sptr self, long min_output_buffer)
        set_min_output_buffer(stream_to_streams_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.stream_to_streams_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(stream_to_streams_sptr self) -> float"""
        return _blocks_swig1.stream_to_streams_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(stream_to_streams_sptr self) -> float"""
        return _blocks_swig1.stream_to_streams_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(stream_to_streams_sptr self) -> float"""
        return _blocks_swig1.stream_to_streams_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(stream_to_streams_sptr self) -> float"""
        return _blocks_swig1.stream_to_streams_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(stream_to_streams_sptr self) -> float"""
        return _blocks_swig1.stream_to_streams_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(stream_to_streams_sptr self) -> float"""
        return _blocks_swig1.stream_to_streams_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(stream_to_streams_sptr self, int which) -> float
        pc_input_buffers_full(stream_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_to_streams_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(stream_to_streams_sptr self, int which) -> float
        pc_input_buffers_full_avg(stream_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_to_streams_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(stream_to_streams_sptr self, int which) -> float
        pc_input_buffers_full_var(stream_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_to_streams_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(stream_to_streams_sptr self, int which) -> float
        pc_output_buffers_full(stream_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_to_streams_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(stream_to_streams_sptr self, int which) -> float
        pc_output_buffers_full_avg(stream_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_to_streams_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(stream_to_streams_sptr self, int which) -> float
        pc_output_buffers_full_var(stream_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_to_streams_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(stream_to_streams_sptr self) -> float"""
        return _blocks_swig1.stream_to_streams_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(stream_to_streams_sptr self) -> float"""
        return _blocks_swig1.stream_to_streams_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(stream_to_streams_sptr self) -> float"""
        return _blocks_swig1.stream_to_streams_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(stream_to_streams_sptr self) -> float"""
        return _blocks_swig1.stream_to_streams_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(stream_to_streams_sptr self) -> float"""
        return _blocks_swig1.stream_to_streams_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(stream_to_streams_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.stream_to_streams_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(stream_to_streams_sptr self)"""
        return _blocks_swig1.stream_to_streams_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(stream_to_streams_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.stream_to_streams_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(stream_to_streams_sptr self) -> int"""
        return _blocks_swig1.stream_to_streams_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(stream_to_streams_sptr self) -> int"""
        return _blocks_swig1.stream_to_streams_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(stream_to_streams_sptr self, int priority) -> int"""
        return _blocks_swig1.stream_to_streams_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(stream_to_streams_sptr self) -> std::string"""
        return _blocks_swig1.stream_to_streams_sptr_name(self)


    def symbol_name(self):
        """symbol_name(stream_to_streams_sptr self) -> std::string"""
        return _blocks_swig1.stream_to_streams_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(stream_to_streams_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.stream_to_streams_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(stream_to_streams_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.stream_to_streams_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(stream_to_streams_sptr self) -> long"""
        return _blocks_swig1.stream_to_streams_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(stream_to_streams_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.stream_to_streams_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(stream_to_streams_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.stream_to_streams_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(stream_to_streams_sptr self) -> std::string"""
        return _blocks_swig1.stream_to_streams_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(stream_to_streams_sptr self, std::string name)"""
        return _blocks_swig1.stream_to_streams_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(stream_to_streams_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.stream_to_streams_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(stream_to_streams_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.stream_to_streams_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(stream_to_streams_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.stream_to_streams_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(stream_to_streams_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.stream_to_streams_sptr_message_subscribers(self, which_port)

stream_to_streams_sptr_swigregister = _blocks_swig1.stream_to_streams_sptr_swigregister
stream_to_streams_sptr_swigregister(stream_to_streams_sptr)

stream_to_streams_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
stream_to_streams = stream_to_streams.make;

class stream_to_tagged_stream_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::stream_to_tagged_stream)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::stream_to_tagged_stream)> self) -> stream_to_tagged_stream_sptr
        __init__(boost::shared_ptr<(gr::blocks::stream_to_tagged_stream)> self, stream_to_tagged_stream p) -> stream_to_tagged_stream_sptr
        """
        this = _blocks_swig1.new_stream_to_tagged_stream_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(stream_to_tagged_stream_sptr self) -> stream_to_tagged_stream"""
        return _blocks_swig1.stream_to_tagged_stream_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_stream_to_tagged_stream_sptr
    __del__ = lambda self: None

    def make(self, itemsize, vlen, packet_len, len_tag_key):
        """make(stream_to_tagged_stream_sptr self, size_t itemsize, int vlen, unsigned int packet_len, std::string const & len_tag_key) -> stream_to_tagged_stream_sptr"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_make(self, itemsize, vlen, packet_len, len_tag_key)


    def set_packet_len(self, packet_len):
        """set_packet_len(stream_to_tagged_stream_sptr self, unsigned int packet_len)"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_set_packet_len(self, packet_len)


    def set_packet_len_pmt(self, packet_len):
        """set_packet_len_pmt(stream_to_tagged_stream_sptr self, unsigned int packet_len)"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_set_packet_len_pmt(self, packet_len)


    def history(self):
        """history(stream_to_tagged_stream_sptr self) -> unsigned int"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(stream_to_tagged_stream_sptr self, int which, int delay)
        declare_sample_delay(stream_to_tagged_stream_sptr self, unsigned int delay)
        """
        return _blocks_swig1.stream_to_tagged_stream_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(stream_to_tagged_stream_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(stream_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(stream_to_tagged_stream_sptr self) -> double"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_relative_rate(self)


    def start(self):
        """start(stream_to_tagged_stream_sptr self) -> bool"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_start(self)


    def stop(self):
        """stop(stream_to_tagged_stream_sptr self) -> bool"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(stream_to_tagged_stream_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(stream_to_tagged_stream_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(stream_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(stream_to_tagged_stream_sptr self, int m)"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(stream_to_tagged_stream_sptr self)"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(stream_to_tagged_stream_sptr self) -> bool"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(stream_to_tagged_stream_sptr self, int m)"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(stream_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(stream_to_tagged_stream_sptr self, int i) -> long"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(stream_to_tagged_stream_sptr self, long max_output_buffer)
        set_max_output_buffer(stream_to_tagged_stream_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.stream_to_tagged_stream_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(stream_to_tagged_stream_sptr self, int i) -> long"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(stream_to_tagged_stream_sptr self, long min_output_buffer)
        set_min_output_buffer(stream_to_tagged_stream_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.stream_to_tagged_stream_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(stream_to_tagged_stream_sptr self, int which) -> float
        pc_input_buffers_full(stream_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_to_tagged_stream_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(stream_to_tagged_stream_sptr self, int which) -> float
        pc_input_buffers_full_avg(stream_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_to_tagged_stream_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(stream_to_tagged_stream_sptr self, int which) -> float
        pc_input_buffers_full_var(stream_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_to_tagged_stream_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(stream_to_tagged_stream_sptr self, int which) -> float
        pc_output_buffers_full(stream_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_to_tagged_stream_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(stream_to_tagged_stream_sptr self, int which) -> float
        pc_output_buffers_full_avg(stream_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_to_tagged_stream_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(stream_to_tagged_stream_sptr self, int which) -> float
        pc_output_buffers_full_var(stream_to_tagged_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_to_tagged_stream_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(stream_to_tagged_stream_sptr self) -> float"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(stream_to_tagged_stream_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(stream_to_tagged_stream_sptr self)"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(stream_to_tagged_stream_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(stream_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(stream_to_tagged_stream_sptr self) -> int"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(stream_to_tagged_stream_sptr self, int priority) -> int"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(stream_to_tagged_stream_sptr self) -> std::string"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_name(self)


    def symbol_name(self):
        """symbol_name(stream_to_tagged_stream_sptr self) -> std::string"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(stream_to_tagged_stream_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(stream_to_tagged_stream_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(stream_to_tagged_stream_sptr self) -> long"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(stream_to_tagged_stream_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(stream_to_tagged_stream_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(stream_to_tagged_stream_sptr self) -> std::string"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(stream_to_tagged_stream_sptr self, std::string name)"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(stream_to_tagged_stream_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.stream_to_tagged_stream_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(stream_to_tagged_stream_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(stream_to_tagged_stream_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(stream_to_tagged_stream_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.stream_to_tagged_stream_sptr_message_subscribers(self, which_port)

stream_to_tagged_stream_sptr_swigregister = _blocks_swig1.stream_to_tagged_stream_sptr_swigregister
stream_to_tagged_stream_sptr_swigregister(stream_to_tagged_stream_sptr)

stream_to_tagged_stream_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
stream_to_tagged_stream = stream_to_tagged_stream.make;

class stream_to_vector_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::stream_to_vector)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::stream_to_vector)> self) -> stream_to_vector_sptr
        __init__(boost::shared_ptr<(gr::blocks::stream_to_vector)> self, stream_to_vector p) -> stream_to_vector_sptr
        """
        this = _blocks_swig1.new_stream_to_vector_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(stream_to_vector_sptr self) -> stream_to_vector"""
        return _blocks_swig1.stream_to_vector_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_stream_to_vector_sptr
    __del__ = lambda self: None

    def make(self, itemsize, nitems_per_block):
        """make(stream_to_vector_sptr self, size_t itemsize, size_t nitems_per_block) -> stream_to_vector_sptr"""
        return _blocks_swig1.stream_to_vector_sptr_make(self, itemsize, nitems_per_block)


    def history(self):
        """history(stream_to_vector_sptr self) -> unsigned int"""
        return _blocks_swig1.stream_to_vector_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(stream_to_vector_sptr self, int which, int delay)
        declare_sample_delay(stream_to_vector_sptr self, unsigned int delay)
        """
        return _blocks_swig1.stream_to_vector_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(stream_to_vector_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.stream_to_vector_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(stream_to_vector_sptr self) -> int"""
        return _blocks_swig1.stream_to_vector_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(stream_to_vector_sptr self) -> double"""
        return _blocks_swig1.stream_to_vector_sptr_relative_rate(self)


    def start(self):
        """start(stream_to_vector_sptr self) -> bool"""
        return _blocks_swig1.stream_to_vector_sptr_start(self)


    def stop(self):
        """stop(stream_to_vector_sptr self) -> bool"""
        return _blocks_swig1.stream_to_vector_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(stream_to_vector_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.stream_to_vector_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(stream_to_vector_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.stream_to_vector_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(stream_to_vector_sptr self) -> int"""
        return _blocks_swig1.stream_to_vector_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(stream_to_vector_sptr self, int m)"""
        return _blocks_swig1.stream_to_vector_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(stream_to_vector_sptr self)"""
        return _blocks_swig1.stream_to_vector_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(stream_to_vector_sptr self) -> bool"""
        return _blocks_swig1.stream_to_vector_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(stream_to_vector_sptr self, int m)"""
        return _blocks_swig1.stream_to_vector_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(stream_to_vector_sptr self) -> int"""
        return _blocks_swig1.stream_to_vector_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(stream_to_vector_sptr self, int i) -> long"""
        return _blocks_swig1.stream_to_vector_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(stream_to_vector_sptr self, long max_output_buffer)
        set_max_output_buffer(stream_to_vector_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.stream_to_vector_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(stream_to_vector_sptr self, int i) -> long"""
        return _blocks_swig1.stream_to_vector_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(stream_to_vector_sptr self, long min_output_buffer)
        set_min_output_buffer(stream_to_vector_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.stream_to_vector_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(stream_to_vector_sptr self) -> float"""
        return _blocks_swig1.stream_to_vector_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(stream_to_vector_sptr self) -> float"""
        return _blocks_swig1.stream_to_vector_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(stream_to_vector_sptr self) -> float"""
        return _blocks_swig1.stream_to_vector_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(stream_to_vector_sptr self) -> float"""
        return _blocks_swig1.stream_to_vector_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(stream_to_vector_sptr self) -> float"""
        return _blocks_swig1.stream_to_vector_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(stream_to_vector_sptr self) -> float"""
        return _blocks_swig1.stream_to_vector_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(stream_to_vector_sptr self, int which) -> float
        pc_input_buffers_full(stream_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_to_vector_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(stream_to_vector_sptr self, int which) -> float
        pc_input_buffers_full_avg(stream_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_to_vector_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(stream_to_vector_sptr self, int which) -> float
        pc_input_buffers_full_var(stream_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_to_vector_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(stream_to_vector_sptr self, int which) -> float
        pc_output_buffers_full(stream_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_to_vector_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(stream_to_vector_sptr self, int which) -> float
        pc_output_buffers_full_avg(stream_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_to_vector_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(stream_to_vector_sptr self, int which) -> float
        pc_output_buffers_full_var(stream_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.stream_to_vector_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(stream_to_vector_sptr self) -> float"""
        return _blocks_swig1.stream_to_vector_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(stream_to_vector_sptr self) -> float"""
        return _blocks_swig1.stream_to_vector_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(stream_to_vector_sptr self) -> float"""
        return _blocks_swig1.stream_to_vector_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(stream_to_vector_sptr self) -> float"""
        return _blocks_swig1.stream_to_vector_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(stream_to_vector_sptr self) -> float"""
        return _blocks_swig1.stream_to_vector_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(stream_to_vector_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.stream_to_vector_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(stream_to_vector_sptr self)"""
        return _blocks_swig1.stream_to_vector_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(stream_to_vector_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.stream_to_vector_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(stream_to_vector_sptr self) -> int"""
        return _blocks_swig1.stream_to_vector_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(stream_to_vector_sptr self) -> int"""
        return _blocks_swig1.stream_to_vector_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(stream_to_vector_sptr self, int priority) -> int"""
        return _blocks_swig1.stream_to_vector_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(stream_to_vector_sptr self) -> std::string"""
        return _blocks_swig1.stream_to_vector_sptr_name(self)


    def symbol_name(self):
        """symbol_name(stream_to_vector_sptr self) -> std::string"""
        return _blocks_swig1.stream_to_vector_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(stream_to_vector_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.stream_to_vector_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(stream_to_vector_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.stream_to_vector_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(stream_to_vector_sptr self) -> long"""
        return _blocks_swig1.stream_to_vector_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(stream_to_vector_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.stream_to_vector_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(stream_to_vector_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.stream_to_vector_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(stream_to_vector_sptr self) -> std::string"""
        return _blocks_swig1.stream_to_vector_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(stream_to_vector_sptr self, std::string name)"""
        return _blocks_swig1.stream_to_vector_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(stream_to_vector_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.stream_to_vector_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(stream_to_vector_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.stream_to_vector_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(stream_to_vector_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.stream_to_vector_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(stream_to_vector_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.stream_to_vector_sptr_message_subscribers(self, which_port)

stream_to_vector_sptr_swigregister = _blocks_swig1.stream_to_vector_sptr_swigregister
stream_to_vector_sptr_swigregister(stream_to_vector_sptr)

stream_to_vector_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
stream_to_vector = stream_to_vector.make;

class streams_to_stream_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::streams_to_stream)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::streams_to_stream)> self) -> streams_to_stream_sptr
        __init__(boost::shared_ptr<(gr::blocks::streams_to_stream)> self, streams_to_stream p) -> streams_to_stream_sptr
        """
        this = _blocks_swig1.new_streams_to_stream_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(streams_to_stream_sptr self) -> streams_to_stream"""
        return _blocks_swig1.streams_to_stream_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_streams_to_stream_sptr
    __del__ = lambda self: None

    def make(self, itemsize, nstreams):
        """make(streams_to_stream_sptr self, size_t itemsize, size_t nstreams) -> streams_to_stream_sptr"""
        return _blocks_swig1.streams_to_stream_sptr_make(self, itemsize, nstreams)


    def history(self):
        """history(streams_to_stream_sptr self) -> unsigned int"""
        return _blocks_swig1.streams_to_stream_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(streams_to_stream_sptr self, int which, int delay)
        declare_sample_delay(streams_to_stream_sptr self, unsigned int delay)
        """
        return _blocks_swig1.streams_to_stream_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(streams_to_stream_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.streams_to_stream_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(streams_to_stream_sptr self) -> int"""
        return _blocks_swig1.streams_to_stream_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(streams_to_stream_sptr self) -> double"""
        return _blocks_swig1.streams_to_stream_sptr_relative_rate(self)


    def start(self):
        """start(streams_to_stream_sptr self) -> bool"""
        return _blocks_swig1.streams_to_stream_sptr_start(self)


    def stop(self):
        """stop(streams_to_stream_sptr self) -> bool"""
        return _blocks_swig1.streams_to_stream_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(streams_to_stream_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.streams_to_stream_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(streams_to_stream_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.streams_to_stream_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(streams_to_stream_sptr self) -> int"""
        return _blocks_swig1.streams_to_stream_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(streams_to_stream_sptr self, int m)"""
        return _blocks_swig1.streams_to_stream_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(streams_to_stream_sptr self)"""
        return _blocks_swig1.streams_to_stream_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(streams_to_stream_sptr self) -> bool"""
        return _blocks_swig1.streams_to_stream_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(streams_to_stream_sptr self, int m)"""
        return _blocks_swig1.streams_to_stream_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(streams_to_stream_sptr self) -> int"""
        return _blocks_swig1.streams_to_stream_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(streams_to_stream_sptr self, int i) -> long"""
        return _blocks_swig1.streams_to_stream_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(streams_to_stream_sptr self, long max_output_buffer)
        set_max_output_buffer(streams_to_stream_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.streams_to_stream_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(streams_to_stream_sptr self, int i) -> long"""
        return _blocks_swig1.streams_to_stream_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(streams_to_stream_sptr self, long min_output_buffer)
        set_min_output_buffer(streams_to_stream_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.streams_to_stream_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(streams_to_stream_sptr self) -> float"""
        return _blocks_swig1.streams_to_stream_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(streams_to_stream_sptr self) -> float"""
        return _blocks_swig1.streams_to_stream_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(streams_to_stream_sptr self) -> float"""
        return _blocks_swig1.streams_to_stream_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(streams_to_stream_sptr self) -> float"""
        return _blocks_swig1.streams_to_stream_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(streams_to_stream_sptr self) -> float"""
        return _blocks_swig1.streams_to_stream_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(streams_to_stream_sptr self) -> float"""
        return _blocks_swig1.streams_to_stream_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(streams_to_stream_sptr self, int which) -> float
        pc_input_buffers_full(streams_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.streams_to_stream_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(streams_to_stream_sptr self, int which) -> float
        pc_input_buffers_full_avg(streams_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.streams_to_stream_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(streams_to_stream_sptr self, int which) -> float
        pc_input_buffers_full_var(streams_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.streams_to_stream_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(streams_to_stream_sptr self, int which) -> float
        pc_output_buffers_full(streams_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.streams_to_stream_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(streams_to_stream_sptr self, int which) -> float
        pc_output_buffers_full_avg(streams_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.streams_to_stream_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(streams_to_stream_sptr self, int which) -> float
        pc_output_buffers_full_var(streams_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.streams_to_stream_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(streams_to_stream_sptr self) -> float"""
        return _blocks_swig1.streams_to_stream_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(streams_to_stream_sptr self) -> float"""
        return _blocks_swig1.streams_to_stream_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(streams_to_stream_sptr self) -> float"""
        return _blocks_swig1.streams_to_stream_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(streams_to_stream_sptr self) -> float"""
        return _blocks_swig1.streams_to_stream_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(streams_to_stream_sptr self) -> float"""
        return _blocks_swig1.streams_to_stream_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(streams_to_stream_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.streams_to_stream_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(streams_to_stream_sptr self)"""
        return _blocks_swig1.streams_to_stream_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(streams_to_stream_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.streams_to_stream_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(streams_to_stream_sptr self) -> int"""
        return _blocks_swig1.streams_to_stream_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(streams_to_stream_sptr self) -> int"""
        return _blocks_swig1.streams_to_stream_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(streams_to_stream_sptr self, int priority) -> int"""
        return _blocks_swig1.streams_to_stream_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(streams_to_stream_sptr self) -> std::string"""
        return _blocks_swig1.streams_to_stream_sptr_name(self)


    def symbol_name(self):
        """symbol_name(streams_to_stream_sptr self) -> std::string"""
        return _blocks_swig1.streams_to_stream_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(streams_to_stream_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.streams_to_stream_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(streams_to_stream_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.streams_to_stream_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(streams_to_stream_sptr self) -> long"""
        return _blocks_swig1.streams_to_stream_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(streams_to_stream_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.streams_to_stream_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(streams_to_stream_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.streams_to_stream_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(streams_to_stream_sptr self) -> std::string"""
        return _blocks_swig1.streams_to_stream_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(streams_to_stream_sptr self, std::string name)"""
        return _blocks_swig1.streams_to_stream_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(streams_to_stream_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.streams_to_stream_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(streams_to_stream_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.streams_to_stream_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(streams_to_stream_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.streams_to_stream_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(streams_to_stream_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.streams_to_stream_sptr_message_subscribers(self, which_port)

streams_to_stream_sptr_swigregister = _blocks_swig1.streams_to_stream_sptr_swigregister
streams_to_stream_sptr_swigregister(streams_to_stream_sptr)

streams_to_stream_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
streams_to_stream = streams_to_stream.make;

class streams_to_vector_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::streams_to_vector)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::streams_to_vector)> self) -> streams_to_vector_sptr
        __init__(boost::shared_ptr<(gr::blocks::streams_to_vector)> self, streams_to_vector p) -> streams_to_vector_sptr
        """
        this = _blocks_swig1.new_streams_to_vector_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(streams_to_vector_sptr self) -> streams_to_vector"""
        return _blocks_swig1.streams_to_vector_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_streams_to_vector_sptr
    __del__ = lambda self: None

    def make(self, itemsize, nstreams):
        """make(streams_to_vector_sptr self, size_t itemsize, size_t nstreams) -> streams_to_vector_sptr"""
        return _blocks_swig1.streams_to_vector_sptr_make(self, itemsize, nstreams)


    def history(self):
        """history(streams_to_vector_sptr self) -> unsigned int"""
        return _blocks_swig1.streams_to_vector_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(streams_to_vector_sptr self, int which, int delay)
        declare_sample_delay(streams_to_vector_sptr self, unsigned int delay)
        """
        return _blocks_swig1.streams_to_vector_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(streams_to_vector_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.streams_to_vector_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(streams_to_vector_sptr self) -> int"""
        return _blocks_swig1.streams_to_vector_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(streams_to_vector_sptr self) -> double"""
        return _blocks_swig1.streams_to_vector_sptr_relative_rate(self)


    def start(self):
        """start(streams_to_vector_sptr self) -> bool"""
        return _blocks_swig1.streams_to_vector_sptr_start(self)


    def stop(self):
        """stop(streams_to_vector_sptr self) -> bool"""
        return _blocks_swig1.streams_to_vector_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(streams_to_vector_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.streams_to_vector_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(streams_to_vector_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.streams_to_vector_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(streams_to_vector_sptr self) -> int"""
        return _blocks_swig1.streams_to_vector_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(streams_to_vector_sptr self, int m)"""
        return _blocks_swig1.streams_to_vector_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(streams_to_vector_sptr self)"""
        return _blocks_swig1.streams_to_vector_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(streams_to_vector_sptr self) -> bool"""
        return _blocks_swig1.streams_to_vector_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(streams_to_vector_sptr self, int m)"""
        return _blocks_swig1.streams_to_vector_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(streams_to_vector_sptr self) -> int"""
        return _blocks_swig1.streams_to_vector_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(streams_to_vector_sptr self, int i) -> long"""
        return _blocks_swig1.streams_to_vector_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(streams_to_vector_sptr self, long max_output_buffer)
        set_max_output_buffer(streams_to_vector_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.streams_to_vector_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(streams_to_vector_sptr self, int i) -> long"""
        return _blocks_swig1.streams_to_vector_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(streams_to_vector_sptr self, long min_output_buffer)
        set_min_output_buffer(streams_to_vector_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.streams_to_vector_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(streams_to_vector_sptr self) -> float"""
        return _blocks_swig1.streams_to_vector_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(streams_to_vector_sptr self) -> float"""
        return _blocks_swig1.streams_to_vector_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(streams_to_vector_sptr self) -> float"""
        return _blocks_swig1.streams_to_vector_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(streams_to_vector_sptr self) -> float"""
        return _blocks_swig1.streams_to_vector_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(streams_to_vector_sptr self) -> float"""
        return _blocks_swig1.streams_to_vector_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(streams_to_vector_sptr self) -> float"""
        return _blocks_swig1.streams_to_vector_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(streams_to_vector_sptr self, int which) -> float
        pc_input_buffers_full(streams_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.streams_to_vector_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(streams_to_vector_sptr self, int which) -> float
        pc_input_buffers_full_avg(streams_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.streams_to_vector_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(streams_to_vector_sptr self, int which) -> float
        pc_input_buffers_full_var(streams_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.streams_to_vector_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(streams_to_vector_sptr self, int which) -> float
        pc_output_buffers_full(streams_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.streams_to_vector_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(streams_to_vector_sptr self, int which) -> float
        pc_output_buffers_full_avg(streams_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.streams_to_vector_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(streams_to_vector_sptr self, int which) -> float
        pc_output_buffers_full_var(streams_to_vector_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.streams_to_vector_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(streams_to_vector_sptr self) -> float"""
        return _blocks_swig1.streams_to_vector_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(streams_to_vector_sptr self) -> float"""
        return _blocks_swig1.streams_to_vector_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(streams_to_vector_sptr self) -> float"""
        return _blocks_swig1.streams_to_vector_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(streams_to_vector_sptr self) -> float"""
        return _blocks_swig1.streams_to_vector_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(streams_to_vector_sptr self) -> float"""
        return _blocks_swig1.streams_to_vector_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(streams_to_vector_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.streams_to_vector_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(streams_to_vector_sptr self)"""
        return _blocks_swig1.streams_to_vector_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(streams_to_vector_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.streams_to_vector_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(streams_to_vector_sptr self) -> int"""
        return _blocks_swig1.streams_to_vector_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(streams_to_vector_sptr self) -> int"""
        return _blocks_swig1.streams_to_vector_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(streams_to_vector_sptr self, int priority) -> int"""
        return _blocks_swig1.streams_to_vector_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(streams_to_vector_sptr self) -> std::string"""
        return _blocks_swig1.streams_to_vector_sptr_name(self)


    def symbol_name(self):
        """symbol_name(streams_to_vector_sptr self) -> std::string"""
        return _blocks_swig1.streams_to_vector_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(streams_to_vector_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.streams_to_vector_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(streams_to_vector_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.streams_to_vector_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(streams_to_vector_sptr self) -> long"""
        return _blocks_swig1.streams_to_vector_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(streams_to_vector_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.streams_to_vector_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(streams_to_vector_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.streams_to_vector_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(streams_to_vector_sptr self) -> std::string"""
        return _blocks_swig1.streams_to_vector_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(streams_to_vector_sptr self, std::string name)"""
        return _blocks_swig1.streams_to_vector_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(streams_to_vector_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.streams_to_vector_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(streams_to_vector_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.streams_to_vector_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(streams_to_vector_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.streams_to_vector_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(streams_to_vector_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.streams_to_vector_sptr_message_subscribers(self, which_port)

streams_to_vector_sptr_swigregister = _blocks_swig1.streams_to_vector_sptr_swigregister
streams_to_vector_sptr_swigregister(streams_to_vector_sptr)

streams_to_vector_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
streams_to_vector = streams_to_vector.make;

class tag_debug_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tag_debug)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::tag_debug)> self) -> tag_debug_sptr
        __init__(boost::shared_ptr<(gr::blocks::tag_debug)> self, tag_debug p) -> tag_debug_sptr
        """
        this = _blocks_swig1.new_tag_debug_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(tag_debug_sptr self) -> tag_debug"""
        return _blocks_swig1.tag_debug_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_tag_debug_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(tag_debug_sptr self, size_t sizeof_stream_item, std::string const & name, std::string const & key_filter) -> tag_debug_sptr"""
        return _blocks_swig1.tag_debug_sptr_make(self, *args, **kwargs)


    def current_tags(self):
        """current_tags(tag_debug_sptr self) -> tags_vector_t"""
        return _blocks_swig1.tag_debug_sptr_current_tags(self)


    def num_tags(self):
        """num_tags(tag_debug_sptr self) -> int"""
        return _blocks_swig1.tag_debug_sptr_num_tags(self)


    def set_display(self, d):
        """set_display(tag_debug_sptr self, bool d)"""
        return _blocks_swig1.tag_debug_sptr_set_display(self, d)


    def set_key_filter(self, key_filter):
        """set_key_filter(tag_debug_sptr self, std::string const & key_filter)"""
        return _blocks_swig1.tag_debug_sptr_set_key_filter(self, key_filter)


    def key_filter(self):
        """key_filter(tag_debug_sptr self) -> std::string"""
        return _blocks_swig1.tag_debug_sptr_key_filter(self)


    def history(self):
        """history(tag_debug_sptr self) -> unsigned int"""
        return _blocks_swig1.tag_debug_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tag_debug_sptr self, int which, int delay)
        declare_sample_delay(tag_debug_sptr self, unsigned int delay)
        """
        return _blocks_swig1.tag_debug_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tag_debug_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.tag_debug_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tag_debug_sptr self) -> int"""
        return _blocks_swig1.tag_debug_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tag_debug_sptr self) -> double"""
        return _blocks_swig1.tag_debug_sptr_relative_rate(self)


    def start(self):
        """start(tag_debug_sptr self) -> bool"""
        return _blocks_swig1.tag_debug_sptr_start(self)


    def stop(self):
        """stop(tag_debug_sptr self) -> bool"""
        return _blocks_swig1.tag_debug_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tag_debug_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.tag_debug_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tag_debug_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.tag_debug_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tag_debug_sptr self) -> int"""
        return _blocks_swig1.tag_debug_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tag_debug_sptr self, int m)"""
        return _blocks_swig1.tag_debug_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tag_debug_sptr self)"""
        return _blocks_swig1.tag_debug_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tag_debug_sptr self) -> bool"""
        return _blocks_swig1.tag_debug_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tag_debug_sptr self, int m)"""
        return _blocks_swig1.tag_debug_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tag_debug_sptr self) -> int"""
        return _blocks_swig1.tag_debug_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tag_debug_sptr self, int i) -> long"""
        return _blocks_swig1.tag_debug_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tag_debug_sptr self, long max_output_buffer)
        set_max_output_buffer(tag_debug_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.tag_debug_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tag_debug_sptr self, int i) -> long"""
        return _blocks_swig1.tag_debug_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tag_debug_sptr self, long min_output_buffer)
        set_min_output_buffer(tag_debug_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.tag_debug_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tag_debug_sptr self) -> float"""
        return _blocks_swig1.tag_debug_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tag_debug_sptr self) -> float"""
        return _blocks_swig1.tag_debug_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tag_debug_sptr self) -> float"""
        return _blocks_swig1.tag_debug_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tag_debug_sptr self) -> float"""
        return _blocks_swig1.tag_debug_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tag_debug_sptr self) -> float"""
        return _blocks_swig1.tag_debug_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tag_debug_sptr self) -> float"""
        return _blocks_swig1.tag_debug_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tag_debug_sptr self, int which) -> float
        pc_input_buffers_full(tag_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tag_debug_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tag_debug_sptr self, int which) -> float
        pc_input_buffers_full_avg(tag_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tag_debug_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tag_debug_sptr self, int which) -> float
        pc_input_buffers_full_var(tag_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tag_debug_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tag_debug_sptr self, int which) -> float
        pc_output_buffers_full(tag_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tag_debug_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tag_debug_sptr self, int which) -> float
        pc_output_buffers_full_avg(tag_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tag_debug_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tag_debug_sptr self, int which) -> float
        pc_output_buffers_full_var(tag_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tag_debug_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tag_debug_sptr self) -> float"""
        return _blocks_swig1.tag_debug_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tag_debug_sptr self) -> float"""
        return _blocks_swig1.tag_debug_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tag_debug_sptr self) -> float"""
        return _blocks_swig1.tag_debug_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tag_debug_sptr self) -> float"""
        return _blocks_swig1.tag_debug_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tag_debug_sptr self) -> float"""
        return _blocks_swig1.tag_debug_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tag_debug_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.tag_debug_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tag_debug_sptr self)"""
        return _blocks_swig1.tag_debug_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tag_debug_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.tag_debug_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tag_debug_sptr self) -> int"""
        return _blocks_swig1.tag_debug_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tag_debug_sptr self) -> int"""
        return _blocks_swig1.tag_debug_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tag_debug_sptr self, int priority) -> int"""
        return _blocks_swig1.tag_debug_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tag_debug_sptr self) -> std::string"""
        return _blocks_swig1.tag_debug_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tag_debug_sptr self) -> std::string"""
        return _blocks_swig1.tag_debug_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tag_debug_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.tag_debug_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tag_debug_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.tag_debug_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tag_debug_sptr self) -> long"""
        return _blocks_swig1.tag_debug_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tag_debug_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.tag_debug_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tag_debug_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.tag_debug_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tag_debug_sptr self) -> std::string"""
        return _blocks_swig1.tag_debug_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tag_debug_sptr self, std::string name)"""
        return _blocks_swig1.tag_debug_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tag_debug_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.tag_debug_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tag_debug_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.tag_debug_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tag_debug_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.tag_debug_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tag_debug_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.tag_debug_sptr_message_subscribers(self, which_port)

tag_debug_sptr_swigregister = _blocks_swig1.tag_debug_sptr_swigregister
tag_debug_sptr_swigregister(tag_debug_sptr)

tag_debug_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tag_debug = tag_debug.make;

class tagged_file_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tagged_file_sink)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::tagged_file_sink)> self) -> tagged_file_sink_sptr
        __init__(boost::shared_ptr<(gr::blocks::tagged_file_sink)> self, tagged_file_sink p) -> tagged_file_sink_sptr
        """
        this = _blocks_swig1.new_tagged_file_sink_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(tagged_file_sink_sptr self) -> tagged_file_sink"""
        return _blocks_swig1.tagged_file_sink_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_tagged_file_sink_sptr
    __del__ = lambda self: None

    def make(self, itemsize, samp_rate):
        """make(tagged_file_sink_sptr self, size_t itemsize, double samp_rate) -> tagged_file_sink_sptr"""
        return _blocks_swig1.tagged_file_sink_sptr_make(self, itemsize, samp_rate)


    def history(self):
        """history(tagged_file_sink_sptr self) -> unsigned int"""
        return _blocks_swig1.tagged_file_sink_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tagged_file_sink_sptr self, int which, int delay)
        declare_sample_delay(tagged_file_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig1.tagged_file_sink_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tagged_file_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.tagged_file_sink_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tagged_file_sink_sptr self) -> int"""
        return _blocks_swig1.tagged_file_sink_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tagged_file_sink_sptr self) -> double"""
        return _blocks_swig1.tagged_file_sink_sptr_relative_rate(self)


    def start(self):
        """start(tagged_file_sink_sptr self) -> bool"""
        return _blocks_swig1.tagged_file_sink_sptr_start(self)


    def stop(self):
        """stop(tagged_file_sink_sptr self) -> bool"""
        return _blocks_swig1.tagged_file_sink_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tagged_file_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.tagged_file_sink_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tagged_file_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.tagged_file_sink_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tagged_file_sink_sptr self) -> int"""
        return _blocks_swig1.tagged_file_sink_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tagged_file_sink_sptr self, int m)"""
        return _blocks_swig1.tagged_file_sink_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tagged_file_sink_sptr self)"""
        return _blocks_swig1.tagged_file_sink_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tagged_file_sink_sptr self) -> bool"""
        return _blocks_swig1.tagged_file_sink_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tagged_file_sink_sptr self, int m)"""
        return _blocks_swig1.tagged_file_sink_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tagged_file_sink_sptr self) -> int"""
        return _blocks_swig1.tagged_file_sink_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tagged_file_sink_sptr self, int i) -> long"""
        return _blocks_swig1.tagged_file_sink_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tagged_file_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(tagged_file_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.tagged_file_sink_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tagged_file_sink_sptr self, int i) -> long"""
        return _blocks_swig1.tagged_file_sink_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tagged_file_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(tagged_file_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.tagged_file_sink_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig1.tagged_file_sink_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig1.tagged_file_sink_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig1.tagged_file_sink_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig1.tagged_file_sink_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig1.tagged_file_sink_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig1.tagged_file_sink_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tagged_file_sink_sptr self, int which) -> float
        pc_input_buffers_full(tagged_file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tagged_file_sink_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tagged_file_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(tagged_file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tagged_file_sink_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tagged_file_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(tagged_file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tagged_file_sink_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tagged_file_sink_sptr self, int which) -> float
        pc_output_buffers_full(tagged_file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tagged_file_sink_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tagged_file_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(tagged_file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tagged_file_sink_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tagged_file_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(tagged_file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tagged_file_sink_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig1.tagged_file_sink_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig1.tagged_file_sink_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig1.tagged_file_sink_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig1.tagged_file_sink_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tagged_file_sink_sptr self) -> float"""
        return _blocks_swig1.tagged_file_sink_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tagged_file_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.tagged_file_sink_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tagged_file_sink_sptr self)"""
        return _blocks_swig1.tagged_file_sink_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tagged_file_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.tagged_file_sink_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tagged_file_sink_sptr self) -> int"""
        return _blocks_swig1.tagged_file_sink_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tagged_file_sink_sptr self) -> int"""
        return _blocks_swig1.tagged_file_sink_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tagged_file_sink_sptr self, int priority) -> int"""
        return _blocks_swig1.tagged_file_sink_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tagged_file_sink_sptr self) -> std::string"""
        return _blocks_swig1.tagged_file_sink_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tagged_file_sink_sptr self) -> std::string"""
        return _blocks_swig1.tagged_file_sink_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tagged_file_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.tagged_file_sink_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tagged_file_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.tagged_file_sink_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tagged_file_sink_sptr self) -> long"""
        return _blocks_swig1.tagged_file_sink_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tagged_file_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.tagged_file_sink_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tagged_file_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.tagged_file_sink_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tagged_file_sink_sptr self) -> std::string"""
        return _blocks_swig1.tagged_file_sink_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tagged_file_sink_sptr self, std::string name)"""
        return _blocks_swig1.tagged_file_sink_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tagged_file_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.tagged_file_sink_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tagged_file_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.tagged_file_sink_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tagged_file_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.tagged_file_sink_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tagged_file_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.tagged_file_sink_sptr_message_subscribers(self, which_port)

tagged_file_sink_sptr_swigregister = _blocks_swig1.tagged_file_sink_sptr_swigregister
tagged_file_sink_sptr_swigregister(tagged_file_sink_sptr)

tagged_file_sink_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tagged_file_sink = tagged_file_sink.make;

class tsb_vector_sink_b_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tsb_vector_sink_b)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_b)> self) -> tsb_vector_sink_b_sptr
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_b)> self, tsb_vector_sink_b p) -> tsb_vector_sink_b_sptr
        """
        this = _blocks_swig1.new_tsb_vector_sink_b_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(tsb_vector_sink_b_sptr self) -> tsb_vector_sink_b"""
        return _blocks_swig1.tsb_vector_sink_b_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_tsb_vector_sink_b_sptr
    __del__ = lambda self: None

    def reset(self):
        """reset(tsb_vector_sink_b_sptr self)"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_reset(self)


    def data(self):
        """data(tsb_vector_sink_b_sptr self) -> std::vector< std::vector< unsigned char,std::allocator< unsigned char > >,std::allocator< std::vector< unsigned char,std::allocator< unsigned char > > > >"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_data(self)


    def tags(self):
        """tags(tsb_vector_sink_b_sptr self) -> tags_vector_t"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_tags(self)


    def make(self, *args, **kwargs):
        """make(tsb_vector_sink_b_sptr self, int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_b_sptr"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_make(self, *args, **kwargs)


    def history(self):
        """history(tsb_vector_sink_b_sptr self) -> unsigned int"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tsb_vector_sink_b_sptr self, int which, int delay)
        declare_sample_delay(tsb_vector_sink_b_sptr self, unsigned int delay)
        """
        return _blocks_swig1.tsb_vector_sink_b_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tsb_vector_sink_b_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tsb_vector_sink_b_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tsb_vector_sink_b_sptr self) -> double"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_relative_rate(self)


    def start(self):
        """start(tsb_vector_sink_b_sptr self) -> bool"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_start(self)


    def stop(self):
        """stop(tsb_vector_sink_b_sptr self) -> bool"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tsb_vector_sink_b_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tsb_vector_sink_b_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tsb_vector_sink_b_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tsb_vector_sink_b_sptr self, int m)"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tsb_vector_sink_b_sptr self)"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tsb_vector_sink_b_sptr self) -> bool"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tsb_vector_sink_b_sptr self, int m)"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tsb_vector_sink_b_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tsb_vector_sink_b_sptr self, int i) -> long"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tsb_vector_sink_b_sptr self, long max_output_buffer)
        set_max_output_buffer(tsb_vector_sink_b_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.tsb_vector_sink_b_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tsb_vector_sink_b_sptr self, int i) -> long"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tsb_vector_sink_b_sptr self, long min_output_buffer)
        set_min_output_buffer(tsb_vector_sink_b_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.tsb_vector_sink_b_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tsb_vector_sink_b_sptr self, int which) -> float
        pc_input_buffers_full(tsb_vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_b_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tsb_vector_sink_b_sptr self, int which) -> float
        pc_input_buffers_full_avg(tsb_vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_b_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tsb_vector_sink_b_sptr self, int which) -> float
        pc_input_buffers_full_var(tsb_vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_b_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tsb_vector_sink_b_sptr self, int which) -> float
        pc_output_buffers_full(tsb_vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_b_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tsb_vector_sink_b_sptr self, int which) -> float
        pc_output_buffers_full_avg(tsb_vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_b_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tsb_vector_sink_b_sptr self, int which) -> float
        pc_output_buffers_full_var(tsb_vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_b_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tsb_vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tsb_vector_sink_b_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tsb_vector_sink_b_sptr self)"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tsb_vector_sink_b_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tsb_vector_sink_b_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tsb_vector_sink_b_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tsb_vector_sink_b_sptr self, int priority) -> int"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tsb_vector_sink_b_sptr self) -> std::string"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tsb_vector_sink_b_sptr self) -> std::string"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tsb_vector_sink_b_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tsb_vector_sink_b_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tsb_vector_sink_b_sptr self) -> long"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tsb_vector_sink_b_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tsb_vector_sink_b_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tsb_vector_sink_b_sptr self) -> std::string"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tsb_vector_sink_b_sptr self, std::string name)"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tsb_vector_sink_b_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.tsb_vector_sink_b_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tsb_vector_sink_b_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tsb_vector_sink_b_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tsb_vector_sink_b_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.tsb_vector_sink_b_sptr_message_subscribers(self, which_port)

tsb_vector_sink_b_sptr_swigregister = _blocks_swig1.tsb_vector_sink_b_sptr_swigregister
tsb_vector_sink_b_sptr_swigregister(tsb_vector_sink_b_sptr)

tsb_vector_sink_b_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tsb_vector_sink_b = tsb_vector_sink_b.make;

class tsb_vector_sink_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tsb_vector_sink_c)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_c)> self) -> tsb_vector_sink_c_sptr
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_c)> self, tsb_vector_sink_c p) -> tsb_vector_sink_c_sptr
        """
        this = _blocks_swig1.new_tsb_vector_sink_c_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(tsb_vector_sink_c_sptr self) -> tsb_vector_sink_c"""
        return _blocks_swig1.tsb_vector_sink_c_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_tsb_vector_sink_c_sptr
    __del__ = lambda self: None

    def reset(self):
        """reset(tsb_vector_sink_c_sptr self)"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_reset(self)


    def data(self):
        """data(tsb_vector_sink_c_sptr self) -> gr_vector_vector_complexf"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_data(self)


    def tags(self):
        """tags(tsb_vector_sink_c_sptr self) -> tags_vector_t"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_tags(self)


    def make(self, *args, **kwargs):
        """make(tsb_vector_sink_c_sptr self, int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_c_sptr"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_make(self, *args, **kwargs)


    def history(self):
        """history(tsb_vector_sink_c_sptr self) -> unsigned int"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tsb_vector_sink_c_sptr self, int which, int delay)
        declare_sample_delay(tsb_vector_sink_c_sptr self, unsigned int delay)
        """
        return _blocks_swig1.tsb_vector_sink_c_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tsb_vector_sink_c_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tsb_vector_sink_c_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tsb_vector_sink_c_sptr self) -> double"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_relative_rate(self)


    def start(self):
        """start(tsb_vector_sink_c_sptr self) -> bool"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_start(self)


    def stop(self):
        """stop(tsb_vector_sink_c_sptr self) -> bool"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tsb_vector_sink_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tsb_vector_sink_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tsb_vector_sink_c_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tsb_vector_sink_c_sptr self, int m)"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tsb_vector_sink_c_sptr self)"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tsb_vector_sink_c_sptr self) -> bool"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tsb_vector_sink_c_sptr self, int m)"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tsb_vector_sink_c_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tsb_vector_sink_c_sptr self, int i) -> long"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tsb_vector_sink_c_sptr self, long max_output_buffer)
        set_max_output_buffer(tsb_vector_sink_c_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.tsb_vector_sink_c_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tsb_vector_sink_c_sptr self, int i) -> long"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tsb_vector_sink_c_sptr self, long min_output_buffer)
        set_min_output_buffer(tsb_vector_sink_c_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.tsb_vector_sink_c_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tsb_vector_sink_c_sptr self, int which) -> float
        pc_input_buffers_full(tsb_vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_c_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tsb_vector_sink_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(tsb_vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_c_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tsb_vector_sink_c_sptr self, int which) -> float
        pc_input_buffers_full_var(tsb_vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_c_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tsb_vector_sink_c_sptr self, int which) -> float
        pc_output_buffers_full(tsb_vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_c_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tsb_vector_sink_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(tsb_vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_c_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tsb_vector_sink_c_sptr self, int which) -> float
        pc_output_buffers_full_var(tsb_vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_c_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tsb_vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tsb_vector_sink_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tsb_vector_sink_c_sptr self)"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tsb_vector_sink_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tsb_vector_sink_c_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tsb_vector_sink_c_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tsb_vector_sink_c_sptr self, int priority) -> int"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tsb_vector_sink_c_sptr self) -> std::string"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tsb_vector_sink_c_sptr self) -> std::string"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tsb_vector_sink_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tsb_vector_sink_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tsb_vector_sink_c_sptr self) -> long"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tsb_vector_sink_c_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tsb_vector_sink_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tsb_vector_sink_c_sptr self) -> std::string"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tsb_vector_sink_c_sptr self, std::string name)"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tsb_vector_sink_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.tsb_vector_sink_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tsb_vector_sink_c_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tsb_vector_sink_c_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tsb_vector_sink_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.tsb_vector_sink_c_sptr_message_subscribers(self, which_port)

tsb_vector_sink_c_sptr_swigregister = _blocks_swig1.tsb_vector_sink_c_sptr_swigregister
tsb_vector_sink_c_sptr_swigregister(tsb_vector_sink_c_sptr)

tsb_vector_sink_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tsb_vector_sink_c = tsb_vector_sink_c.make;

class tsb_vector_sink_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tsb_vector_sink_f)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_f)> self) -> tsb_vector_sink_f_sptr
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_f)> self, tsb_vector_sink_f p) -> tsb_vector_sink_f_sptr
        """
        this = _blocks_swig1.new_tsb_vector_sink_f_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(tsb_vector_sink_f_sptr self) -> tsb_vector_sink_f"""
        return _blocks_swig1.tsb_vector_sink_f_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_tsb_vector_sink_f_sptr
    __del__ = lambda self: None

    def reset(self):
        """reset(tsb_vector_sink_f_sptr self)"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_reset(self)


    def data(self):
        """data(tsb_vector_sink_f_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_data(self)


    def tags(self):
        """tags(tsb_vector_sink_f_sptr self) -> tags_vector_t"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_tags(self)


    def make(self, *args, **kwargs):
        """make(tsb_vector_sink_f_sptr self, int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_f_sptr"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_make(self, *args, **kwargs)


    def history(self):
        """history(tsb_vector_sink_f_sptr self) -> unsigned int"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tsb_vector_sink_f_sptr self, int which, int delay)
        declare_sample_delay(tsb_vector_sink_f_sptr self, unsigned int delay)
        """
        return _blocks_swig1.tsb_vector_sink_f_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tsb_vector_sink_f_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tsb_vector_sink_f_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tsb_vector_sink_f_sptr self) -> double"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_relative_rate(self)


    def start(self):
        """start(tsb_vector_sink_f_sptr self) -> bool"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_start(self)


    def stop(self):
        """stop(tsb_vector_sink_f_sptr self) -> bool"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tsb_vector_sink_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tsb_vector_sink_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tsb_vector_sink_f_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tsb_vector_sink_f_sptr self, int m)"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tsb_vector_sink_f_sptr self)"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tsb_vector_sink_f_sptr self) -> bool"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tsb_vector_sink_f_sptr self, int m)"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tsb_vector_sink_f_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tsb_vector_sink_f_sptr self, int i) -> long"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tsb_vector_sink_f_sptr self, long max_output_buffer)
        set_max_output_buffer(tsb_vector_sink_f_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.tsb_vector_sink_f_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tsb_vector_sink_f_sptr self, int i) -> long"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tsb_vector_sink_f_sptr self, long min_output_buffer)
        set_min_output_buffer(tsb_vector_sink_f_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.tsb_vector_sink_f_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tsb_vector_sink_f_sptr self, int which) -> float
        pc_input_buffers_full(tsb_vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_f_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tsb_vector_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(tsb_vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_f_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tsb_vector_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_var(tsb_vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_f_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tsb_vector_sink_f_sptr self, int which) -> float
        pc_output_buffers_full(tsb_vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_f_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tsb_vector_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(tsb_vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_f_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tsb_vector_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_var(tsb_vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_f_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tsb_vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tsb_vector_sink_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tsb_vector_sink_f_sptr self)"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tsb_vector_sink_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tsb_vector_sink_f_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tsb_vector_sink_f_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tsb_vector_sink_f_sptr self, int priority) -> int"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tsb_vector_sink_f_sptr self) -> std::string"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tsb_vector_sink_f_sptr self) -> std::string"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tsb_vector_sink_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tsb_vector_sink_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tsb_vector_sink_f_sptr self) -> long"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tsb_vector_sink_f_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tsb_vector_sink_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tsb_vector_sink_f_sptr self) -> std::string"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tsb_vector_sink_f_sptr self, std::string name)"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tsb_vector_sink_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.tsb_vector_sink_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tsb_vector_sink_f_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tsb_vector_sink_f_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tsb_vector_sink_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.tsb_vector_sink_f_sptr_message_subscribers(self, which_port)

tsb_vector_sink_f_sptr_swigregister = _blocks_swig1.tsb_vector_sink_f_sptr_swigregister
tsb_vector_sink_f_sptr_swigregister(tsb_vector_sink_f_sptr)

tsb_vector_sink_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tsb_vector_sink_f = tsb_vector_sink_f.make;

class tsb_vector_sink_i_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tsb_vector_sink_i)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_i)> self) -> tsb_vector_sink_i_sptr
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_i)> self, tsb_vector_sink_i p) -> tsb_vector_sink_i_sptr
        """
        this = _blocks_swig1.new_tsb_vector_sink_i_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(tsb_vector_sink_i_sptr self) -> tsb_vector_sink_i"""
        return _blocks_swig1.tsb_vector_sink_i_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_tsb_vector_sink_i_sptr
    __del__ = lambda self: None

    def reset(self):
        """reset(tsb_vector_sink_i_sptr self)"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_reset(self)


    def data(self):
        """data(tsb_vector_sink_i_sptr self) -> std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_data(self)


    def tags(self):
        """tags(tsb_vector_sink_i_sptr self) -> tags_vector_t"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_tags(self)


    def make(self, *args, **kwargs):
        """make(tsb_vector_sink_i_sptr self, int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_i_sptr"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_make(self, *args, **kwargs)


    def history(self):
        """history(tsb_vector_sink_i_sptr self) -> unsigned int"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tsb_vector_sink_i_sptr self, int which, int delay)
        declare_sample_delay(tsb_vector_sink_i_sptr self, unsigned int delay)
        """
        return _blocks_swig1.tsb_vector_sink_i_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tsb_vector_sink_i_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tsb_vector_sink_i_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tsb_vector_sink_i_sptr self) -> double"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_relative_rate(self)


    def start(self):
        """start(tsb_vector_sink_i_sptr self) -> bool"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_start(self)


    def stop(self):
        """stop(tsb_vector_sink_i_sptr self) -> bool"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tsb_vector_sink_i_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tsb_vector_sink_i_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tsb_vector_sink_i_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tsb_vector_sink_i_sptr self, int m)"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tsb_vector_sink_i_sptr self)"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tsb_vector_sink_i_sptr self) -> bool"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tsb_vector_sink_i_sptr self, int m)"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tsb_vector_sink_i_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tsb_vector_sink_i_sptr self, int i) -> long"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tsb_vector_sink_i_sptr self, long max_output_buffer)
        set_max_output_buffer(tsb_vector_sink_i_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.tsb_vector_sink_i_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tsb_vector_sink_i_sptr self, int i) -> long"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tsb_vector_sink_i_sptr self, long min_output_buffer)
        set_min_output_buffer(tsb_vector_sink_i_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.tsb_vector_sink_i_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tsb_vector_sink_i_sptr self, int which) -> float
        pc_input_buffers_full(tsb_vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_i_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tsb_vector_sink_i_sptr self, int which) -> float
        pc_input_buffers_full_avg(tsb_vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_i_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tsb_vector_sink_i_sptr self, int which) -> float
        pc_input_buffers_full_var(tsb_vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_i_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tsb_vector_sink_i_sptr self, int which) -> float
        pc_output_buffers_full(tsb_vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_i_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tsb_vector_sink_i_sptr self, int which) -> float
        pc_output_buffers_full_avg(tsb_vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_i_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tsb_vector_sink_i_sptr self, int which) -> float
        pc_output_buffers_full_var(tsb_vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_i_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tsb_vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tsb_vector_sink_i_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tsb_vector_sink_i_sptr self)"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tsb_vector_sink_i_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tsb_vector_sink_i_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tsb_vector_sink_i_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tsb_vector_sink_i_sptr self, int priority) -> int"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tsb_vector_sink_i_sptr self) -> std::string"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tsb_vector_sink_i_sptr self) -> std::string"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tsb_vector_sink_i_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tsb_vector_sink_i_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tsb_vector_sink_i_sptr self) -> long"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tsb_vector_sink_i_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tsb_vector_sink_i_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tsb_vector_sink_i_sptr self) -> std::string"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tsb_vector_sink_i_sptr self, std::string name)"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tsb_vector_sink_i_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.tsb_vector_sink_i_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tsb_vector_sink_i_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tsb_vector_sink_i_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tsb_vector_sink_i_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.tsb_vector_sink_i_sptr_message_subscribers(self, which_port)

tsb_vector_sink_i_sptr_swigregister = _blocks_swig1.tsb_vector_sink_i_sptr_swigregister
tsb_vector_sink_i_sptr_swigregister(tsb_vector_sink_i_sptr)

tsb_vector_sink_i_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tsb_vector_sink_i = tsb_vector_sink_i.make;

class tsb_vector_sink_s_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::tsb_vector_sink_s)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_s)> self) -> tsb_vector_sink_s_sptr
        __init__(boost::shared_ptr<(gr::blocks::tsb_vector_sink_s)> self, tsb_vector_sink_s p) -> tsb_vector_sink_s_sptr
        """
        this = _blocks_swig1.new_tsb_vector_sink_s_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(tsb_vector_sink_s_sptr self) -> tsb_vector_sink_s"""
        return _blocks_swig1.tsb_vector_sink_s_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_tsb_vector_sink_s_sptr
    __del__ = lambda self: None

    def reset(self):
        """reset(tsb_vector_sink_s_sptr self)"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_reset(self)


    def data(self):
        """data(tsb_vector_sink_s_sptr self) -> std::vector< std::vector< short,std::allocator< short > >,std::allocator< std::vector< short,std::allocator< short > > > >"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_data(self)


    def tags(self):
        """tags(tsb_vector_sink_s_sptr self) -> tags_vector_t"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_tags(self)


    def make(self, *args, **kwargs):
        """make(tsb_vector_sink_s_sptr self, int vlen=1, std::string const & tsb_key) -> tsb_vector_sink_s_sptr"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_make(self, *args, **kwargs)


    def history(self):
        """history(tsb_vector_sink_s_sptr self) -> unsigned int"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tsb_vector_sink_s_sptr self, int which, int delay)
        declare_sample_delay(tsb_vector_sink_s_sptr self, unsigned int delay)
        """
        return _blocks_swig1.tsb_vector_sink_s_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tsb_vector_sink_s_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tsb_vector_sink_s_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tsb_vector_sink_s_sptr self) -> double"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_relative_rate(self)


    def start(self):
        """start(tsb_vector_sink_s_sptr self) -> bool"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_start(self)


    def stop(self):
        """stop(tsb_vector_sink_s_sptr self) -> bool"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tsb_vector_sink_s_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tsb_vector_sink_s_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tsb_vector_sink_s_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tsb_vector_sink_s_sptr self, int m)"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tsb_vector_sink_s_sptr self)"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tsb_vector_sink_s_sptr self) -> bool"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tsb_vector_sink_s_sptr self, int m)"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tsb_vector_sink_s_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tsb_vector_sink_s_sptr self, int i) -> long"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tsb_vector_sink_s_sptr self, long max_output_buffer)
        set_max_output_buffer(tsb_vector_sink_s_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.tsb_vector_sink_s_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tsb_vector_sink_s_sptr self, int i) -> long"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tsb_vector_sink_s_sptr self, long min_output_buffer)
        set_min_output_buffer(tsb_vector_sink_s_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.tsb_vector_sink_s_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tsb_vector_sink_s_sptr self, int which) -> float
        pc_input_buffers_full(tsb_vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_s_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tsb_vector_sink_s_sptr self, int which) -> float
        pc_input_buffers_full_avg(tsb_vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_s_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tsb_vector_sink_s_sptr self, int which) -> float
        pc_input_buffers_full_var(tsb_vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_s_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tsb_vector_sink_s_sptr self, int which) -> float
        pc_output_buffers_full(tsb_vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_s_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tsb_vector_sink_s_sptr self, int which) -> float
        pc_output_buffers_full_avg(tsb_vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_s_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tsb_vector_sink_s_sptr self, int which) -> float
        pc_output_buffers_full_var(tsb_vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.tsb_vector_sink_s_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tsb_vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tsb_vector_sink_s_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tsb_vector_sink_s_sptr self)"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tsb_vector_sink_s_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tsb_vector_sink_s_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tsb_vector_sink_s_sptr self) -> int"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tsb_vector_sink_s_sptr self, int priority) -> int"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tsb_vector_sink_s_sptr self) -> std::string"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tsb_vector_sink_s_sptr self) -> std::string"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tsb_vector_sink_s_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tsb_vector_sink_s_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tsb_vector_sink_s_sptr self) -> long"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tsb_vector_sink_s_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tsb_vector_sink_s_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tsb_vector_sink_s_sptr self) -> std::string"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tsb_vector_sink_s_sptr self, std::string name)"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tsb_vector_sink_s_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.tsb_vector_sink_s_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tsb_vector_sink_s_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tsb_vector_sink_s_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tsb_vector_sink_s_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.tsb_vector_sink_s_sptr_message_subscribers(self, which_port)

tsb_vector_sink_s_sptr_swigregister = _blocks_swig1.tsb_vector_sink_s_sptr_swigregister
tsb_vector_sink_s_sptr_swigregister(tsb_vector_sink_s_sptr)

tsb_vector_sink_s_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
tsb_vector_sink_s = tsb_vector_sink_s.make;

class throttle_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::throttle)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::throttle)> self) -> throttle_sptr
        __init__(boost::shared_ptr<(gr::blocks::throttle)> self, throttle p) -> throttle_sptr
        """
        this = _blocks_swig1.new_throttle_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(throttle_sptr self) -> throttle"""
        return _blocks_swig1.throttle_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_throttle_sptr
    __del__ = lambda self: None

    def make(self, itemsize, samples_per_sec, ignore_tags=True):
        """make(throttle_sptr self, size_t itemsize, double samples_per_sec, bool ignore_tags=True) -> throttle_sptr"""
        return _blocks_swig1.throttle_sptr_make(self, itemsize, samples_per_sec, ignore_tags)


    def set_sample_rate(self, rate):
        """set_sample_rate(throttle_sptr self, double rate)"""
        return _blocks_swig1.throttle_sptr_set_sample_rate(self, rate)


    def sample_rate(self):
        """sample_rate(throttle_sptr self) -> double"""
        return _blocks_swig1.throttle_sptr_sample_rate(self)


    def history(self):
        """history(throttle_sptr self) -> unsigned int"""
        return _blocks_swig1.throttle_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(throttle_sptr self, int which, int delay)
        declare_sample_delay(throttle_sptr self, unsigned int delay)
        """
        return _blocks_swig1.throttle_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(throttle_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.throttle_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(throttle_sptr self) -> int"""
        return _blocks_swig1.throttle_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(throttle_sptr self) -> double"""
        return _blocks_swig1.throttle_sptr_relative_rate(self)


    def start(self):
        """start(throttle_sptr self) -> bool"""
        return _blocks_swig1.throttle_sptr_start(self)


    def stop(self):
        """stop(throttle_sptr self) -> bool"""
        return _blocks_swig1.throttle_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(throttle_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.throttle_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(throttle_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.throttle_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(throttle_sptr self) -> int"""
        return _blocks_swig1.throttle_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(throttle_sptr self, int m)"""
        return _blocks_swig1.throttle_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(throttle_sptr self)"""
        return _blocks_swig1.throttle_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(throttle_sptr self) -> bool"""
        return _blocks_swig1.throttle_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(throttle_sptr self, int m)"""
        return _blocks_swig1.throttle_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(throttle_sptr self) -> int"""
        return _blocks_swig1.throttle_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(throttle_sptr self, int i) -> long"""
        return _blocks_swig1.throttle_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(throttle_sptr self, long max_output_buffer)
        set_max_output_buffer(throttle_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.throttle_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(throttle_sptr self, int i) -> long"""
        return _blocks_swig1.throttle_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(throttle_sptr self, long min_output_buffer)
        set_min_output_buffer(throttle_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.throttle_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(throttle_sptr self) -> float"""
        return _blocks_swig1.throttle_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(throttle_sptr self) -> float"""
        return _blocks_swig1.throttle_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(throttle_sptr self) -> float"""
        return _blocks_swig1.throttle_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(throttle_sptr self) -> float"""
        return _blocks_swig1.throttle_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(throttle_sptr self) -> float"""
        return _blocks_swig1.throttle_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(throttle_sptr self) -> float"""
        return _blocks_swig1.throttle_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(throttle_sptr self, int which) -> float
        pc_input_buffers_full(throttle_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.throttle_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(throttle_sptr self, int which) -> float
        pc_input_buffers_full_avg(throttle_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.throttle_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(throttle_sptr self, int which) -> float
        pc_input_buffers_full_var(throttle_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.throttle_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(throttle_sptr self, int which) -> float
        pc_output_buffers_full(throttle_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.throttle_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(throttle_sptr self, int which) -> float
        pc_output_buffers_full_avg(throttle_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.throttle_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(throttle_sptr self, int which) -> float
        pc_output_buffers_full_var(throttle_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.throttle_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(throttle_sptr self) -> float"""
        return _blocks_swig1.throttle_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(throttle_sptr self) -> float"""
        return _blocks_swig1.throttle_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(throttle_sptr self) -> float"""
        return _blocks_swig1.throttle_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(throttle_sptr self) -> float"""
        return _blocks_swig1.throttle_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(throttle_sptr self) -> float"""
        return _blocks_swig1.throttle_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(throttle_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.throttle_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(throttle_sptr self)"""
        return _blocks_swig1.throttle_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(throttle_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.throttle_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(throttle_sptr self) -> int"""
        return _blocks_swig1.throttle_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(throttle_sptr self) -> int"""
        return _blocks_swig1.throttle_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(throttle_sptr self, int priority) -> int"""
        return _blocks_swig1.throttle_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(throttle_sptr self) -> std::string"""
        return _blocks_swig1.throttle_sptr_name(self)


    def symbol_name(self):
        """symbol_name(throttle_sptr self) -> std::string"""
        return _blocks_swig1.throttle_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(throttle_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.throttle_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(throttle_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.throttle_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(throttle_sptr self) -> long"""
        return _blocks_swig1.throttle_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(throttle_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.throttle_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(throttle_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.throttle_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(throttle_sptr self) -> std::string"""
        return _blocks_swig1.throttle_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(throttle_sptr self, std::string name)"""
        return _blocks_swig1.throttle_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(throttle_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.throttle_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(throttle_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.throttle_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(throttle_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.throttle_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(throttle_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.throttle_sptr_message_subscribers(self, which_port)

throttle_sptr_swigregister = _blocks_swig1.throttle_sptr_swigregister
throttle_sptr_swigregister(throttle_sptr)

throttle_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
throttle = throttle.make;

class vector_map_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vector_map)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::vector_map)> self) -> vector_map_sptr
        __init__(boost::shared_ptr<(gr::blocks::vector_map)> self, vector_map p) -> vector_map_sptr
        """
        this = _blocks_swig1.new_vector_map_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_map_sptr self) -> vector_map"""
        return _blocks_swig1.vector_map_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_map_sptr
    __del__ = lambda self: None

    def make(self, item_size, in_vlens, mapping):
        """make(vector_map_sptr self, size_t item_size, gr_vsize_t in_vlens, gr_vvvsize_t mapping) -> vector_map_sptr"""
        return _blocks_swig1.vector_map_sptr_make(self, item_size, in_vlens, mapping)


    def set_mapping(self, mapping):
        """set_mapping(vector_map_sptr self, gr_vvvsize_t mapping)"""
        return _blocks_swig1.vector_map_sptr_set_mapping(self, mapping)


    def history(self):
        """history(vector_map_sptr self) -> unsigned int"""
        return _blocks_swig1.vector_map_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_map_sptr self, int which, int delay)
        declare_sample_delay(vector_map_sptr self, unsigned int delay)
        """
        return _blocks_swig1.vector_map_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_map_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.vector_map_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_map_sptr self) -> int"""
        return _blocks_swig1.vector_map_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_map_sptr self) -> double"""
        return _blocks_swig1.vector_map_sptr_relative_rate(self)


    def start(self):
        """start(vector_map_sptr self) -> bool"""
        return _blocks_swig1.vector_map_sptr_start(self)


    def stop(self):
        """stop(vector_map_sptr self) -> bool"""
        return _blocks_swig1.vector_map_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_map_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.vector_map_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_map_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.vector_map_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_map_sptr self) -> int"""
        return _blocks_swig1.vector_map_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_map_sptr self, int m)"""
        return _blocks_swig1.vector_map_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_map_sptr self)"""
        return _blocks_swig1.vector_map_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_map_sptr self) -> bool"""
        return _blocks_swig1.vector_map_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_map_sptr self, int m)"""
        return _blocks_swig1.vector_map_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_map_sptr self) -> int"""
        return _blocks_swig1.vector_map_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_map_sptr self, int i) -> long"""
        return _blocks_swig1.vector_map_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_map_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_map_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.vector_map_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_map_sptr self, int i) -> long"""
        return _blocks_swig1.vector_map_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_map_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_map_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.vector_map_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_map_sptr self) -> float"""
        return _blocks_swig1.vector_map_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_map_sptr self) -> float"""
        return _blocks_swig1.vector_map_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_map_sptr self) -> float"""
        return _blocks_swig1.vector_map_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_map_sptr self) -> float"""
        return _blocks_swig1.vector_map_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_map_sptr self) -> float"""
        return _blocks_swig1.vector_map_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_map_sptr self) -> float"""
        return _blocks_swig1.vector_map_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_map_sptr self, int which) -> float
        pc_input_buffers_full(vector_map_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_map_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_map_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_map_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_map_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_map_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_map_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_map_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_map_sptr self, int which) -> float
        pc_output_buffers_full(vector_map_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_map_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_map_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_map_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_map_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_map_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_map_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_map_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_map_sptr self) -> float"""
        return _blocks_swig1.vector_map_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_map_sptr self) -> float"""
        return _blocks_swig1.vector_map_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_map_sptr self) -> float"""
        return _blocks_swig1.vector_map_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_map_sptr self) -> float"""
        return _blocks_swig1.vector_map_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_map_sptr self) -> float"""
        return _blocks_swig1.vector_map_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_map_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.vector_map_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_map_sptr self)"""
        return _blocks_swig1.vector_map_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_map_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_map_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_map_sptr self) -> int"""
        return _blocks_swig1.vector_map_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_map_sptr self) -> int"""
        return _blocks_swig1.vector_map_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_map_sptr self, int priority) -> int"""
        return _blocks_swig1.vector_map_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_map_sptr self) -> std::string"""
        return _blocks_swig1.vector_map_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_map_sptr self) -> std::string"""
        return _blocks_swig1.vector_map_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_map_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_map_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_map_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_map_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_map_sptr self) -> long"""
        return _blocks_swig1.vector_map_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_map_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.vector_map_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_map_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.vector_map_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_map_sptr self) -> std::string"""
        return _blocks_swig1.vector_map_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_map_sptr self, std::string name)"""
        return _blocks_swig1.vector_map_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_map_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.vector_map_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_map_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_map_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_map_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_map_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_map_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.vector_map_sptr_message_subscribers(self, which_port)

vector_map_sptr_swigregister = _blocks_swig1.vector_map_sptr_swigregister
vector_map_sptr_swigregister(vector_map_sptr)

vector_map_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_map = vector_map.make;

class vector_to_stream_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vector_to_stream)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::vector_to_stream)> self) -> vector_to_stream_sptr
        __init__(boost::shared_ptr<(gr::blocks::vector_to_stream)> self, vector_to_stream p) -> vector_to_stream_sptr
        """
        this = _blocks_swig1.new_vector_to_stream_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_to_stream_sptr self) -> vector_to_stream"""
        return _blocks_swig1.vector_to_stream_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_to_stream_sptr
    __del__ = lambda self: None

    def make(self, itemsize, nitems_per_block):
        """make(vector_to_stream_sptr self, size_t itemsize, size_t nitems_per_block) -> vector_to_stream_sptr"""
        return _blocks_swig1.vector_to_stream_sptr_make(self, itemsize, nitems_per_block)


    def history(self):
        """history(vector_to_stream_sptr self) -> unsigned int"""
        return _blocks_swig1.vector_to_stream_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_to_stream_sptr self, int which, int delay)
        declare_sample_delay(vector_to_stream_sptr self, unsigned int delay)
        """
        return _blocks_swig1.vector_to_stream_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_to_stream_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.vector_to_stream_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_to_stream_sptr self) -> int"""
        return _blocks_swig1.vector_to_stream_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_to_stream_sptr self) -> double"""
        return _blocks_swig1.vector_to_stream_sptr_relative_rate(self)


    def start(self):
        """start(vector_to_stream_sptr self) -> bool"""
        return _blocks_swig1.vector_to_stream_sptr_start(self)


    def stop(self):
        """stop(vector_to_stream_sptr self) -> bool"""
        return _blocks_swig1.vector_to_stream_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_to_stream_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.vector_to_stream_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_to_stream_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.vector_to_stream_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_to_stream_sptr self) -> int"""
        return _blocks_swig1.vector_to_stream_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_to_stream_sptr self, int m)"""
        return _blocks_swig1.vector_to_stream_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_to_stream_sptr self)"""
        return _blocks_swig1.vector_to_stream_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_to_stream_sptr self) -> bool"""
        return _blocks_swig1.vector_to_stream_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_to_stream_sptr self, int m)"""
        return _blocks_swig1.vector_to_stream_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_to_stream_sptr self) -> int"""
        return _blocks_swig1.vector_to_stream_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_to_stream_sptr self, int i) -> long"""
        return _blocks_swig1.vector_to_stream_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_to_stream_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_to_stream_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.vector_to_stream_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_to_stream_sptr self, int i) -> long"""
        return _blocks_swig1.vector_to_stream_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_to_stream_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_to_stream_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.vector_to_stream_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_to_stream_sptr self) -> float"""
        return _blocks_swig1.vector_to_stream_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_to_stream_sptr self) -> float"""
        return _blocks_swig1.vector_to_stream_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_to_stream_sptr self) -> float"""
        return _blocks_swig1.vector_to_stream_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_to_stream_sptr self) -> float"""
        return _blocks_swig1.vector_to_stream_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_to_stream_sptr self) -> float"""
        return _blocks_swig1.vector_to_stream_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_to_stream_sptr self) -> float"""
        return _blocks_swig1.vector_to_stream_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_to_stream_sptr self, int which) -> float
        pc_input_buffers_full(vector_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_to_stream_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_to_stream_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_to_stream_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_to_stream_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_to_stream_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_to_stream_sptr self, int which) -> float
        pc_output_buffers_full(vector_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_to_stream_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_to_stream_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_to_stream_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_to_stream_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_to_stream_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_to_stream_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_to_stream_sptr self) -> float"""
        return _blocks_swig1.vector_to_stream_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_to_stream_sptr self) -> float"""
        return _blocks_swig1.vector_to_stream_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_to_stream_sptr self) -> float"""
        return _blocks_swig1.vector_to_stream_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_to_stream_sptr self) -> float"""
        return _blocks_swig1.vector_to_stream_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_to_stream_sptr self) -> float"""
        return _blocks_swig1.vector_to_stream_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_to_stream_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.vector_to_stream_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_to_stream_sptr self)"""
        return _blocks_swig1.vector_to_stream_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_to_stream_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_to_stream_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_to_stream_sptr self) -> int"""
        return _blocks_swig1.vector_to_stream_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_to_stream_sptr self) -> int"""
        return _blocks_swig1.vector_to_stream_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_to_stream_sptr self, int priority) -> int"""
        return _blocks_swig1.vector_to_stream_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_to_stream_sptr self) -> std::string"""
        return _blocks_swig1.vector_to_stream_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_to_stream_sptr self) -> std::string"""
        return _blocks_swig1.vector_to_stream_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_to_stream_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_to_stream_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_to_stream_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_to_stream_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_to_stream_sptr self) -> long"""
        return _blocks_swig1.vector_to_stream_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_to_stream_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.vector_to_stream_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_to_stream_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.vector_to_stream_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_to_stream_sptr self) -> std::string"""
        return _blocks_swig1.vector_to_stream_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_to_stream_sptr self, std::string name)"""
        return _blocks_swig1.vector_to_stream_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_to_stream_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.vector_to_stream_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_to_stream_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_to_stream_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_to_stream_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_to_stream_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_to_stream_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.vector_to_stream_sptr_message_subscribers(self, which_port)

vector_to_stream_sptr_swigregister = _blocks_swig1.vector_to_stream_sptr_swigregister
vector_to_stream_sptr_swigregister(vector_to_stream_sptr)

vector_to_stream_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_to_stream = vector_to_stream.make;

class vector_to_streams_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vector_to_streams)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::vector_to_streams)> self) -> vector_to_streams_sptr
        __init__(boost::shared_ptr<(gr::blocks::vector_to_streams)> self, vector_to_streams p) -> vector_to_streams_sptr
        """
        this = _blocks_swig1.new_vector_to_streams_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_to_streams_sptr self) -> vector_to_streams"""
        return _blocks_swig1.vector_to_streams_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_to_streams_sptr
    __del__ = lambda self: None

    def make(self, itemsize, nstreams):
        """make(vector_to_streams_sptr self, size_t itemsize, size_t nstreams) -> vector_to_streams_sptr"""
        return _blocks_swig1.vector_to_streams_sptr_make(self, itemsize, nstreams)


    def history(self):
        """history(vector_to_streams_sptr self) -> unsigned int"""
        return _blocks_swig1.vector_to_streams_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_to_streams_sptr self, int which, int delay)
        declare_sample_delay(vector_to_streams_sptr self, unsigned int delay)
        """
        return _blocks_swig1.vector_to_streams_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_to_streams_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.vector_to_streams_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_to_streams_sptr self) -> int"""
        return _blocks_swig1.vector_to_streams_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_to_streams_sptr self) -> double"""
        return _blocks_swig1.vector_to_streams_sptr_relative_rate(self)


    def start(self):
        """start(vector_to_streams_sptr self) -> bool"""
        return _blocks_swig1.vector_to_streams_sptr_start(self)


    def stop(self):
        """stop(vector_to_streams_sptr self) -> bool"""
        return _blocks_swig1.vector_to_streams_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_to_streams_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.vector_to_streams_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_to_streams_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.vector_to_streams_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_to_streams_sptr self) -> int"""
        return _blocks_swig1.vector_to_streams_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_to_streams_sptr self, int m)"""
        return _blocks_swig1.vector_to_streams_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_to_streams_sptr self)"""
        return _blocks_swig1.vector_to_streams_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_to_streams_sptr self) -> bool"""
        return _blocks_swig1.vector_to_streams_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_to_streams_sptr self, int m)"""
        return _blocks_swig1.vector_to_streams_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_to_streams_sptr self) -> int"""
        return _blocks_swig1.vector_to_streams_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_to_streams_sptr self, int i) -> long"""
        return _blocks_swig1.vector_to_streams_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_to_streams_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_to_streams_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.vector_to_streams_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_to_streams_sptr self, int i) -> long"""
        return _blocks_swig1.vector_to_streams_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_to_streams_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_to_streams_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.vector_to_streams_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_to_streams_sptr self) -> float"""
        return _blocks_swig1.vector_to_streams_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_to_streams_sptr self) -> float"""
        return _blocks_swig1.vector_to_streams_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_to_streams_sptr self) -> float"""
        return _blocks_swig1.vector_to_streams_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_to_streams_sptr self) -> float"""
        return _blocks_swig1.vector_to_streams_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_to_streams_sptr self) -> float"""
        return _blocks_swig1.vector_to_streams_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_to_streams_sptr self) -> float"""
        return _blocks_swig1.vector_to_streams_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_to_streams_sptr self, int which) -> float
        pc_input_buffers_full(vector_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_to_streams_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_to_streams_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_to_streams_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_to_streams_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_to_streams_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_to_streams_sptr self, int which) -> float
        pc_output_buffers_full(vector_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_to_streams_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_to_streams_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_to_streams_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_to_streams_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_to_streams_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_to_streams_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_to_streams_sptr self) -> float"""
        return _blocks_swig1.vector_to_streams_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_to_streams_sptr self) -> float"""
        return _blocks_swig1.vector_to_streams_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_to_streams_sptr self) -> float"""
        return _blocks_swig1.vector_to_streams_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_to_streams_sptr self) -> float"""
        return _blocks_swig1.vector_to_streams_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_to_streams_sptr self) -> float"""
        return _blocks_swig1.vector_to_streams_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_to_streams_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.vector_to_streams_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_to_streams_sptr self)"""
        return _blocks_swig1.vector_to_streams_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_to_streams_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_to_streams_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_to_streams_sptr self) -> int"""
        return _blocks_swig1.vector_to_streams_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_to_streams_sptr self) -> int"""
        return _blocks_swig1.vector_to_streams_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_to_streams_sptr self, int priority) -> int"""
        return _blocks_swig1.vector_to_streams_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_to_streams_sptr self) -> std::string"""
        return _blocks_swig1.vector_to_streams_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_to_streams_sptr self) -> std::string"""
        return _blocks_swig1.vector_to_streams_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_to_streams_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_to_streams_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_to_streams_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_to_streams_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_to_streams_sptr self) -> long"""
        return _blocks_swig1.vector_to_streams_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_to_streams_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.vector_to_streams_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_to_streams_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.vector_to_streams_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_to_streams_sptr self) -> std::string"""
        return _blocks_swig1.vector_to_streams_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_to_streams_sptr self, std::string name)"""
        return _blocks_swig1.vector_to_streams_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_to_streams_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.vector_to_streams_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_to_streams_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_to_streams_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_to_streams_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_to_streams_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_to_streams_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.vector_to_streams_sptr_message_subscribers(self, which_port)

vector_to_streams_sptr_swigregister = _blocks_swig1.vector_to_streams_sptr_swigregister
vector_to_streams_sptr_swigregister(vector_to_streams_sptr)

vector_to_streams_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_to_streams = vector_to_streams.make;

class vector_insert_b_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vector_insert_b)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::vector_insert_b)> self) -> vector_insert_b_sptr
        __init__(boost::shared_ptr<(gr::blocks::vector_insert_b)> self, vector_insert_b p) -> vector_insert_b_sptr
        """
        this = _blocks_swig1.new_vector_insert_b_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_insert_b_sptr self) -> vector_insert_b"""
        return _blocks_swig1.vector_insert_b_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_insert_b_sptr
    __del__ = lambda self: None

    def make(self, data, periodicity, offset=0):
        """make(vector_insert_b_sptr self, std::vector< unsigned char,std::allocator< unsigned char > > const & data, int periodicity, int offset=0) -> vector_insert_b_sptr"""
        return _blocks_swig1.vector_insert_b_sptr_make(self, data, periodicity, offset)


    def rewind(self):
        """rewind(vector_insert_b_sptr self)"""
        return _blocks_swig1.vector_insert_b_sptr_rewind(self)


    def set_data(self, data):
        """set_data(vector_insert_b_sptr self, std::vector< unsigned char,std::allocator< unsigned char > > const & data)"""
        return _blocks_swig1.vector_insert_b_sptr_set_data(self, data)


    def history(self):
        """history(vector_insert_b_sptr self) -> unsigned int"""
        return _blocks_swig1.vector_insert_b_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_insert_b_sptr self, int which, int delay)
        declare_sample_delay(vector_insert_b_sptr self, unsigned int delay)
        """
        return _blocks_swig1.vector_insert_b_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_insert_b_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.vector_insert_b_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_insert_b_sptr self) -> int"""
        return _blocks_swig1.vector_insert_b_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_insert_b_sptr self) -> double"""
        return _blocks_swig1.vector_insert_b_sptr_relative_rate(self)


    def start(self):
        """start(vector_insert_b_sptr self) -> bool"""
        return _blocks_swig1.vector_insert_b_sptr_start(self)


    def stop(self):
        """stop(vector_insert_b_sptr self) -> bool"""
        return _blocks_swig1.vector_insert_b_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_insert_b_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.vector_insert_b_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_insert_b_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.vector_insert_b_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_insert_b_sptr self) -> int"""
        return _blocks_swig1.vector_insert_b_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_insert_b_sptr self, int m)"""
        return _blocks_swig1.vector_insert_b_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_insert_b_sptr self)"""
        return _blocks_swig1.vector_insert_b_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_insert_b_sptr self) -> bool"""
        return _blocks_swig1.vector_insert_b_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_insert_b_sptr self, int m)"""
        return _blocks_swig1.vector_insert_b_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_insert_b_sptr self) -> int"""
        return _blocks_swig1.vector_insert_b_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_insert_b_sptr self, int i) -> long"""
        return _blocks_swig1.vector_insert_b_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_insert_b_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_insert_b_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.vector_insert_b_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_insert_b_sptr self, int i) -> long"""
        return _blocks_swig1.vector_insert_b_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_insert_b_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_insert_b_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.vector_insert_b_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_insert_b_sptr self) -> float"""
        return _blocks_swig1.vector_insert_b_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_insert_b_sptr self) -> float"""
        return _blocks_swig1.vector_insert_b_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_insert_b_sptr self) -> float"""
        return _blocks_swig1.vector_insert_b_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_insert_b_sptr self) -> float"""
        return _blocks_swig1.vector_insert_b_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_insert_b_sptr self) -> float"""
        return _blocks_swig1.vector_insert_b_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_insert_b_sptr self) -> float"""
        return _blocks_swig1.vector_insert_b_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_insert_b_sptr self, int which) -> float
        pc_input_buffers_full(vector_insert_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_b_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_insert_b_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_insert_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_b_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_insert_b_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_insert_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_b_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_insert_b_sptr self, int which) -> float
        pc_output_buffers_full(vector_insert_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_b_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_insert_b_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_insert_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_b_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_insert_b_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_insert_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_b_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_insert_b_sptr self) -> float"""
        return _blocks_swig1.vector_insert_b_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_insert_b_sptr self) -> float"""
        return _blocks_swig1.vector_insert_b_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_insert_b_sptr self) -> float"""
        return _blocks_swig1.vector_insert_b_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_insert_b_sptr self) -> float"""
        return _blocks_swig1.vector_insert_b_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_insert_b_sptr self) -> float"""
        return _blocks_swig1.vector_insert_b_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_insert_b_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.vector_insert_b_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_insert_b_sptr self)"""
        return _blocks_swig1.vector_insert_b_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_insert_b_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_insert_b_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_insert_b_sptr self) -> int"""
        return _blocks_swig1.vector_insert_b_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_insert_b_sptr self) -> int"""
        return _blocks_swig1.vector_insert_b_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_insert_b_sptr self, int priority) -> int"""
        return _blocks_swig1.vector_insert_b_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_insert_b_sptr self) -> std::string"""
        return _blocks_swig1.vector_insert_b_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_insert_b_sptr self) -> std::string"""
        return _blocks_swig1.vector_insert_b_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_insert_b_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_insert_b_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_insert_b_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_insert_b_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_insert_b_sptr self) -> long"""
        return _blocks_swig1.vector_insert_b_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_insert_b_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.vector_insert_b_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_insert_b_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.vector_insert_b_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_insert_b_sptr self) -> std::string"""
        return _blocks_swig1.vector_insert_b_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_insert_b_sptr self, std::string name)"""
        return _blocks_swig1.vector_insert_b_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_insert_b_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.vector_insert_b_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_insert_b_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_insert_b_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_insert_b_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_insert_b_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_insert_b_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.vector_insert_b_sptr_message_subscribers(self, which_port)

vector_insert_b_sptr_swigregister = _blocks_swig1.vector_insert_b_sptr_swigregister
vector_insert_b_sptr_swigregister(vector_insert_b_sptr)

vector_insert_b_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_insert_b = vector_insert_b.make;

class vector_insert_s_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vector_insert_s)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::vector_insert_s)> self) -> vector_insert_s_sptr
        __init__(boost::shared_ptr<(gr::blocks::vector_insert_s)> self, vector_insert_s p) -> vector_insert_s_sptr
        """
        this = _blocks_swig1.new_vector_insert_s_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_insert_s_sptr self) -> vector_insert_s"""
        return _blocks_swig1.vector_insert_s_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_insert_s_sptr
    __del__ = lambda self: None

    def make(self, data, periodicity, offset=0):
        """make(vector_insert_s_sptr self, std::vector< short,std::allocator< short > > const & data, int periodicity, int offset=0) -> vector_insert_s_sptr"""
        return _blocks_swig1.vector_insert_s_sptr_make(self, data, periodicity, offset)


    def rewind(self):
        """rewind(vector_insert_s_sptr self)"""
        return _blocks_swig1.vector_insert_s_sptr_rewind(self)


    def set_data(self, data):
        """set_data(vector_insert_s_sptr self, std::vector< short,std::allocator< short > > const & data)"""
        return _blocks_swig1.vector_insert_s_sptr_set_data(self, data)


    def history(self):
        """history(vector_insert_s_sptr self) -> unsigned int"""
        return _blocks_swig1.vector_insert_s_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_insert_s_sptr self, int which, int delay)
        declare_sample_delay(vector_insert_s_sptr self, unsigned int delay)
        """
        return _blocks_swig1.vector_insert_s_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_insert_s_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.vector_insert_s_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_insert_s_sptr self) -> int"""
        return _blocks_swig1.vector_insert_s_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_insert_s_sptr self) -> double"""
        return _blocks_swig1.vector_insert_s_sptr_relative_rate(self)


    def start(self):
        """start(vector_insert_s_sptr self) -> bool"""
        return _blocks_swig1.vector_insert_s_sptr_start(self)


    def stop(self):
        """stop(vector_insert_s_sptr self) -> bool"""
        return _blocks_swig1.vector_insert_s_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_insert_s_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.vector_insert_s_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_insert_s_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.vector_insert_s_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_insert_s_sptr self) -> int"""
        return _blocks_swig1.vector_insert_s_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_insert_s_sptr self, int m)"""
        return _blocks_swig1.vector_insert_s_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_insert_s_sptr self)"""
        return _blocks_swig1.vector_insert_s_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_insert_s_sptr self) -> bool"""
        return _blocks_swig1.vector_insert_s_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_insert_s_sptr self, int m)"""
        return _blocks_swig1.vector_insert_s_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_insert_s_sptr self) -> int"""
        return _blocks_swig1.vector_insert_s_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_insert_s_sptr self, int i) -> long"""
        return _blocks_swig1.vector_insert_s_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_insert_s_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_insert_s_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.vector_insert_s_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_insert_s_sptr self, int i) -> long"""
        return _blocks_swig1.vector_insert_s_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_insert_s_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_insert_s_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.vector_insert_s_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_insert_s_sptr self) -> float"""
        return _blocks_swig1.vector_insert_s_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_insert_s_sptr self) -> float"""
        return _blocks_swig1.vector_insert_s_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_insert_s_sptr self) -> float"""
        return _blocks_swig1.vector_insert_s_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_insert_s_sptr self) -> float"""
        return _blocks_swig1.vector_insert_s_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_insert_s_sptr self) -> float"""
        return _blocks_swig1.vector_insert_s_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_insert_s_sptr self) -> float"""
        return _blocks_swig1.vector_insert_s_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_insert_s_sptr self, int which) -> float
        pc_input_buffers_full(vector_insert_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_s_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_insert_s_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_insert_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_s_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_insert_s_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_insert_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_s_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_insert_s_sptr self, int which) -> float
        pc_output_buffers_full(vector_insert_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_s_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_insert_s_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_insert_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_s_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_insert_s_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_insert_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_s_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_insert_s_sptr self) -> float"""
        return _blocks_swig1.vector_insert_s_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_insert_s_sptr self) -> float"""
        return _blocks_swig1.vector_insert_s_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_insert_s_sptr self) -> float"""
        return _blocks_swig1.vector_insert_s_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_insert_s_sptr self) -> float"""
        return _blocks_swig1.vector_insert_s_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_insert_s_sptr self) -> float"""
        return _blocks_swig1.vector_insert_s_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_insert_s_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.vector_insert_s_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_insert_s_sptr self)"""
        return _blocks_swig1.vector_insert_s_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_insert_s_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_insert_s_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_insert_s_sptr self) -> int"""
        return _blocks_swig1.vector_insert_s_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_insert_s_sptr self) -> int"""
        return _blocks_swig1.vector_insert_s_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_insert_s_sptr self, int priority) -> int"""
        return _blocks_swig1.vector_insert_s_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_insert_s_sptr self) -> std::string"""
        return _blocks_swig1.vector_insert_s_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_insert_s_sptr self) -> std::string"""
        return _blocks_swig1.vector_insert_s_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_insert_s_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_insert_s_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_insert_s_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_insert_s_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_insert_s_sptr self) -> long"""
        return _blocks_swig1.vector_insert_s_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_insert_s_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.vector_insert_s_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_insert_s_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.vector_insert_s_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_insert_s_sptr self) -> std::string"""
        return _blocks_swig1.vector_insert_s_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_insert_s_sptr self, std::string name)"""
        return _blocks_swig1.vector_insert_s_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_insert_s_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.vector_insert_s_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_insert_s_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_insert_s_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_insert_s_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_insert_s_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_insert_s_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.vector_insert_s_sptr_message_subscribers(self, which_port)

vector_insert_s_sptr_swigregister = _blocks_swig1.vector_insert_s_sptr_swigregister
vector_insert_s_sptr_swigregister(vector_insert_s_sptr)

vector_insert_s_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_insert_s = vector_insert_s.make;

class vector_insert_i_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vector_insert_i)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::vector_insert_i)> self) -> vector_insert_i_sptr
        __init__(boost::shared_ptr<(gr::blocks::vector_insert_i)> self, vector_insert_i p) -> vector_insert_i_sptr
        """
        this = _blocks_swig1.new_vector_insert_i_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_insert_i_sptr self) -> vector_insert_i"""
        return _blocks_swig1.vector_insert_i_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_insert_i_sptr
    __del__ = lambda self: None

    def make(self, data, periodicity, offset=0):
        """make(vector_insert_i_sptr self, std::vector< int,std::allocator< int > > const & data, int periodicity, int offset=0) -> vector_insert_i_sptr"""
        return _blocks_swig1.vector_insert_i_sptr_make(self, data, periodicity, offset)


    def rewind(self):
        """rewind(vector_insert_i_sptr self)"""
        return _blocks_swig1.vector_insert_i_sptr_rewind(self)


    def set_data(self, data):
        """set_data(vector_insert_i_sptr self, std::vector< int,std::allocator< int > > const & data)"""
        return _blocks_swig1.vector_insert_i_sptr_set_data(self, data)


    def history(self):
        """history(vector_insert_i_sptr self) -> unsigned int"""
        return _blocks_swig1.vector_insert_i_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_insert_i_sptr self, int which, int delay)
        declare_sample_delay(vector_insert_i_sptr self, unsigned int delay)
        """
        return _blocks_swig1.vector_insert_i_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_insert_i_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.vector_insert_i_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_insert_i_sptr self) -> int"""
        return _blocks_swig1.vector_insert_i_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_insert_i_sptr self) -> double"""
        return _blocks_swig1.vector_insert_i_sptr_relative_rate(self)


    def start(self):
        """start(vector_insert_i_sptr self) -> bool"""
        return _blocks_swig1.vector_insert_i_sptr_start(self)


    def stop(self):
        """stop(vector_insert_i_sptr self) -> bool"""
        return _blocks_swig1.vector_insert_i_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_insert_i_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.vector_insert_i_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_insert_i_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.vector_insert_i_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_insert_i_sptr self) -> int"""
        return _blocks_swig1.vector_insert_i_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_insert_i_sptr self, int m)"""
        return _blocks_swig1.vector_insert_i_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_insert_i_sptr self)"""
        return _blocks_swig1.vector_insert_i_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_insert_i_sptr self) -> bool"""
        return _blocks_swig1.vector_insert_i_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_insert_i_sptr self, int m)"""
        return _blocks_swig1.vector_insert_i_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_insert_i_sptr self) -> int"""
        return _blocks_swig1.vector_insert_i_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_insert_i_sptr self, int i) -> long"""
        return _blocks_swig1.vector_insert_i_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_insert_i_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_insert_i_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.vector_insert_i_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_insert_i_sptr self, int i) -> long"""
        return _blocks_swig1.vector_insert_i_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_insert_i_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_insert_i_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.vector_insert_i_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_insert_i_sptr self) -> float"""
        return _blocks_swig1.vector_insert_i_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_insert_i_sptr self) -> float"""
        return _blocks_swig1.vector_insert_i_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_insert_i_sptr self) -> float"""
        return _blocks_swig1.vector_insert_i_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_insert_i_sptr self) -> float"""
        return _blocks_swig1.vector_insert_i_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_insert_i_sptr self) -> float"""
        return _blocks_swig1.vector_insert_i_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_insert_i_sptr self) -> float"""
        return _blocks_swig1.vector_insert_i_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_insert_i_sptr self, int which) -> float
        pc_input_buffers_full(vector_insert_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_i_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_insert_i_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_insert_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_i_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_insert_i_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_insert_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_i_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_insert_i_sptr self, int which) -> float
        pc_output_buffers_full(vector_insert_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_i_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_insert_i_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_insert_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_i_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_insert_i_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_insert_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_i_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_insert_i_sptr self) -> float"""
        return _blocks_swig1.vector_insert_i_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_insert_i_sptr self) -> float"""
        return _blocks_swig1.vector_insert_i_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_insert_i_sptr self) -> float"""
        return _blocks_swig1.vector_insert_i_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_insert_i_sptr self) -> float"""
        return _blocks_swig1.vector_insert_i_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_insert_i_sptr self) -> float"""
        return _blocks_swig1.vector_insert_i_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_insert_i_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.vector_insert_i_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_insert_i_sptr self)"""
        return _blocks_swig1.vector_insert_i_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_insert_i_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_insert_i_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_insert_i_sptr self) -> int"""
        return _blocks_swig1.vector_insert_i_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_insert_i_sptr self) -> int"""
        return _blocks_swig1.vector_insert_i_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_insert_i_sptr self, int priority) -> int"""
        return _blocks_swig1.vector_insert_i_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_insert_i_sptr self) -> std::string"""
        return _blocks_swig1.vector_insert_i_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_insert_i_sptr self) -> std::string"""
        return _blocks_swig1.vector_insert_i_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_insert_i_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_insert_i_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_insert_i_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_insert_i_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_insert_i_sptr self) -> long"""
        return _blocks_swig1.vector_insert_i_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_insert_i_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.vector_insert_i_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_insert_i_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.vector_insert_i_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_insert_i_sptr self) -> std::string"""
        return _blocks_swig1.vector_insert_i_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_insert_i_sptr self, std::string name)"""
        return _blocks_swig1.vector_insert_i_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_insert_i_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.vector_insert_i_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_insert_i_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_insert_i_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_insert_i_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_insert_i_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_insert_i_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.vector_insert_i_sptr_message_subscribers(self, which_port)

vector_insert_i_sptr_swigregister = _blocks_swig1.vector_insert_i_sptr_swigregister
vector_insert_i_sptr_swigregister(vector_insert_i_sptr)

vector_insert_i_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_insert_i = vector_insert_i.make;

class vector_insert_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vector_insert_f)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::vector_insert_f)> self) -> vector_insert_f_sptr
        __init__(boost::shared_ptr<(gr::blocks::vector_insert_f)> self, vector_insert_f p) -> vector_insert_f_sptr
        """
        this = _blocks_swig1.new_vector_insert_f_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_insert_f_sptr self) -> vector_insert_f"""
        return _blocks_swig1.vector_insert_f_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_insert_f_sptr
    __del__ = lambda self: None

    def make(self, data, periodicity, offset=0):
        """make(vector_insert_f_sptr self, pmt_vector_float data, int periodicity, int offset=0) -> vector_insert_f_sptr"""
        return _blocks_swig1.vector_insert_f_sptr_make(self, data, periodicity, offset)


    def rewind(self):
        """rewind(vector_insert_f_sptr self)"""
        return _blocks_swig1.vector_insert_f_sptr_rewind(self)


    def set_data(self, data):
        """set_data(vector_insert_f_sptr self, pmt_vector_float data)"""
        return _blocks_swig1.vector_insert_f_sptr_set_data(self, data)


    def history(self):
        """history(vector_insert_f_sptr self) -> unsigned int"""
        return _blocks_swig1.vector_insert_f_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_insert_f_sptr self, int which, int delay)
        declare_sample_delay(vector_insert_f_sptr self, unsigned int delay)
        """
        return _blocks_swig1.vector_insert_f_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_insert_f_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.vector_insert_f_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_insert_f_sptr self) -> int"""
        return _blocks_swig1.vector_insert_f_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_insert_f_sptr self) -> double"""
        return _blocks_swig1.vector_insert_f_sptr_relative_rate(self)


    def start(self):
        """start(vector_insert_f_sptr self) -> bool"""
        return _blocks_swig1.vector_insert_f_sptr_start(self)


    def stop(self):
        """stop(vector_insert_f_sptr self) -> bool"""
        return _blocks_swig1.vector_insert_f_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_insert_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.vector_insert_f_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_insert_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.vector_insert_f_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_insert_f_sptr self) -> int"""
        return _blocks_swig1.vector_insert_f_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_insert_f_sptr self, int m)"""
        return _blocks_swig1.vector_insert_f_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_insert_f_sptr self)"""
        return _blocks_swig1.vector_insert_f_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_insert_f_sptr self) -> bool"""
        return _blocks_swig1.vector_insert_f_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_insert_f_sptr self, int m)"""
        return _blocks_swig1.vector_insert_f_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_insert_f_sptr self) -> int"""
        return _blocks_swig1.vector_insert_f_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_insert_f_sptr self, int i) -> long"""
        return _blocks_swig1.vector_insert_f_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_insert_f_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_insert_f_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.vector_insert_f_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_insert_f_sptr self, int i) -> long"""
        return _blocks_swig1.vector_insert_f_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_insert_f_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_insert_f_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.vector_insert_f_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_insert_f_sptr self) -> float"""
        return _blocks_swig1.vector_insert_f_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_insert_f_sptr self) -> float"""
        return _blocks_swig1.vector_insert_f_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_insert_f_sptr self) -> float"""
        return _blocks_swig1.vector_insert_f_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_insert_f_sptr self) -> float"""
        return _blocks_swig1.vector_insert_f_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_insert_f_sptr self) -> float"""
        return _blocks_swig1.vector_insert_f_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_insert_f_sptr self) -> float"""
        return _blocks_swig1.vector_insert_f_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_insert_f_sptr self, int which) -> float
        pc_input_buffers_full(vector_insert_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_f_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_insert_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_insert_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_f_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_insert_f_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_insert_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_f_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_insert_f_sptr self, int which) -> float
        pc_output_buffers_full(vector_insert_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_f_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_insert_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_insert_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_f_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_insert_f_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_insert_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_f_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_insert_f_sptr self) -> float"""
        return _blocks_swig1.vector_insert_f_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_insert_f_sptr self) -> float"""
        return _blocks_swig1.vector_insert_f_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_insert_f_sptr self) -> float"""
        return _blocks_swig1.vector_insert_f_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_insert_f_sptr self) -> float"""
        return _blocks_swig1.vector_insert_f_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_insert_f_sptr self) -> float"""
        return _blocks_swig1.vector_insert_f_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_insert_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.vector_insert_f_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_insert_f_sptr self)"""
        return _blocks_swig1.vector_insert_f_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_insert_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_insert_f_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_insert_f_sptr self) -> int"""
        return _blocks_swig1.vector_insert_f_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_insert_f_sptr self) -> int"""
        return _blocks_swig1.vector_insert_f_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_insert_f_sptr self, int priority) -> int"""
        return _blocks_swig1.vector_insert_f_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_insert_f_sptr self) -> std::string"""
        return _blocks_swig1.vector_insert_f_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_insert_f_sptr self) -> std::string"""
        return _blocks_swig1.vector_insert_f_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_insert_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_insert_f_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_insert_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_insert_f_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_insert_f_sptr self) -> long"""
        return _blocks_swig1.vector_insert_f_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_insert_f_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.vector_insert_f_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_insert_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.vector_insert_f_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_insert_f_sptr self) -> std::string"""
        return _blocks_swig1.vector_insert_f_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_insert_f_sptr self, std::string name)"""
        return _blocks_swig1.vector_insert_f_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_insert_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.vector_insert_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_insert_f_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_insert_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_insert_f_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_insert_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_insert_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.vector_insert_f_sptr_message_subscribers(self, which_port)

vector_insert_f_sptr_swigregister = _blocks_swig1.vector_insert_f_sptr_swigregister
vector_insert_f_sptr_swigregister(vector_insert_f_sptr)

vector_insert_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_insert_f = vector_insert_f.make;

class vector_insert_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vector_insert_c)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::vector_insert_c)> self) -> vector_insert_c_sptr
        __init__(boost::shared_ptr<(gr::blocks::vector_insert_c)> self, vector_insert_c p) -> vector_insert_c_sptr
        """
        this = _blocks_swig1.new_vector_insert_c_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_insert_c_sptr self) -> vector_insert_c"""
        return _blocks_swig1.vector_insert_c_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_insert_c_sptr
    __del__ = lambda self: None

    def make(self, data, periodicity, offset=0):
        """make(vector_insert_c_sptr self, pmt_vector_cfloat data, int periodicity, int offset=0) -> vector_insert_c_sptr"""
        return _blocks_swig1.vector_insert_c_sptr_make(self, data, periodicity, offset)


    def rewind(self):
        """rewind(vector_insert_c_sptr self)"""
        return _blocks_swig1.vector_insert_c_sptr_rewind(self)


    def set_data(self, data):
        """set_data(vector_insert_c_sptr self, pmt_vector_cfloat data)"""
        return _blocks_swig1.vector_insert_c_sptr_set_data(self, data)


    def history(self):
        """history(vector_insert_c_sptr self) -> unsigned int"""
        return _blocks_swig1.vector_insert_c_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_insert_c_sptr self, int which, int delay)
        declare_sample_delay(vector_insert_c_sptr self, unsigned int delay)
        """
        return _blocks_swig1.vector_insert_c_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_insert_c_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.vector_insert_c_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_insert_c_sptr self) -> int"""
        return _blocks_swig1.vector_insert_c_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_insert_c_sptr self) -> double"""
        return _blocks_swig1.vector_insert_c_sptr_relative_rate(self)


    def start(self):
        """start(vector_insert_c_sptr self) -> bool"""
        return _blocks_swig1.vector_insert_c_sptr_start(self)


    def stop(self):
        """stop(vector_insert_c_sptr self) -> bool"""
        return _blocks_swig1.vector_insert_c_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_insert_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.vector_insert_c_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_insert_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.vector_insert_c_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_insert_c_sptr self) -> int"""
        return _blocks_swig1.vector_insert_c_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_insert_c_sptr self, int m)"""
        return _blocks_swig1.vector_insert_c_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_insert_c_sptr self)"""
        return _blocks_swig1.vector_insert_c_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_insert_c_sptr self) -> bool"""
        return _blocks_swig1.vector_insert_c_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_insert_c_sptr self, int m)"""
        return _blocks_swig1.vector_insert_c_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_insert_c_sptr self) -> int"""
        return _blocks_swig1.vector_insert_c_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_insert_c_sptr self, int i) -> long"""
        return _blocks_swig1.vector_insert_c_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_insert_c_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_insert_c_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.vector_insert_c_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_insert_c_sptr self, int i) -> long"""
        return _blocks_swig1.vector_insert_c_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_insert_c_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_insert_c_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.vector_insert_c_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_insert_c_sptr self) -> float"""
        return _blocks_swig1.vector_insert_c_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_insert_c_sptr self) -> float"""
        return _blocks_swig1.vector_insert_c_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_insert_c_sptr self) -> float"""
        return _blocks_swig1.vector_insert_c_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_insert_c_sptr self) -> float"""
        return _blocks_swig1.vector_insert_c_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_insert_c_sptr self) -> float"""
        return _blocks_swig1.vector_insert_c_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_insert_c_sptr self) -> float"""
        return _blocks_swig1.vector_insert_c_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_insert_c_sptr self, int which) -> float
        pc_input_buffers_full(vector_insert_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_c_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_insert_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_insert_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_c_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_insert_c_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_insert_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_c_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_insert_c_sptr self, int which) -> float
        pc_output_buffers_full(vector_insert_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_c_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_insert_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_insert_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_c_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_insert_c_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_insert_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_insert_c_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_insert_c_sptr self) -> float"""
        return _blocks_swig1.vector_insert_c_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_insert_c_sptr self) -> float"""
        return _blocks_swig1.vector_insert_c_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_insert_c_sptr self) -> float"""
        return _blocks_swig1.vector_insert_c_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_insert_c_sptr self) -> float"""
        return _blocks_swig1.vector_insert_c_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_insert_c_sptr self) -> float"""
        return _blocks_swig1.vector_insert_c_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_insert_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.vector_insert_c_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_insert_c_sptr self)"""
        return _blocks_swig1.vector_insert_c_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_insert_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_insert_c_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_insert_c_sptr self) -> int"""
        return _blocks_swig1.vector_insert_c_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_insert_c_sptr self) -> int"""
        return _blocks_swig1.vector_insert_c_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_insert_c_sptr self, int priority) -> int"""
        return _blocks_swig1.vector_insert_c_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_insert_c_sptr self) -> std::string"""
        return _blocks_swig1.vector_insert_c_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_insert_c_sptr self) -> std::string"""
        return _blocks_swig1.vector_insert_c_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_insert_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_insert_c_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_insert_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_insert_c_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_insert_c_sptr self) -> long"""
        return _blocks_swig1.vector_insert_c_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_insert_c_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.vector_insert_c_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_insert_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.vector_insert_c_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_insert_c_sptr self) -> std::string"""
        return _blocks_swig1.vector_insert_c_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_insert_c_sptr self, std::string name)"""
        return _blocks_swig1.vector_insert_c_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_insert_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.vector_insert_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_insert_c_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_insert_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_insert_c_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_insert_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_insert_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.vector_insert_c_sptr_message_subscribers(self, which_port)

vector_insert_c_sptr_swigregister = _blocks_swig1.vector_insert_c_sptr_swigregister
vector_insert_c_sptr_swigregister(vector_insert_c_sptr)

vector_insert_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_insert_c = vector_insert_c.make;

class vector_sink_b_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vector_sink_b)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::vector_sink_b)> self) -> vector_sink_b_sptr
        __init__(boost::shared_ptr<(gr::blocks::vector_sink_b)> self, vector_sink_b p) -> vector_sink_b_sptr
        """
        this = _blocks_swig1.new_vector_sink_b_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_sink_b_sptr self) -> vector_sink_b"""
        return _blocks_swig1.vector_sink_b_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_sink_b_sptr
    __del__ = lambda self: None

    def make(self, vlen=1):
        """make(vector_sink_b_sptr self, int vlen=1) -> vector_sink_b_sptr"""
        return _blocks_swig1.vector_sink_b_sptr_make(self, vlen)


    def reset(self):
        """reset(vector_sink_b_sptr self)"""
        return _blocks_swig1.vector_sink_b_sptr_reset(self)


    def data(self):
        """data(vector_sink_b_sptr self) -> std::vector< unsigned char,std::allocator< unsigned char > >"""
        return _blocks_swig1.vector_sink_b_sptr_data(self)


    def tags(self):
        """tags(vector_sink_b_sptr self) -> tags_vector_t"""
        return _blocks_swig1.vector_sink_b_sptr_tags(self)


    def history(self):
        """history(vector_sink_b_sptr self) -> unsigned int"""
        return _blocks_swig1.vector_sink_b_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_sink_b_sptr self, int which, int delay)
        declare_sample_delay(vector_sink_b_sptr self, unsigned int delay)
        """
        return _blocks_swig1.vector_sink_b_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_sink_b_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.vector_sink_b_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_sink_b_sptr self) -> int"""
        return _blocks_swig1.vector_sink_b_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_sink_b_sptr self) -> double"""
        return _blocks_swig1.vector_sink_b_sptr_relative_rate(self)


    def start(self):
        """start(vector_sink_b_sptr self) -> bool"""
        return _blocks_swig1.vector_sink_b_sptr_start(self)


    def stop(self):
        """stop(vector_sink_b_sptr self) -> bool"""
        return _blocks_swig1.vector_sink_b_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_sink_b_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.vector_sink_b_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_sink_b_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.vector_sink_b_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_sink_b_sptr self) -> int"""
        return _blocks_swig1.vector_sink_b_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_sink_b_sptr self, int m)"""
        return _blocks_swig1.vector_sink_b_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_sink_b_sptr self)"""
        return _blocks_swig1.vector_sink_b_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_sink_b_sptr self) -> bool"""
        return _blocks_swig1.vector_sink_b_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_sink_b_sptr self, int m)"""
        return _blocks_swig1.vector_sink_b_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_sink_b_sptr self) -> int"""
        return _blocks_swig1.vector_sink_b_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_sink_b_sptr self, int i) -> long"""
        return _blocks_swig1.vector_sink_b_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_sink_b_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_sink_b_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.vector_sink_b_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_sink_b_sptr self, int i) -> long"""
        return _blocks_swig1.vector_sink_b_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_sink_b_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_sink_b_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.vector_sink_b_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.vector_sink_b_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.vector_sink_b_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.vector_sink_b_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.vector_sink_b_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.vector_sink_b_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.vector_sink_b_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_sink_b_sptr self, int which) -> float
        pc_input_buffers_full(vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_b_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_sink_b_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_b_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_sink_b_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_b_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_sink_b_sptr self, int which) -> float
        pc_output_buffers_full(vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_b_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_sink_b_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_b_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_sink_b_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_sink_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_b_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.vector_sink_b_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.vector_sink_b_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.vector_sink_b_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.vector_sink_b_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_sink_b_sptr self) -> float"""
        return _blocks_swig1.vector_sink_b_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_sink_b_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.vector_sink_b_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_sink_b_sptr self)"""
        return _blocks_swig1.vector_sink_b_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_sink_b_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_sink_b_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_sink_b_sptr self) -> int"""
        return _blocks_swig1.vector_sink_b_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_sink_b_sptr self) -> int"""
        return _blocks_swig1.vector_sink_b_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_sink_b_sptr self, int priority) -> int"""
        return _blocks_swig1.vector_sink_b_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_sink_b_sptr self) -> std::string"""
        return _blocks_swig1.vector_sink_b_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_sink_b_sptr self) -> std::string"""
        return _blocks_swig1.vector_sink_b_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_sink_b_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_sink_b_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_sink_b_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_sink_b_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_sink_b_sptr self) -> long"""
        return _blocks_swig1.vector_sink_b_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_sink_b_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.vector_sink_b_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_sink_b_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.vector_sink_b_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_sink_b_sptr self) -> std::string"""
        return _blocks_swig1.vector_sink_b_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_sink_b_sptr self, std::string name)"""
        return _blocks_swig1.vector_sink_b_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_sink_b_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.vector_sink_b_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_sink_b_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_sink_b_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_sink_b_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_sink_b_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_sink_b_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.vector_sink_b_sptr_message_subscribers(self, which_port)

vector_sink_b_sptr_swigregister = _blocks_swig1.vector_sink_b_sptr_swigregister
vector_sink_b_sptr_swigregister(vector_sink_b_sptr)

vector_sink_b_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_sink_b = vector_sink_b.make;

class vector_sink_s_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vector_sink_s)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::vector_sink_s)> self) -> vector_sink_s_sptr
        __init__(boost::shared_ptr<(gr::blocks::vector_sink_s)> self, vector_sink_s p) -> vector_sink_s_sptr
        """
        this = _blocks_swig1.new_vector_sink_s_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_sink_s_sptr self) -> vector_sink_s"""
        return _blocks_swig1.vector_sink_s_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_sink_s_sptr
    __del__ = lambda self: None

    def make(self, vlen=1):
        """make(vector_sink_s_sptr self, int vlen=1) -> vector_sink_s_sptr"""
        return _blocks_swig1.vector_sink_s_sptr_make(self, vlen)


    def reset(self):
        """reset(vector_sink_s_sptr self)"""
        return _blocks_swig1.vector_sink_s_sptr_reset(self)


    def data(self):
        """data(vector_sink_s_sptr self) -> std::vector< short,std::allocator< short > >"""
        return _blocks_swig1.vector_sink_s_sptr_data(self)


    def tags(self):
        """tags(vector_sink_s_sptr self) -> tags_vector_t"""
        return _blocks_swig1.vector_sink_s_sptr_tags(self)


    def history(self):
        """history(vector_sink_s_sptr self) -> unsigned int"""
        return _blocks_swig1.vector_sink_s_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_sink_s_sptr self, int which, int delay)
        declare_sample_delay(vector_sink_s_sptr self, unsigned int delay)
        """
        return _blocks_swig1.vector_sink_s_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_sink_s_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.vector_sink_s_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_sink_s_sptr self) -> int"""
        return _blocks_swig1.vector_sink_s_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_sink_s_sptr self) -> double"""
        return _blocks_swig1.vector_sink_s_sptr_relative_rate(self)


    def start(self):
        """start(vector_sink_s_sptr self) -> bool"""
        return _blocks_swig1.vector_sink_s_sptr_start(self)


    def stop(self):
        """stop(vector_sink_s_sptr self) -> bool"""
        return _blocks_swig1.vector_sink_s_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_sink_s_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.vector_sink_s_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_sink_s_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.vector_sink_s_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_sink_s_sptr self) -> int"""
        return _blocks_swig1.vector_sink_s_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_sink_s_sptr self, int m)"""
        return _blocks_swig1.vector_sink_s_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_sink_s_sptr self)"""
        return _blocks_swig1.vector_sink_s_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_sink_s_sptr self) -> bool"""
        return _blocks_swig1.vector_sink_s_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_sink_s_sptr self, int m)"""
        return _blocks_swig1.vector_sink_s_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_sink_s_sptr self) -> int"""
        return _blocks_swig1.vector_sink_s_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_sink_s_sptr self, int i) -> long"""
        return _blocks_swig1.vector_sink_s_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_sink_s_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_sink_s_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.vector_sink_s_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_sink_s_sptr self, int i) -> long"""
        return _blocks_swig1.vector_sink_s_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_sink_s_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_sink_s_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.vector_sink_s_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.vector_sink_s_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.vector_sink_s_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.vector_sink_s_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.vector_sink_s_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.vector_sink_s_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.vector_sink_s_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_sink_s_sptr self, int which) -> float
        pc_input_buffers_full(vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_s_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_sink_s_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_s_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_sink_s_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_s_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_sink_s_sptr self, int which) -> float
        pc_output_buffers_full(vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_s_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_sink_s_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_s_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_sink_s_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_sink_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_s_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.vector_sink_s_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.vector_sink_s_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.vector_sink_s_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.vector_sink_s_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_sink_s_sptr self) -> float"""
        return _blocks_swig1.vector_sink_s_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_sink_s_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.vector_sink_s_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_sink_s_sptr self)"""
        return _blocks_swig1.vector_sink_s_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_sink_s_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_sink_s_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_sink_s_sptr self) -> int"""
        return _blocks_swig1.vector_sink_s_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_sink_s_sptr self) -> int"""
        return _blocks_swig1.vector_sink_s_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_sink_s_sptr self, int priority) -> int"""
        return _blocks_swig1.vector_sink_s_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_sink_s_sptr self) -> std::string"""
        return _blocks_swig1.vector_sink_s_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_sink_s_sptr self) -> std::string"""
        return _blocks_swig1.vector_sink_s_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_sink_s_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_sink_s_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_sink_s_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_sink_s_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_sink_s_sptr self) -> long"""
        return _blocks_swig1.vector_sink_s_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_sink_s_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.vector_sink_s_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_sink_s_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.vector_sink_s_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_sink_s_sptr self) -> std::string"""
        return _blocks_swig1.vector_sink_s_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_sink_s_sptr self, std::string name)"""
        return _blocks_swig1.vector_sink_s_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_sink_s_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.vector_sink_s_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_sink_s_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_sink_s_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_sink_s_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_sink_s_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_sink_s_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.vector_sink_s_sptr_message_subscribers(self, which_port)

vector_sink_s_sptr_swigregister = _blocks_swig1.vector_sink_s_sptr_swigregister
vector_sink_s_sptr_swigregister(vector_sink_s_sptr)

vector_sink_s_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_sink_s = vector_sink_s.make;

class vector_sink_i_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vector_sink_i)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::vector_sink_i)> self) -> vector_sink_i_sptr
        __init__(boost::shared_ptr<(gr::blocks::vector_sink_i)> self, vector_sink_i p) -> vector_sink_i_sptr
        """
        this = _blocks_swig1.new_vector_sink_i_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_sink_i_sptr self) -> vector_sink_i"""
        return _blocks_swig1.vector_sink_i_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_sink_i_sptr
    __del__ = lambda self: None

    def make(self, vlen=1):
        """make(vector_sink_i_sptr self, int vlen=1) -> vector_sink_i_sptr"""
        return _blocks_swig1.vector_sink_i_sptr_make(self, vlen)


    def reset(self):
        """reset(vector_sink_i_sptr self)"""
        return _blocks_swig1.vector_sink_i_sptr_reset(self)


    def data(self):
        """data(vector_sink_i_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_sink_i_sptr_data(self)


    def tags(self):
        """tags(vector_sink_i_sptr self) -> tags_vector_t"""
        return _blocks_swig1.vector_sink_i_sptr_tags(self)


    def history(self):
        """history(vector_sink_i_sptr self) -> unsigned int"""
        return _blocks_swig1.vector_sink_i_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_sink_i_sptr self, int which, int delay)
        declare_sample_delay(vector_sink_i_sptr self, unsigned int delay)
        """
        return _blocks_swig1.vector_sink_i_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_sink_i_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.vector_sink_i_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_sink_i_sptr self) -> int"""
        return _blocks_swig1.vector_sink_i_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_sink_i_sptr self) -> double"""
        return _blocks_swig1.vector_sink_i_sptr_relative_rate(self)


    def start(self):
        """start(vector_sink_i_sptr self) -> bool"""
        return _blocks_swig1.vector_sink_i_sptr_start(self)


    def stop(self):
        """stop(vector_sink_i_sptr self) -> bool"""
        return _blocks_swig1.vector_sink_i_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_sink_i_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.vector_sink_i_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_sink_i_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.vector_sink_i_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_sink_i_sptr self) -> int"""
        return _blocks_swig1.vector_sink_i_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_sink_i_sptr self, int m)"""
        return _blocks_swig1.vector_sink_i_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_sink_i_sptr self)"""
        return _blocks_swig1.vector_sink_i_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_sink_i_sptr self) -> bool"""
        return _blocks_swig1.vector_sink_i_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_sink_i_sptr self, int m)"""
        return _blocks_swig1.vector_sink_i_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_sink_i_sptr self) -> int"""
        return _blocks_swig1.vector_sink_i_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_sink_i_sptr self, int i) -> long"""
        return _blocks_swig1.vector_sink_i_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_sink_i_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_sink_i_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.vector_sink_i_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_sink_i_sptr self, int i) -> long"""
        return _blocks_swig1.vector_sink_i_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_sink_i_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_sink_i_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.vector_sink_i_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.vector_sink_i_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.vector_sink_i_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.vector_sink_i_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.vector_sink_i_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.vector_sink_i_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.vector_sink_i_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_sink_i_sptr self, int which) -> float
        pc_input_buffers_full(vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_i_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_sink_i_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_i_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_sink_i_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_i_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_sink_i_sptr self, int which) -> float
        pc_output_buffers_full(vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_i_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_sink_i_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_i_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_sink_i_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_sink_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_i_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.vector_sink_i_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.vector_sink_i_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.vector_sink_i_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.vector_sink_i_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_sink_i_sptr self) -> float"""
        return _blocks_swig1.vector_sink_i_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_sink_i_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.vector_sink_i_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_sink_i_sptr self)"""
        return _blocks_swig1.vector_sink_i_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_sink_i_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_sink_i_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_sink_i_sptr self) -> int"""
        return _blocks_swig1.vector_sink_i_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_sink_i_sptr self) -> int"""
        return _blocks_swig1.vector_sink_i_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_sink_i_sptr self, int priority) -> int"""
        return _blocks_swig1.vector_sink_i_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_sink_i_sptr self) -> std::string"""
        return _blocks_swig1.vector_sink_i_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_sink_i_sptr self) -> std::string"""
        return _blocks_swig1.vector_sink_i_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_sink_i_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_sink_i_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_sink_i_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_sink_i_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_sink_i_sptr self) -> long"""
        return _blocks_swig1.vector_sink_i_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_sink_i_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.vector_sink_i_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_sink_i_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.vector_sink_i_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_sink_i_sptr self) -> std::string"""
        return _blocks_swig1.vector_sink_i_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_sink_i_sptr self, std::string name)"""
        return _blocks_swig1.vector_sink_i_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_sink_i_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.vector_sink_i_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_sink_i_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_sink_i_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_sink_i_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_sink_i_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_sink_i_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.vector_sink_i_sptr_message_subscribers(self, which_port)

vector_sink_i_sptr_swigregister = _blocks_swig1.vector_sink_i_sptr_swigregister
vector_sink_i_sptr_swigregister(vector_sink_i_sptr)

vector_sink_i_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_sink_i = vector_sink_i.make;

class vector_sink_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vector_sink_f)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::vector_sink_f)> self) -> vector_sink_f_sptr
        __init__(boost::shared_ptr<(gr::blocks::vector_sink_f)> self, vector_sink_f p) -> vector_sink_f_sptr
        """
        this = _blocks_swig1.new_vector_sink_f_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_sink_f_sptr self) -> vector_sink_f"""
        return _blocks_swig1.vector_sink_f_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_sink_f_sptr
    __del__ = lambda self: None

    def make(self, vlen=1):
        """make(vector_sink_f_sptr self, int vlen=1) -> vector_sink_f_sptr"""
        return _blocks_swig1.vector_sink_f_sptr_make(self, vlen)


    def reset(self):
        """reset(vector_sink_f_sptr self)"""
        return _blocks_swig1.vector_sink_f_sptr_reset(self)


    def data(self):
        """data(vector_sink_f_sptr self) -> pmt_vector_float"""
        return _blocks_swig1.vector_sink_f_sptr_data(self)


    def tags(self):
        """tags(vector_sink_f_sptr self) -> tags_vector_t"""
        return _blocks_swig1.vector_sink_f_sptr_tags(self)


    def history(self):
        """history(vector_sink_f_sptr self) -> unsigned int"""
        return _blocks_swig1.vector_sink_f_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_sink_f_sptr self, int which, int delay)
        declare_sample_delay(vector_sink_f_sptr self, unsigned int delay)
        """
        return _blocks_swig1.vector_sink_f_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_sink_f_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.vector_sink_f_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_sink_f_sptr self) -> int"""
        return _blocks_swig1.vector_sink_f_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_sink_f_sptr self) -> double"""
        return _blocks_swig1.vector_sink_f_sptr_relative_rate(self)


    def start(self):
        """start(vector_sink_f_sptr self) -> bool"""
        return _blocks_swig1.vector_sink_f_sptr_start(self)


    def stop(self):
        """stop(vector_sink_f_sptr self) -> bool"""
        return _blocks_swig1.vector_sink_f_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_sink_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.vector_sink_f_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_sink_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.vector_sink_f_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_sink_f_sptr self) -> int"""
        return _blocks_swig1.vector_sink_f_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_sink_f_sptr self, int m)"""
        return _blocks_swig1.vector_sink_f_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_sink_f_sptr self)"""
        return _blocks_swig1.vector_sink_f_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_sink_f_sptr self) -> bool"""
        return _blocks_swig1.vector_sink_f_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_sink_f_sptr self, int m)"""
        return _blocks_swig1.vector_sink_f_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_sink_f_sptr self) -> int"""
        return _blocks_swig1.vector_sink_f_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_sink_f_sptr self, int i) -> long"""
        return _blocks_swig1.vector_sink_f_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_sink_f_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_sink_f_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.vector_sink_f_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_sink_f_sptr self, int i) -> long"""
        return _blocks_swig1.vector_sink_f_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_sink_f_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_sink_f_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.vector_sink_f_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.vector_sink_f_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.vector_sink_f_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.vector_sink_f_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.vector_sink_f_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.vector_sink_f_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.vector_sink_f_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_sink_f_sptr self, int which) -> float
        pc_input_buffers_full(vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_f_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_f_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_sink_f_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_f_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_sink_f_sptr self, int which) -> float
        pc_output_buffers_full(vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_f_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_f_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_sink_f_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_sink_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_f_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.vector_sink_f_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.vector_sink_f_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.vector_sink_f_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.vector_sink_f_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_sink_f_sptr self) -> float"""
        return _blocks_swig1.vector_sink_f_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_sink_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.vector_sink_f_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_sink_f_sptr self)"""
        return _blocks_swig1.vector_sink_f_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_sink_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_sink_f_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_sink_f_sptr self) -> int"""
        return _blocks_swig1.vector_sink_f_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_sink_f_sptr self) -> int"""
        return _blocks_swig1.vector_sink_f_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_sink_f_sptr self, int priority) -> int"""
        return _blocks_swig1.vector_sink_f_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_sink_f_sptr self) -> std::string"""
        return _blocks_swig1.vector_sink_f_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_sink_f_sptr self) -> std::string"""
        return _blocks_swig1.vector_sink_f_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_sink_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_sink_f_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_sink_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_sink_f_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_sink_f_sptr self) -> long"""
        return _blocks_swig1.vector_sink_f_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_sink_f_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.vector_sink_f_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_sink_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.vector_sink_f_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_sink_f_sptr self) -> std::string"""
        return _blocks_swig1.vector_sink_f_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_sink_f_sptr self, std::string name)"""
        return _blocks_swig1.vector_sink_f_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_sink_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.vector_sink_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_sink_f_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_sink_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_sink_f_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_sink_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_sink_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.vector_sink_f_sptr_message_subscribers(self, which_port)

vector_sink_f_sptr_swigregister = _blocks_swig1.vector_sink_f_sptr_swigregister
vector_sink_f_sptr_swigregister(vector_sink_f_sptr)

vector_sink_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_sink_f = vector_sink_f.make;

class vector_sink_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vector_sink_c)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::vector_sink_c)> self) -> vector_sink_c_sptr
        __init__(boost::shared_ptr<(gr::blocks::vector_sink_c)> self, vector_sink_c p) -> vector_sink_c_sptr
        """
        this = _blocks_swig1.new_vector_sink_c_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_sink_c_sptr self) -> vector_sink_c"""
        return _blocks_swig1.vector_sink_c_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_sink_c_sptr
    __del__ = lambda self: None

    def make(self, vlen=1):
        """make(vector_sink_c_sptr self, int vlen=1) -> vector_sink_c_sptr"""
        return _blocks_swig1.vector_sink_c_sptr_make(self, vlen)


    def reset(self):
        """reset(vector_sink_c_sptr self)"""
        return _blocks_swig1.vector_sink_c_sptr_reset(self)


    def data(self):
        """data(vector_sink_c_sptr self) -> pmt_vector_cfloat"""
        return _blocks_swig1.vector_sink_c_sptr_data(self)


    def tags(self):
        """tags(vector_sink_c_sptr self) -> tags_vector_t"""
        return _blocks_swig1.vector_sink_c_sptr_tags(self)


    def history(self):
        """history(vector_sink_c_sptr self) -> unsigned int"""
        return _blocks_swig1.vector_sink_c_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_sink_c_sptr self, int which, int delay)
        declare_sample_delay(vector_sink_c_sptr self, unsigned int delay)
        """
        return _blocks_swig1.vector_sink_c_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_sink_c_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.vector_sink_c_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_sink_c_sptr self) -> int"""
        return _blocks_swig1.vector_sink_c_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_sink_c_sptr self) -> double"""
        return _blocks_swig1.vector_sink_c_sptr_relative_rate(self)


    def start(self):
        """start(vector_sink_c_sptr self) -> bool"""
        return _blocks_swig1.vector_sink_c_sptr_start(self)


    def stop(self):
        """stop(vector_sink_c_sptr self) -> bool"""
        return _blocks_swig1.vector_sink_c_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_sink_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.vector_sink_c_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_sink_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.vector_sink_c_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_sink_c_sptr self) -> int"""
        return _blocks_swig1.vector_sink_c_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_sink_c_sptr self, int m)"""
        return _blocks_swig1.vector_sink_c_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_sink_c_sptr self)"""
        return _blocks_swig1.vector_sink_c_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_sink_c_sptr self) -> bool"""
        return _blocks_swig1.vector_sink_c_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_sink_c_sptr self, int m)"""
        return _blocks_swig1.vector_sink_c_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_sink_c_sptr self) -> int"""
        return _blocks_swig1.vector_sink_c_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_sink_c_sptr self, int i) -> long"""
        return _blocks_swig1.vector_sink_c_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_sink_c_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_sink_c_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.vector_sink_c_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_sink_c_sptr self, int i) -> long"""
        return _blocks_swig1.vector_sink_c_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_sink_c_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_sink_c_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.vector_sink_c_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.vector_sink_c_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.vector_sink_c_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.vector_sink_c_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.vector_sink_c_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.vector_sink_c_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.vector_sink_c_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_sink_c_sptr self, int which) -> float
        pc_input_buffers_full(vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_c_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_sink_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_c_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_sink_c_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_c_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_sink_c_sptr self, int which) -> float
        pc_output_buffers_full(vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_c_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_sink_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_c_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_sink_c_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_sink_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_sink_c_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.vector_sink_c_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.vector_sink_c_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.vector_sink_c_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.vector_sink_c_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_sink_c_sptr self) -> float"""
        return _blocks_swig1.vector_sink_c_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_sink_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.vector_sink_c_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_sink_c_sptr self)"""
        return _blocks_swig1.vector_sink_c_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_sink_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_sink_c_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_sink_c_sptr self) -> int"""
        return _blocks_swig1.vector_sink_c_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_sink_c_sptr self) -> int"""
        return _blocks_swig1.vector_sink_c_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_sink_c_sptr self, int priority) -> int"""
        return _blocks_swig1.vector_sink_c_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_sink_c_sptr self) -> std::string"""
        return _blocks_swig1.vector_sink_c_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_sink_c_sptr self) -> std::string"""
        return _blocks_swig1.vector_sink_c_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_sink_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_sink_c_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_sink_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_sink_c_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_sink_c_sptr self) -> long"""
        return _blocks_swig1.vector_sink_c_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_sink_c_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.vector_sink_c_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_sink_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.vector_sink_c_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_sink_c_sptr self) -> std::string"""
        return _blocks_swig1.vector_sink_c_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_sink_c_sptr self, std::string name)"""
        return _blocks_swig1.vector_sink_c_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_sink_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.vector_sink_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_sink_c_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_sink_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_sink_c_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_sink_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_sink_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.vector_sink_c_sptr_message_subscribers(self, which_port)

vector_sink_c_sptr_swigregister = _blocks_swig1.vector_sink_c_sptr_swigregister
vector_sink_c_sptr_swigregister(vector_sink_c_sptr)

vector_sink_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_sink_c = vector_sink_c.make;

class vector_source_b_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vector_source_b)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::vector_source_b)> self) -> vector_source_b_sptr
        __init__(boost::shared_ptr<(gr::blocks::vector_source_b)> self, vector_source_b p) -> vector_source_b_sptr
        """
        this = _blocks_swig1.new_vector_source_b_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_source_b_sptr self) -> vector_source_b"""
        return _blocks_swig1.vector_source_b_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_source_b_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(vector_source_b_sptr self, std::vector< unsigned char,std::allocator< unsigned char > > const & data, bool repeat=False, int vlen=1, tags_vector_t tags) -> vector_source_b_sptr"""
        return _blocks_swig1.vector_source_b_sptr_make(self, *args, **kwargs)


    def rewind(self):
        """rewind(vector_source_b_sptr self)"""
        return _blocks_swig1.vector_source_b_sptr_rewind(self)


    def set_data(self, *args, **kwargs):
        """set_data(vector_source_b_sptr self, std::vector< unsigned char,std::allocator< unsigned char > > const & data, tags_vector_t tags)"""
        return _blocks_swig1.vector_source_b_sptr_set_data(self, *args, **kwargs)


    def history(self):
        """history(vector_source_b_sptr self) -> unsigned int"""
        return _blocks_swig1.vector_source_b_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_source_b_sptr self, int which, int delay)
        declare_sample_delay(vector_source_b_sptr self, unsigned int delay)
        """
        return _blocks_swig1.vector_source_b_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_source_b_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.vector_source_b_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_source_b_sptr self) -> int"""
        return _blocks_swig1.vector_source_b_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_source_b_sptr self) -> double"""
        return _blocks_swig1.vector_source_b_sptr_relative_rate(self)


    def start(self):
        """start(vector_source_b_sptr self) -> bool"""
        return _blocks_swig1.vector_source_b_sptr_start(self)


    def stop(self):
        """stop(vector_source_b_sptr self) -> bool"""
        return _blocks_swig1.vector_source_b_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_source_b_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.vector_source_b_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_source_b_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.vector_source_b_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_source_b_sptr self) -> int"""
        return _blocks_swig1.vector_source_b_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_source_b_sptr self, int m)"""
        return _blocks_swig1.vector_source_b_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_source_b_sptr self)"""
        return _blocks_swig1.vector_source_b_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_source_b_sptr self) -> bool"""
        return _blocks_swig1.vector_source_b_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_source_b_sptr self, int m)"""
        return _blocks_swig1.vector_source_b_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_source_b_sptr self) -> int"""
        return _blocks_swig1.vector_source_b_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_source_b_sptr self, int i) -> long"""
        return _blocks_swig1.vector_source_b_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_source_b_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_source_b_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.vector_source_b_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_source_b_sptr self, int i) -> long"""
        return _blocks_swig1.vector_source_b_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_source_b_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_source_b_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.vector_source_b_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_source_b_sptr self) -> float"""
        return _blocks_swig1.vector_source_b_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_source_b_sptr self) -> float"""
        return _blocks_swig1.vector_source_b_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_source_b_sptr self) -> float"""
        return _blocks_swig1.vector_source_b_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_source_b_sptr self) -> float"""
        return _blocks_swig1.vector_source_b_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_source_b_sptr self) -> float"""
        return _blocks_swig1.vector_source_b_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_source_b_sptr self) -> float"""
        return _blocks_swig1.vector_source_b_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_source_b_sptr self, int which) -> float
        pc_input_buffers_full(vector_source_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_b_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_source_b_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_source_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_b_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_source_b_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_source_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_b_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_source_b_sptr self, int which) -> float
        pc_output_buffers_full(vector_source_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_b_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_source_b_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_source_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_b_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_source_b_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_source_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_b_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_source_b_sptr self) -> float"""
        return _blocks_swig1.vector_source_b_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_source_b_sptr self) -> float"""
        return _blocks_swig1.vector_source_b_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_source_b_sptr self) -> float"""
        return _blocks_swig1.vector_source_b_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_source_b_sptr self) -> float"""
        return _blocks_swig1.vector_source_b_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_source_b_sptr self) -> float"""
        return _blocks_swig1.vector_source_b_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_source_b_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.vector_source_b_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_source_b_sptr self)"""
        return _blocks_swig1.vector_source_b_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_source_b_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_source_b_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_source_b_sptr self) -> int"""
        return _blocks_swig1.vector_source_b_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_source_b_sptr self) -> int"""
        return _blocks_swig1.vector_source_b_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_source_b_sptr self, int priority) -> int"""
        return _blocks_swig1.vector_source_b_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_source_b_sptr self) -> std::string"""
        return _blocks_swig1.vector_source_b_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_source_b_sptr self) -> std::string"""
        return _blocks_swig1.vector_source_b_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_source_b_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_source_b_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_source_b_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_source_b_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_source_b_sptr self) -> long"""
        return _blocks_swig1.vector_source_b_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_source_b_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.vector_source_b_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_source_b_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.vector_source_b_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_source_b_sptr self) -> std::string"""
        return _blocks_swig1.vector_source_b_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_source_b_sptr self, std::string name)"""
        return _blocks_swig1.vector_source_b_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_source_b_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.vector_source_b_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_source_b_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_source_b_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_source_b_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_source_b_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_source_b_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.vector_source_b_sptr_message_subscribers(self, which_port)

vector_source_b_sptr_swigregister = _blocks_swig1.vector_source_b_sptr_swigregister
vector_source_b_sptr_swigregister(vector_source_b_sptr)

vector_source_b_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_source_b = vector_source_b.make;

class vector_source_s_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vector_source_s)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::vector_source_s)> self) -> vector_source_s_sptr
        __init__(boost::shared_ptr<(gr::blocks::vector_source_s)> self, vector_source_s p) -> vector_source_s_sptr
        """
        this = _blocks_swig1.new_vector_source_s_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_source_s_sptr self) -> vector_source_s"""
        return _blocks_swig1.vector_source_s_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_source_s_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(vector_source_s_sptr self, std::vector< short,std::allocator< short > > const & data, bool repeat=False, int vlen=1, tags_vector_t tags) -> vector_source_s_sptr"""
        return _blocks_swig1.vector_source_s_sptr_make(self, *args, **kwargs)


    def rewind(self):
        """rewind(vector_source_s_sptr self)"""
        return _blocks_swig1.vector_source_s_sptr_rewind(self)


    def set_data(self, *args, **kwargs):
        """set_data(vector_source_s_sptr self, std::vector< short,std::allocator< short > > const & data, tags_vector_t tags)"""
        return _blocks_swig1.vector_source_s_sptr_set_data(self, *args, **kwargs)


    def history(self):
        """history(vector_source_s_sptr self) -> unsigned int"""
        return _blocks_swig1.vector_source_s_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_source_s_sptr self, int which, int delay)
        declare_sample_delay(vector_source_s_sptr self, unsigned int delay)
        """
        return _blocks_swig1.vector_source_s_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_source_s_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.vector_source_s_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_source_s_sptr self) -> int"""
        return _blocks_swig1.vector_source_s_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_source_s_sptr self) -> double"""
        return _blocks_swig1.vector_source_s_sptr_relative_rate(self)


    def start(self):
        """start(vector_source_s_sptr self) -> bool"""
        return _blocks_swig1.vector_source_s_sptr_start(self)


    def stop(self):
        """stop(vector_source_s_sptr self) -> bool"""
        return _blocks_swig1.vector_source_s_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_source_s_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.vector_source_s_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_source_s_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.vector_source_s_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_source_s_sptr self) -> int"""
        return _blocks_swig1.vector_source_s_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_source_s_sptr self, int m)"""
        return _blocks_swig1.vector_source_s_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_source_s_sptr self)"""
        return _blocks_swig1.vector_source_s_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_source_s_sptr self) -> bool"""
        return _blocks_swig1.vector_source_s_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_source_s_sptr self, int m)"""
        return _blocks_swig1.vector_source_s_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_source_s_sptr self) -> int"""
        return _blocks_swig1.vector_source_s_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_source_s_sptr self, int i) -> long"""
        return _blocks_swig1.vector_source_s_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_source_s_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_source_s_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.vector_source_s_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_source_s_sptr self, int i) -> long"""
        return _blocks_swig1.vector_source_s_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_source_s_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_source_s_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.vector_source_s_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_source_s_sptr self) -> float"""
        return _blocks_swig1.vector_source_s_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_source_s_sptr self) -> float"""
        return _blocks_swig1.vector_source_s_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_source_s_sptr self) -> float"""
        return _blocks_swig1.vector_source_s_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_source_s_sptr self) -> float"""
        return _blocks_swig1.vector_source_s_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_source_s_sptr self) -> float"""
        return _blocks_swig1.vector_source_s_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_source_s_sptr self) -> float"""
        return _blocks_swig1.vector_source_s_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_source_s_sptr self, int which) -> float
        pc_input_buffers_full(vector_source_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_s_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_source_s_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_source_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_s_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_source_s_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_source_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_s_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_source_s_sptr self, int which) -> float
        pc_output_buffers_full(vector_source_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_s_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_source_s_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_source_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_s_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_source_s_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_source_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_s_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_source_s_sptr self) -> float"""
        return _blocks_swig1.vector_source_s_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_source_s_sptr self) -> float"""
        return _blocks_swig1.vector_source_s_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_source_s_sptr self) -> float"""
        return _blocks_swig1.vector_source_s_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_source_s_sptr self) -> float"""
        return _blocks_swig1.vector_source_s_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_source_s_sptr self) -> float"""
        return _blocks_swig1.vector_source_s_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_source_s_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.vector_source_s_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_source_s_sptr self)"""
        return _blocks_swig1.vector_source_s_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_source_s_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_source_s_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_source_s_sptr self) -> int"""
        return _blocks_swig1.vector_source_s_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_source_s_sptr self) -> int"""
        return _blocks_swig1.vector_source_s_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_source_s_sptr self, int priority) -> int"""
        return _blocks_swig1.vector_source_s_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_source_s_sptr self) -> std::string"""
        return _blocks_swig1.vector_source_s_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_source_s_sptr self) -> std::string"""
        return _blocks_swig1.vector_source_s_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_source_s_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_source_s_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_source_s_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_source_s_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_source_s_sptr self) -> long"""
        return _blocks_swig1.vector_source_s_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_source_s_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.vector_source_s_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_source_s_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.vector_source_s_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_source_s_sptr self) -> std::string"""
        return _blocks_swig1.vector_source_s_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_source_s_sptr self, std::string name)"""
        return _blocks_swig1.vector_source_s_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_source_s_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.vector_source_s_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_source_s_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_source_s_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_source_s_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_source_s_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_source_s_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.vector_source_s_sptr_message_subscribers(self, which_port)

vector_source_s_sptr_swigregister = _blocks_swig1.vector_source_s_sptr_swigregister
vector_source_s_sptr_swigregister(vector_source_s_sptr)

vector_source_s_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_source_s = vector_source_s.make;

class vector_source_i_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vector_source_i)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::vector_source_i)> self) -> vector_source_i_sptr
        __init__(boost::shared_ptr<(gr::blocks::vector_source_i)> self, vector_source_i p) -> vector_source_i_sptr
        """
        this = _blocks_swig1.new_vector_source_i_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_source_i_sptr self) -> vector_source_i"""
        return _blocks_swig1.vector_source_i_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_source_i_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(vector_source_i_sptr self, std::vector< int,std::allocator< int > > const & data, bool repeat=False, int vlen=1, tags_vector_t tags) -> vector_source_i_sptr"""
        return _blocks_swig1.vector_source_i_sptr_make(self, *args, **kwargs)


    def rewind(self):
        """rewind(vector_source_i_sptr self)"""
        return _blocks_swig1.vector_source_i_sptr_rewind(self)


    def set_data(self, *args, **kwargs):
        """set_data(vector_source_i_sptr self, std::vector< int,std::allocator< int > > const & data, tags_vector_t tags)"""
        return _blocks_swig1.vector_source_i_sptr_set_data(self, *args, **kwargs)


    def history(self):
        """history(vector_source_i_sptr self) -> unsigned int"""
        return _blocks_swig1.vector_source_i_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_source_i_sptr self, int which, int delay)
        declare_sample_delay(vector_source_i_sptr self, unsigned int delay)
        """
        return _blocks_swig1.vector_source_i_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_source_i_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.vector_source_i_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_source_i_sptr self) -> int"""
        return _blocks_swig1.vector_source_i_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_source_i_sptr self) -> double"""
        return _blocks_swig1.vector_source_i_sptr_relative_rate(self)


    def start(self):
        """start(vector_source_i_sptr self) -> bool"""
        return _blocks_swig1.vector_source_i_sptr_start(self)


    def stop(self):
        """stop(vector_source_i_sptr self) -> bool"""
        return _blocks_swig1.vector_source_i_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_source_i_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.vector_source_i_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_source_i_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.vector_source_i_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_source_i_sptr self) -> int"""
        return _blocks_swig1.vector_source_i_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_source_i_sptr self, int m)"""
        return _blocks_swig1.vector_source_i_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_source_i_sptr self)"""
        return _blocks_swig1.vector_source_i_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_source_i_sptr self) -> bool"""
        return _blocks_swig1.vector_source_i_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_source_i_sptr self, int m)"""
        return _blocks_swig1.vector_source_i_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_source_i_sptr self) -> int"""
        return _blocks_swig1.vector_source_i_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_source_i_sptr self, int i) -> long"""
        return _blocks_swig1.vector_source_i_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_source_i_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_source_i_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.vector_source_i_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_source_i_sptr self, int i) -> long"""
        return _blocks_swig1.vector_source_i_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_source_i_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_source_i_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.vector_source_i_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_source_i_sptr self) -> float"""
        return _blocks_swig1.vector_source_i_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_source_i_sptr self) -> float"""
        return _blocks_swig1.vector_source_i_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_source_i_sptr self) -> float"""
        return _blocks_swig1.vector_source_i_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_source_i_sptr self) -> float"""
        return _blocks_swig1.vector_source_i_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_source_i_sptr self) -> float"""
        return _blocks_swig1.vector_source_i_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_source_i_sptr self) -> float"""
        return _blocks_swig1.vector_source_i_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_source_i_sptr self, int which) -> float
        pc_input_buffers_full(vector_source_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_i_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_source_i_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_source_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_i_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_source_i_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_source_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_i_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_source_i_sptr self, int which) -> float
        pc_output_buffers_full(vector_source_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_i_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_source_i_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_source_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_i_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_source_i_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_source_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_i_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_source_i_sptr self) -> float"""
        return _blocks_swig1.vector_source_i_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_source_i_sptr self) -> float"""
        return _blocks_swig1.vector_source_i_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_source_i_sptr self) -> float"""
        return _blocks_swig1.vector_source_i_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_source_i_sptr self) -> float"""
        return _blocks_swig1.vector_source_i_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_source_i_sptr self) -> float"""
        return _blocks_swig1.vector_source_i_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_source_i_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.vector_source_i_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_source_i_sptr self)"""
        return _blocks_swig1.vector_source_i_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_source_i_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_source_i_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_source_i_sptr self) -> int"""
        return _blocks_swig1.vector_source_i_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_source_i_sptr self) -> int"""
        return _blocks_swig1.vector_source_i_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_source_i_sptr self, int priority) -> int"""
        return _blocks_swig1.vector_source_i_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_source_i_sptr self) -> std::string"""
        return _blocks_swig1.vector_source_i_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_source_i_sptr self) -> std::string"""
        return _blocks_swig1.vector_source_i_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_source_i_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_source_i_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_source_i_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_source_i_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_source_i_sptr self) -> long"""
        return _blocks_swig1.vector_source_i_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_source_i_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.vector_source_i_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_source_i_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.vector_source_i_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_source_i_sptr self) -> std::string"""
        return _blocks_swig1.vector_source_i_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_source_i_sptr self, std::string name)"""
        return _blocks_swig1.vector_source_i_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_source_i_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.vector_source_i_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_source_i_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_source_i_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_source_i_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_source_i_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_source_i_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.vector_source_i_sptr_message_subscribers(self, which_port)

vector_source_i_sptr_swigregister = _blocks_swig1.vector_source_i_sptr_swigregister
vector_source_i_sptr_swigregister(vector_source_i_sptr)

vector_source_i_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_source_i = vector_source_i.make;

class vector_source_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vector_source_f)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::vector_source_f)> self) -> vector_source_f_sptr
        __init__(boost::shared_ptr<(gr::blocks::vector_source_f)> self, vector_source_f p) -> vector_source_f_sptr
        """
        this = _blocks_swig1.new_vector_source_f_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_source_f_sptr self) -> vector_source_f"""
        return _blocks_swig1.vector_source_f_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_source_f_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(vector_source_f_sptr self, pmt_vector_float data, bool repeat=False, int vlen=1, tags_vector_t tags) -> vector_source_f_sptr"""
        return _blocks_swig1.vector_source_f_sptr_make(self, *args, **kwargs)


    def rewind(self):
        """rewind(vector_source_f_sptr self)"""
        return _blocks_swig1.vector_source_f_sptr_rewind(self)


    def set_data(self, *args, **kwargs):
        """set_data(vector_source_f_sptr self, pmt_vector_float data, tags_vector_t tags)"""
        return _blocks_swig1.vector_source_f_sptr_set_data(self, *args, **kwargs)


    def history(self):
        """history(vector_source_f_sptr self) -> unsigned int"""
        return _blocks_swig1.vector_source_f_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_source_f_sptr self, int which, int delay)
        declare_sample_delay(vector_source_f_sptr self, unsigned int delay)
        """
        return _blocks_swig1.vector_source_f_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_source_f_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.vector_source_f_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_source_f_sptr self) -> int"""
        return _blocks_swig1.vector_source_f_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_source_f_sptr self) -> double"""
        return _blocks_swig1.vector_source_f_sptr_relative_rate(self)


    def start(self):
        """start(vector_source_f_sptr self) -> bool"""
        return _blocks_swig1.vector_source_f_sptr_start(self)


    def stop(self):
        """stop(vector_source_f_sptr self) -> bool"""
        return _blocks_swig1.vector_source_f_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_source_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.vector_source_f_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_source_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.vector_source_f_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_source_f_sptr self) -> int"""
        return _blocks_swig1.vector_source_f_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_source_f_sptr self, int m)"""
        return _blocks_swig1.vector_source_f_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_source_f_sptr self)"""
        return _blocks_swig1.vector_source_f_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_source_f_sptr self) -> bool"""
        return _blocks_swig1.vector_source_f_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_source_f_sptr self, int m)"""
        return _blocks_swig1.vector_source_f_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_source_f_sptr self) -> int"""
        return _blocks_swig1.vector_source_f_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_source_f_sptr self, int i) -> long"""
        return _blocks_swig1.vector_source_f_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_source_f_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_source_f_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.vector_source_f_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_source_f_sptr self, int i) -> long"""
        return _blocks_swig1.vector_source_f_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_source_f_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_source_f_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.vector_source_f_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_source_f_sptr self) -> float"""
        return _blocks_swig1.vector_source_f_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_source_f_sptr self) -> float"""
        return _blocks_swig1.vector_source_f_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_source_f_sptr self) -> float"""
        return _blocks_swig1.vector_source_f_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_source_f_sptr self) -> float"""
        return _blocks_swig1.vector_source_f_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_source_f_sptr self) -> float"""
        return _blocks_swig1.vector_source_f_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_source_f_sptr self) -> float"""
        return _blocks_swig1.vector_source_f_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_source_f_sptr self, int which) -> float
        pc_input_buffers_full(vector_source_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_f_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_source_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_source_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_f_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_source_f_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_source_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_f_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_source_f_sptr self, int which) -> float
        pc_output_buffers_full(vector_source_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_f_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_source_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_source_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_f_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_source_f_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_source_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_f_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_source_f_sptr self) -> float"""
        return _blocks_swig1.vector_source_f_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_source_f_sptr self) -> float"""
        return _blocks_swig1.vector_source_f_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_source_f_sptr self) -> float"""
        return _blocks_swig1.vector_source_f_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_source_f_sptr self) -> float"""
        return _blocks_swig1.vector_source_f_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_source_f_sptr self) -> float"""
        return _blocks_swig1.vector_source_f_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_source_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.vector_source_f_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_source_f_sptr self)"""
        return _blocks_swig1.vector_source_f_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_source_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_source_f_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_source_f_sptr self) -> int"""
        return _blocks_swig1.vector_source_f_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_source_f_sptr self) -> int"""
        return _blocks_swig1.vector_source_f_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_source_f_sptr self, int priority) -> int"""
        return _blocks_swig1.vector_source_f_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_source_f_sptr self) -> std::string"""
        return _blocks_swig1.vector_source_f_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_source_f_sptr self) -> std::string"""
        return _blocks_swig1.vector_source_f_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_source_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_source_f_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_source_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_source_f_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_source_f_sptr self) -> long"""
        return _blocks_swig1.vector_source_f_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_source_f_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.vector_source_f_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_source_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.vector_source_f_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_source_f_sptr self) -> std::string"""
        return _blocks_swig1.vector_source_f_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_source_f_sptr self, std::string name)"""
        return _blocks_swig1.vector_source_f_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_source_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.vector_source_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_source_f_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_source_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_source_f_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_source_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_source_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.vector_source_f_sptr_message_subscribers(self, which_port)

vector_source_f_sptr_swigregister = _blocks_swig1.vector_source_f_sptr_swigregister
vector_source_f_sptr_swigregister(vector_source_f_sptr)

vector_source_f_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_source_f = vector_source_f.make;

class vector_source_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::vector_source_c)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::vector_source_c)> self) -> vector_source_c_sptr
        __init__(boost::shared_ptr<(gr::blocks::vector_source_c)> self, vector_source_c p) -> vector_source_c_sptr
        """
        this = _blocks_swig1.new_vector_source_c_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(vector_source_c_sptr self) -> vector_source_c"""
        return _blocks_swig1.vector_source_c_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_vector_source_c_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(vector_source_c_sptr self, pmt_vector_cfloat data, bool repeat=False, int vlen=1, tags_vector_t tags) -> vector_source_c_sptr"""
        return _blocks_swig1.vector_source_c_sptr_make(self, *args, **kwargs)


    def rewind(self):
        """rewind(vector_source_c_sptr self)"""
        return _blocks_swig1.vector_source_c_sptr_rewind(self)


    def set_data(self, *args, **kwargs):
        """set_data(vector_source_c_sptr self, pmt_vector_cfloat data, tags_vector_t tags)"""
        return _blocks_swig1.vector_source_c_sptr_set_data(self, *args, **kwargs)


    def history(self):
        """history(vector_source_c_sptr self) -> unsigned int"""
        return _blocks_swig1.vector_source_c_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_source_c_sptr self, int which, int delay)
        declare_sample_delay(vector_source_c_sptr self, unsigned int delay)
        """
        return _blocks_swig1.vector_source_c_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_source_c_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.vector_source_c_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_source_c_sptr self) -> int"""
        return _blocks_swig1.vector_source_c_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_source_c_sptr self) -> double"""
        return _blocks_swig1.vector_source_c_sptr_relative_rate(self)


    def start(self):
        """start(vector_source_c_sptr self) -> bool"""
        return _blocks_swig1.vector_source_c_sptr_start(self)


    def stop(self):
        """stop(vector_source_c_sptr self) -> bool"""
        return _blocks_swig1.vector_source_c_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_source_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.vector_source_c_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_source_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.vector_source_c_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_source_c_sptr self) -> int"""
        return _blocks_swig1.vector_source_c_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_source_c_sptr self, int m)"""
        return _blocks_swig1.vector_source_c_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_source_c_sptr self)"""
        return _blocks_swig1.vector_source_c_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_source_c_sptr self) -> bool"""
        return _blocks_swig1.vector_source_c_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_source_c_sptr self, int m)"""
        return _blocks_swig1.vector_source_c_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_source_c_sptr self) -> int"""
        return _blocks_swig1.vector_source_c_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_source_c_sptr self, int i) -> long"""
        return _blocks_swig1.vector_source_c_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_source_c_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_source_c_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.vector_source_c_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_source_c_sptr self, int i) -> long"""
        return _blocks_swig1.vector_source_c_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_source_c_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_source_c_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.vector_source_c_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_source_c_sptr self) -> float"""
        return _blocks_swig1.vector_source_c_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_source_c_sptr self) -> float"""
        return _blocks_swig1.vector_source_c_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_source_c_sptr self) -> float"""
        return _blocks_swig1.vector_source_c_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_source_c_sptr self) -> float"""
        return _blocks_swig1.vector_source_c_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_source_c_sptr self) -> float"""
        return _blocks_swig1.vector_source_c_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_source_c_sptr self) -> float"""
        return _blocks_swig1.vector_source_c_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_source_c_sptr self, int which) -> float
        pc_input_buffers_full(vector_source_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_c_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_source_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_source_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_c_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_source_c_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_source_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_c_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_source_c_sptr self, int which) -> float
        pc_output_buffers_full(vector_source_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_c_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_source_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_source_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_c_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_source_c_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_source_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.vector_source_c_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_source_c_sptr self) -> float"""
        return _blocks_swig1.vector_source_c_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_source_c_sptr self) -> float"""
        return _blocks_swig1.vector_source_c_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_source_c_sptr self) -> float"""
        return _blocks_swig1.vector_source_c_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_source_c_sptr self) -> float"""
        return _blocks_swig1.vector_source_c_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_source_c_sptr self) -> float"""
        return _blocks_swig1.vector_source_c_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_source_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.vector_source_c_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_source_c_sptr self)"""
        return _blocks_swig1.vector_source_c_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_source_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.vector_source_c_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_source_c_sptr self) -> int"""
        return _blocks_swig1.vector_source_c_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_source_c_sptr self) -> int"""
        return _blocks_swig1.vector_source_c_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_source_c_sptr self, int priority) -> int"""
        return _blocks_swig1.vector_source_c_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_source_c_sptr self) -> std::string"""
        return _blocks_swig1.vector_source_c_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_source_c_sptr self) -> std::string"""
        return _blocks_swig1.vector_source_c_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_source_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_source_c_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_source_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.vector_source_c_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_source_c_sptr self) -> long"""
        return _blocks_swig1.vector_source_c_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_source_c_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.vector_source_c_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_source_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.vector_source_c_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_source_c_sptr self) -> std::string"""
        return _blocks_swig1.vector_source_c_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_source_c_sptr self, std::string name)"""
        return _blocks_swig1.vector_source_c_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_source_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.vector_source_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_source_c_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_source_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_source_c_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.vector_source_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_source_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.vector_source_c_sptr_message_subscribers(self, which_port)

vector_source_c_sptr_swigregister = _blocks_swig1.vector_source_c_sptr_swigregister
vector_source_c_sptr_swigregister(vector_source_c_sptr)

vector_source_c_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
vector_source_c = vector_source_c.make;

class wavfile_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::wavfile_sink)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::wavfile_sink)> self) -> wavfile_sink_sptr
        __init__(boost::shared_ptr<(gr::blocks::wavfile_sink)> self, wavfile_sink p) -> wavfile_sink_sptr
        """
        this = _blocks_swig1.new_wavfile_sink_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(wavfile_sink_sptr self) -> wavfile_sink"""
        return _blocks_swig1.wavfile_sink_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_wavfile_sink_sptr
    __del__ = lambda self: None

    def make(self, filename, n_channels, sample_rate, bits_per_sample=16):
        """make(wavfile_sink_sptr self, char const * filename, int n_channels, unsigned int sample_rate, int bits_per_sample=16) -> wavfile_sink_sptr"""
        return _blocks_swig1.wavfile_sink_sptr_make(self, filename, n_channels, sample_rate, bits_per_sample)


    def open(self, filename):
        """open(wavfile_sink_sptr self, char const * filename) -> bool"""
        return _blocks_swig1.wavfile_sink_sptr_open(self, filename)


    def close(self):
        """close(wavfile_sink_sptr self)"""
        return _blocks_swig1.wavfile_sink_sptr_close(self)


    def set_sample_rate(self, sample_rate):
        """set_sample_rate(wavfile_sink_sptr self, unsigned int sample_rate)"""
        return _blocks_swig1.wavfile_sink_sptr_set_sample_rate(self, sample_rate)


    def set_bits_per_sample(self, bits_per_sample):
        """set_bits_per_sample(wavfile_sink_sptr self, int bits_per_sample)"""
        return _blocks_swig1.wavfile_sink_sptr_set_bits_per_sample(self, bits_per_sample)


    def history(self):
        """history(wavfile_sink_sptr self) -> unsigned int"""
        return _blocks_swig1.wavfile_sink_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(wavfile_sink_sptr self, int which, int delay)
        declare_sample_delay(wavfile_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig1.wavfile_sink_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(wavfile_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.wavfile_sink_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(wavfile_sink_sptr self) -> int"""
        return _blocks_swig1.wavfile_sink_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(wavfile_sink_sptr self) -> double"""
        return _blocks_swig1.wavfile_sink_sptr_relative_rate(self)


    def start(self):
        """start(wavfile_sink_sptr self) -> bool"""
        return _blocks_swig1.wavfile_sink_sptr_start(self)


    def stop(self):
        """stop(wavfile_sink_sptr self) -> bool"""
        return _blocks_swig1.wavfile_sink_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(wavfile_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.wavfile_sink_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(wavfile_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.wavfile_sink_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(wavfile_sink_sptr self) -> int"""
        return _blocks_swig1.wavfile_sink_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(wavfile_sink_sptr self, int m)"""
        return _blocks_swig1.wavfile_sink_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(wavfile_sink_sptr self)"""
        return _blocks_swig1.wavfile_sink_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(wavfile_sink_sptr self) -> bool"""
        return _blocks_swig1.wavfile_sink_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(wavfile_sink_sptr self, int m)"""
        return _blocks_swig1.wavfile_sink_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(wavfile_sink_sptr self) -> int"""
        return _blocks_swig1.wavfile_sink_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(wavfile_sink_sptr self, int i) -> long"""
        return _blocks_swig1.wavfile_sink_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(wavfile_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(wavfile_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.wavfile_sink_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(wavfile_sink_sptr self, int i) -> long"""
        return _blocks_swig1.wavfile_sink_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(wavfile_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(wavfile_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.wavfile_sink_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(wavfile_sink_sptr self) -> float"""
        return _blocks_swig1.wavfile_sink_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(wavfile_sink_sptr self) -> float"""
        return _blocks_swig1.wavfile_sink_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(wavfile_sink_sptr self) -> float"""
        return _blocks_swig1.wavfile_sink_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(wavfile_sink_sptr self) -> float"""
        return _blocks_swig1.wavfile_sink_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(wavfile_sink_sptr self) -> float"""
        return _blocks_swig1.wavfile_sink_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(wavfile_sink_sptr self) -> float"""
        return _blocks_swig1.wavfile_sink_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(wavfile_sink_sptr self, int which) -> float
        pc_input_buffers_full(wavfile_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.wavfile_sink_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(wavfile_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(wavfile_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.wavfile_sink_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(wavfile_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(wavfile_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.wavfile_sink_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(wavfile_sink_sptr self, int which) -> float
        pc_output_buffers_full(wavfile_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.wavfile_sink_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(wavfile_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(wavfile_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.wavfile_sink_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(wavfile_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(wavfile_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.wavfile_sink_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(wavfile_sink_sptr self) -> float"""
        return _blocks_swig1.wavfile_sink_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(wavfile_sink_sptr self) -> float"""
        return _blocks_swig1.wavfile_sink_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(wavfile_sink_sptr self) -> float"""
        return _blocks_swig1.wavfile_sink_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(wavfile_sink_sptr self) -> float"""
        return _blocks_swig1.wavfile_sink_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(wavfile_sink_sptr self) -> float"""
        return _blocks_swig1.wavfile_sink_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(wavfile_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.wavfile_sink_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(wavfile_sink_sptr self)"""
        return _blocks_swig1.wavfile_sink_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(wavfile_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.wavfile_sink_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(wavfile_sink_sptr self) -> int"""
        return _blocks_swig1.wavfile_sink_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(wavfile_sink_sptr self) -> int"""
        return _blocks_swig1.wavfile_sink_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(wavfile_sink_sptr self, int priority) -> int"""
        return _blocks_swig1.wavfile_sink_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(wavfile_sink_sptr self) -> std::string"""
        return _blocks_swig1.wavfile_sink_sptr_name(self)


    def symbol_name(self):
        """symbol_name(wavfile_sink_sptr self) -> std::string"""
        return _blocks_swig1.wavfile_sink_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(wavfile_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.wavfile_sink_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(wavfile_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.wavfile_sink_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(wavfile_sink_sptr self) -> long"""
        return _blocks_swig1.wavfile_sink_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(wavfile_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.wavfile_sink_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(wavfile_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.wavfile_sink_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(wavfile_sink_sptr self) -> std::string"""
        return _blocks_swig1.wavfile_sink_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(wavfile_sink_sptr self, std::string name)"""
        return _blocks_swig1.wavfile_sink_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(wavfile_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.wavfile_sink_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(wavfile_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.wavfile_sink_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(wavfile_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.wavfile_sink_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(wavfile_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.wavfile_sink_sptr_message_subscribers(self, which_port)

wavfile_sink_sptr_swigregister = _blocks_swig1.wavfile_sink_sptr_swigregister
wavfile_sink_sptr_swigregister(wavfile_sink_sptr)

wavfile_sink_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
wavfile_sink = wavfile_sink.make;

class wavfile_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::wavfile_source)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::blocks::wavfile_source)> self) -> wavfile_source_sptr
        __init__(boost::shared_ptr<(gr::blocks::wavfile_source)> self, wavfile_source p) -> wavfile_source_sptr
        """
        this = _blocks_swig1.new_wavfile_source_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(wavfile_source_sptr self) -> wavfile_source"""
        return _blocks_swig1.wavfile_source_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig1.delete_wavfile_source_sptr
    __del__ = lambda self: None

    def make(self, filename, repeat=False):
        """make(wavfile_source_sptr self, char const * filename, bool repeat=False) -> wavfile_source_sptr"""
        return _blocks_swig1.wavfile_source_sptr_make(self, filename, repeat)


    def sample_rate(self):
        """sample_rate(wavfile_source_sptr self) -> unsigned int"""
        return _blocks_swig1.wavfile_source_sptr_sample_rate(self)


    def bits_per_sample(self):
        """bits_per_sample(wavfile_source_sptr self) -> int"""
        return _blocks_swig1.wavfile_source_sptr_bits_per_sample(self)


    def channels(self):
        """channels(wavfile_source_sptr self) -> int"""
        return _blocks_swig1.wavfile_source_sptr_channels(self)


    def history(self):
        """history(wavfile_source_sptr self) -> unsigned int"""
        return _blocks_swig1.wavfile_source_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(wavfile_source_sptr self, int which, int delay)
        declare_sample_delay(wavfile_source_sptr self, unsigned int delay)
        """
        return _blocks_swig1.wavfile_source_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(wavfile_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig1.wavfile_source_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(wavfile_source_sptr self) -> int"""
        return _blocks_swig1.wavfile_source_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(wavfile_source_sptr self) -> double"""
        return _blocks_swig1.wavfile_source_sptr_relative_rate(self)


    def start(self):
        """start(wavfile_source_sptr self) -> bool"""
        return _blocks_swig1.wavfile_source_sptr_start(self)


    def stop(self):
        """stop(wavfile_source_sptr self) -> bool"""
        return _blocks_swig1.wavfile_source_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(wavfile_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig1.wavfile_source_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(wavfile_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig1.wavfile_source_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(wavfile_source_sptr self) -> int"""
        return _blocks_swig1.wavfile_source_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(wavfile_source_sptr self, int m)"""
        return _blocks_swig1.wavfile_source_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(wavfile_source_sptr self)"""
        return _blocks_swig1.wavfile_source_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(wavfile_source_sptr self) -> bool"""
        return _blocks_swig1.wavfile_source_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(wavfile_source_sptr self, int m)"""
        return _blocks_swig1.wavfile_source_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(wavfile_source_sptr self) -> int"""
        return _blocks_swig1.wavfile_source_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(wavfile_source_sptr self, int i) -> long"""
        return _blocks_swig1.wavfile_source_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(wavfile_source_sptr self, long max_output_buffer)
        set_max_output_buffer(wavfile_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig1.wavfile_source_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(wavfile_source_sptr self, int i) -> long"""
        return _blocks_swig1.wavfile_source_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(wavfile_source_sptr self, long min_output_buffer)
        set_min_output_buffer(wavfile_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig1.wavfile_source_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(wavfile_source_sptr self) -> float"""
        return _blocks_swig1.wavfile_source_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(wavfile_source_sptr self) -> float"""
        return _blocks_swig1.wavfile_source_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(wavfile_source_sptr self) -> float"""
        return _blocks_swig1.wavfile_source_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(wavfile_source_sptr self) -> float"""
        return _blocks_swig1.wavfile_source_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(wavfile_source_sptr self) -> float"""
        return _blocks_swig1.wavfile_source_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(wavfile_source_sptr self) -> float"""
        return _blocks_swig1.wavfile_source_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(wavfile_source_sptr self, int which) -> float
        pc_input_buffers_full(wavfile_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.wavfile_source_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(wavfile_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(wavfile_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.wavfile_source_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(wavfile_source_sptr self, int which) -> float
        pc_input_buffers_full_var(wavfile_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.wavfile_source_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(wavfile_source_sptr self, int which) -> float
        pc_output_buffers_full(wavfile_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.wavfile_source_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(wavfile_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(wavfile_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.wavfile_source_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(wavfile_source_sptr self, int which) -> float
        pc_output_buffers_full_var(wavfile_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig1.wavfile_source_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(wavfile_source_sptr self) -> float"""
        return _blocks_swig1.wavfile_source_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(wavfile_source_sptr self) -> float"""
        return _blocks_swig1.wavfile_source_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(wavfile_source_sptr self) -> float"""
        return _blocks_swig1.wavfile_source_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(wavfile_source_sptr self) -> float"""
        return _blocks_swig1.wavfile_source_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(wavfile_source_sptr self) -> float"""
        return _blocks_swig1.wavfile_source_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(wavfile_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig1.wavfile_source_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(wavfile_source_sptr self)"""
        return _blocks_swig1.wavfile_source_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(wavfile_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig1.wavfile_source_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(wavfile_source_sptr self) -> int"""
        return _blocks_swig1.wavfile_source_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(wavfile_source_sptr self) -> int"""
        return _blocks_swig1.wavfile_source_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(wavfile_source_sptr self, int priority) -> int"""
        return _blocks_swig1.wavfile_source_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(wavfile_source_sptr self) -> std::string"""
        return _blocks_swig1.wavfile_source_sptr_name(self)


    def symbol_name(self):
        """symbol_name(wavfile_source_sptr self) -> std::string"""
        return _blocks_swig1.wavfile_source_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(wavfile_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.wavfile_source_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(wavfile_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig1.wavfile_source_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(wavfile_source_sptr self) -> long"""
        return _blocks_swig1.wavfile_source_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(wavfile_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig1.wavfile_source_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(wavfile_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig1.wavfile_source_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(wavfile_source_sptr self) -> std::string"""
        return _blocks_swig1.wavfile_source_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(wavfile_source_sptr self, std::string name)"""
        return _blocks_swig1.wavfile_source_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(wavfile_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig1.wavfile_source_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(wavfile_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.wavfile_source_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(wavfile_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig1.wavfile_source_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(wavfile_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig1.wavfile_source_sptr_message_subscribers(self, which_port)

wavfile_source_sptr_swigregister = _blocks_swig1.wavfile_source_sptr_swigregister
wavfile_source_sptr_swigregister(wavfile_source_sptr)

wavfile_source_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
wavfile_source = wavfile_source.make;



