# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.7
#
# 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_swig0', [dirname(__file__)])
        except ImportError:
            import _blocks_swig0
            return _blocks_swig0
        if fp is not None:
            try:
                _mod = imp.load_module('_blocks_swig0', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _blocks_swig0 = swig_import_helper()
    del swig_import_helper
else:
    import _blocks_swig0
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_swig0.high_res_timer_now()

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

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

def high_res_timer_epoch():
    """high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _blocks_swig0.high_res_timer_epoch()
class annotator_1to1(object):
    """Proxy of C++ gr::blocks::annotator_1to1 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(when, sizeof_stream_item):
        """make(int when, size_t sizeof_stream_item) -> annotator_1to1_sptr"""
        return _blocks_swig0.annotator_1to1_make(when, sizeof_stream_item)

    make = staticmethod(make)

    def data(self):
        """data(annotator_1to1 self) -> tags_vector_t"""
        return _blocks_swig0.annotator_1to1_data(self)

    __swig_destroy__ = _blocks_swig0.delete_annotator_1to1
    __del__ = lambda self: None
annotator_1to1_swigregister = _blocks_swig0.annotator_1to1_swigregister
annotator_1to1_swigregister(annotator_1to1)

def annotator_1to1_make(when, sizeof_stream_item):
    """annotator_1to1_make(int when, size_t sizeof_stream_item) -> annotator_1to1_sptr"""
    return _blocks_swig0.annotator_1to1_make(when, sizeof_stream_item)

class annotator_alltoall(object):
    """Proxy of C++ gr::blocks::annotator_alltoall 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(when, sizeof_stream_item):
        """make(int when, size_t sizeof_stream_item) -> annotator_alltoall_sptr"""
        return _blocks_swig0.annotator_alltoall_make(when, sizeof_stream_item)

    make = staticmethod(make)

    def data(self):
        """data(annotator_alltoall self) -> tags_vector_t"""
        return _blocks_swig0.annotator_alltoall_data(self)

    __swig_destroy__ = _blocks_swig0.delete_annotator_alltoall
    __del__ = lambda self: None
annotator_alltoall_swigregister = _blocks_swig0.annotator_alltoall_swigregister
annotator_alltoall_swigregister(annotator_alltoall)

def annotator_alltoall_make(when, sizeof_stream_item):
    """annotator_alltoall_make(int when, size_t sizeof_stream_item) -> annotator_alltoall_sptr"""
    return _blocks_swig0.annotator_alltoall_make(when, sizeof_stream_item)

class annotator_raw(object):
    """Proxy of C++ gr::blocks::annotator_raw 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(sizeof_stream_item):
        """make(size_t sizeof_stream_item) -> annotator_raw_sptr"""
        return _blocks_swig0.annotator_raw_make(sizeof_stream_item)

    make = staticmethod(make)

    def add_tag(self, offset, key, val):
        """add_tag(annotator_raw self, uint64_t offset, swig_int_ptr key, swig_int_ptr val)"""
        return _blocks_swig0.annotator_raw_add_tag(self, offset, key, val)

    __swig_destroy__ = _blocks_swig0.delete_annotator_raw
    __del__ = lambda self: None
annotator_raw_swigregister = _blocks_swig0.annotator_raw_swigregister
annotator_raw_swigregister(annotator_raw)

def annotator_raw_make(sizeof_stream_item):
    """annotator_raw_make(size_t sizeof_stream_item) -> annotator_raw_sptr"""
    return _blocks_swig0.annotator_raw_make(sizeof_stream_item)

class control_loop(object):
    """Proxy of C++ gr::blocks::control_loop 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__(gr::blocks::control_loop self) -> control_loop
        __init__(gr::blocks::control_loop self, float loop_bw, float max_freq, float min_freq) -> control_loop
        """
        this = _blocks_swig0.new_control_loop(*args)
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _blocks_swig0.delete_control_loop
    __del__ = lambda self: None

    def update_gains(self):
        """update_gains(control_loop self)"""
        return _blocks_swig0.control_loop_update_gains(self)


    def advance_loop(self, error):
        """advance_loop(control_loop self, float error)"""
        return _blocks_swig0.control_loop_advance_loop(self, error)


    def phase_wrap(self):
        """phase_wrap(control_loop self)"""
        return _blocks_swig0.control_loop_phase_wrap(self)


    def frequency_limit(self):
        """frequency_limit(control_loop self)"""
        return _blocks_swig0.control_loop_frequency_limit(self)


    def set_loop_bandwidth(self, bw):
        """set_loop_bandwidth(control_loop self, float bw)"""
        return _blocks_swig0.control_loop_set_loop_bandwidth(self, bw)


    def set_damping_factor(self, df):
        """set_damping_factor(control_loop self, float df)"""
        return _blocks_swig0.control_loop_set_damping_factor(self, df)


    def set_alpha(self, alpha):
        """set_alpha(control_loop self, float alpha)"""
        return _blocks_swig0.control_loop_set_alpha(self, alpha)


    def set_beta(self, beta):
        """set_beta(control_loop self, float beta)"""
        return _blocks_swig0.control_loop_set_beta(self, beta)


    def set_frequency(self, freq):
        """set_frequency(control_loop self, float freq)"""
        return _blocks_swig0.control_loop_set_frequency(self, freq)


    def set_phase(self, phase):
        """set_phase(control_loop self, float phase)"""
        return _blocks_swig0.control_loop_set_phase(self, phase)


    def set_max_freq(self, freq):
        """set_max_freq(control_loop self, float freq)"""
        return _blocks_swig0.control_loop_set_max_freq(self, freq)


    def set_min_freq(self, freq):
        """set_min_freq(control_loop self, float freq)"""
        return _blocks_swig0.control_loop_set_min_freq(self, freq)


    def get_loop_bandwidth(self):
        """get_loop_bandwidth(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_loop_bandwidth(self)


    def get_damping_factor(self):
        """get_damping_factor(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_damping_factor(self)


    def get_alpha(self):
        """get_alpha(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_alpha(self)


    def get_beta(self):
        """get_beta(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_beta(self)


    def get_frequency(self):
        """get_frequency(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_frequency(self)


    def get_phase(self):
        """get_phase(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_phase(self)


    def get_max_freq(self):
        """get_max_freq(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_max_freq(self)


    def get_min_freq(self):
        """get_min_freq(control_loop self) -> float"""
        return _blocks_swig0.control_loop_get_min_freq(self)

control_loop_swigregister = _blocks_swig0.control_loop_swigregister
control_loop_swigregister(control_loop)


def tanhf_lut(x):
    """tanhf_lut(float x) -> float"""
    return _blocks_swig0.tanhf_lut(x)
class copy(object):
    """Proxy of C++ gr::blocks::copy 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):
        """make(size_t itemsize) -> copy_sptr"""
        return _blocks_swig0.copy_make(itemsize)

    make = staticmethod(make)

    def set_enabled(self, enable):
        """set_enabled(copy self, bool enable)"""
        return _blocks_swig0.copy_set_enabled(self, enable)


    def enabled(self):
        """enabled(copy self) -> bool"""
        return _blocks_swig0.copy_enabled(self)

    __swig_destroy__ = _blocks_swig0.delete_copy
    __del__ = lambda self: None
copy_swigregister = _blocks_swig0.copy_swigregister
copy_swigregister(copy)
cvar = _blocks_swig0.cvar

def copy_make(itemsize):
    """copy_make(size_t itemsize) -> copy_sptr"""
    return _blocks_swig0.copy_make(itemsize)

class delay(object):
    """Proxy of C++ gr::blocks::delay 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, delay):
        """make(size_t itemsize, int delay) -> delay_sptr"""
        return _blocks_swig0.delay_make(itemsize, delay)

    make = staticmethod(make)

    def dly(self):
        """dly(delay self) -> int"""
        return _blocks_swig0.delay_dly(self)


    def set_dly(self, d):
        """set_dly(delay self, int d)"""
        return _blocks_swig0.delay_set_dly(self, d)

    __swig_destroy__ = _blocks_swig0.delete_delay
    __del__ = lambda self: None
delay_swigregister = _blocks_swig0.delay_swigregister
delay_swigregister(delay)

def delay_make(itemsize, delay):
    """delay_make(size_t itemsize, int delay) -> delay_sptr"""
    return _blocks_swig0.delay_make(itemsize, delay)

class endian_swap(object):
    """Proxy of C++ gr::blocks::endian_swap 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(item_size_bytes=1):
        """make(size_t item_size_bytes=1) -> endian_swap_sptr"""
        return _blocks_swig0.endian_swap_make(item_size_bytes)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig0.delete_endian_swap
    __del__ = lambda self: None
endian_swap_swigregister = _blocks_swig0.endian_swap_swigregister
endian_swap_swigregister(endian_swap)

def endian_swap_make(item_size_bytes=1):
    """endian_swap_make(size_t item_size_bytes=1) -> endian_swap_sptr"""
    return _blocks_swig0.endian_swap_make(item_size_bytes)

class file_descriptor_sink(object):
    """Proxy of C++ gr::blocks::file_descriptor_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, fd):
        """make(size_t itemsize, int fd) -> file_descriptor_sink_sptr"""
        return _blocks_swig0.file_descriptor_sink_make(itemsize, fd)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig0.delete_file_descriptor_sink
    __del__ = lambda self: None
file_descriptor_sink_swigregister = _blocks_swig0.file_descriptor_sink_swigregister
file_descriptor_sink_swigregister(file_descriptor_sink)

def file_descriptor_sink_make(itemsize, fd):
    """file_descriptor_sink_make(size_t itemsize, int fd) -> file_descriptor_sink_sptr"""
    return _blocks_swig0.file_descriptor_sink_make(itemsize, fd)

class file_descriptor_source(object):
    """Proxy of C++ gr::blocks::file_descriptor_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(itemsize, fd, repeat=False):
        """make(size_t itemsize, int fd, bool repeat=False) -> file_descriptor_source_sptr"""
        return _blocks_swig0.file_descriptor_source_make(itemsize, fd, repeat)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig0.delete_file_descriptor_source
    __del__ = lambda self: None
file_descriptor_source_swigregister = _blocks_swig0.file_descriptor_source_swigregister
file_descriptor_source_swigregister(file_descriptor_source)

def file_descriptor_source_make(itemsize, fd, repeat=False):
    """file_descriptor_source_make(size_t itemsize, int fd, bool repeat=False) -> file_descriptor_source_sptr"""
    return _blocks_swig0.file_descriptor_source_make(itemsize, fd, repeat)

class file_sink_base(object):
    """Proxy of C++ gr::blocks::file_sink_base 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):
        """__init__(gr::blocks::file_sink_base self) -> file_sink_base"""
        this = _blocks_swig0.new_file_sink_base()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _blocks_swig0.delete_file_sink_base
    __del__ = lambda self: None

    def open(self, filename):
        """open(file_sink_base self, char const * filename) -> bool"""
        return _blocks_swig0.file_sink_base_open(self, filename)


    def close(self):
        """close(file_sink_base self)"""
        return _blocks_swig0.file_sink_base_close(self)


    def do_update(self):
        """do_update(file_sink_base self)"""
        return _blocks_swig0.file_sink_base_do_update(self)


    def set_unbuffered(self, unbuffered):
        """set_unbuffered(file_sink_base self, bool unbuffered)"""
        return _blocks_swig0.file_sink_base_set_unbuffered(self, unbuffered)

file_sink_base_swigregister = _blocks_swig0.file_sink_base_swigregister
file_sink_base_swigregister(file_sink_base)

class file_sink(file_sink_base):
    """Proxy of C++ gr::blocks::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, filename, append=False):
        """make(size_t itemsize, char const * filename, bool append=False) -> file_sink_sptr"""
        return _blocks_swig0.file_sink_make(itemsize, filename, append)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig0.delete_file_sink
    __del__ = lambda self: None
file_sink_swigregister = _blocks_swig0.file_sink_swigregister
file_sink_swigregister(file_sink)

def file_sink_make(itemsize, filename, append=False):
    """file_sink_make(size_t itemsize, char const * filename, bool append=False) -> file_sink_sptr"""
    return _blocks_swig0.file_sink_make(itemsize, filename, append)

class file_source(object):
    """Proxy of C++ gr::blocks::file_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(itemsize, filename, repeat=False):
        """make(size_t itemsize, char const * filename, bool repeat=False) -> file_source_sptr"""
        return _blocks_swig0.file_source_make(itemsize, filename, repeat)

    make = staticmethod(make)

    def seek(self, seek_point, whence):
        """seek(file_source self, long seek_point, int whence) -> bool"""
        return _blocks_swig0.file_source_seek(self, seek_point, whence)


    def open(self, filename, repeat):
        """open(file_source self, char const * filename, bool repeat)"""
        return _blocks_swig0.file_source_open(self, filename, repeat)


    def close(self):
        """close(file_source self)"""
        return _blocks_swig0.file_source_close(self)

    __swig_destroy__ = _blocks_swig0.delete_file_source
    __del__ = lambda self: None
file_source_swigregister = _blocks_swig0.file_source_swigregister
file_source_swigregister(file_source)

def file_source_make(itemsize, filename, repeat=False):
    """file_source_make(size_t itemsize, char const * filename, bool repeat=False) -> file_source_sptr"""
    return _blocks_swig0.file_source_make(itemsize, filename, repeat)


_blocks_swig0.GR_FILE_BYTE_swigconstant(_blocks_swig0)
GR_FILE_BYTE = _blocks_swig0.GR_FILE_BYTE

_blocks_swig0.GR_FILE_CHAR_swigconstant(_blocks_swig0)
GR_FILE_CHAR = _blocks_swig0.GR_FILE_CHAR

_blocks_swig0.GR_FILE_SHORT_swigconstant(_blocks_swig0)
GR_FILE_SHORT = _blocks_swig0.GR_FILE_SHORT

_blocks_swig0.GR_FILE_INT_swigconstant(_blocks_swig0)
GR_FILE_INT = _blocks_swig0.GR_FILE_INT

_blocks_swig0.GR_FILE_LONG_swigconstant(_blocks_swig0)
GR_FILE_LONG = _blocks_swig0.GR_FILE_LONG

_blocks_swig0.GR_FILE_LONG_LONG_swigconstant(_blocks_swig0)
GR_FILE_LONG_LONG = _blocks_swig0.GR_FILE_LONG_LONG

_blocks_swig0.GR_FILE_FLOAT_swigconstant(_blocks_swig0)
GR_FILE_FLOAT = _blocks_swig0.GR_FILE_FLOAT

_blocks_swig0.GR_FILE_DOUBLE_swigconstant(_blocks_swig0)
GR_FILE_DOUBLE = _blocks_swig0.GR_FILE_DOUBLE
class file_meta_sink(object):
    """Proxy of C++ gr::blocks::file_meta_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(*args, **kwargs):
        """make(size_t itemsize, std::string const & filename, double samp_rate=1, double relative_rate=1, gr::blocks::gr_file_types type, bool complex=True, size_t max_segment_size=1000000, std::string const & extra_dict, bool detached_header=False) -> file_meta_sink_sptr"""
        return _blocks_swig0.file_meta_sink_make(*args, **kwargs)

    make = staticmethod(make)

    def open(self, filename):
        """open(file_meta_sink self, std::string const & filename) -> bool"""
        return _blocks_swig0.file_meta_sink_open(self, filename)


    def close(self):
        """close(file_meta_sink self)"""
        return _blocks_swig0.file_meta_sink_close(self)


    def do_update(self):
        """do_update(file_meta_sink self)"""
        return _blocks_swig0.file_meta_sink_do_update(self)


    def set_unbuffered(self, unbuffered):
        """set_unbuffered(file_meta_sink self, bool unbuffered)"""
        return _blocks_swig0.file_meta_sink_set_unbuffered(self, unbuffered)

    __swig_destroy__ = _blocks_swig0.delete_file_meta_sink
    __del__ = lambda self: None
file_meta_sink_swigregister = _blocks_swig0.file_meta_sink_swigregister
file_meta_sink_swigregister(file_meta_sink)
METADATA_VERSION = cvar.METADATA_VERSION
METADATA_HEADER_SIZE = cvar.METADATA_HEADER_SIZE

def file_meta_sink_make(*args, **kwargs):
    """file_meta_sink_make(size_t itemsize, std::string const & filename, double samp_rate=1, double relative_rate=1, gr::blocks::gr_file_types type, bool complex=True, size_t max_segment_size=1000000, std::string const & extra_dict, bool detached_header=False) -> file_meta_sink_sptr"""
    return _blocks_swig0.file_meta_sink_make(*args, **kwargs)

class file_meta_source(object):
    """Proxy of C++ gr::blocks::file_meta_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(*args, **kwargs):
        """make(std::string const & filename, bool repeat=False, bool detached_header=False, std::string const & hdr_filename) -> file_meta_source_sptr"""
        return _blocks_swig0.file_meta_source_make(*args, **kwargs)

    make = staticmethod(make)

    def open(self, *args, **kwargs):
        """open(file_meta_source self, std::string const & filename, std::string const & hdr_filename) -> bool"""
        return _blocks_swig0.file_meta_source_open(self, *args, **kwargs)


    def close(self):
        """close(file_meta_source self)"""
        return _blocks_swig0.file_meta_source_close(self)


    def do_update(self):
        """do_update(file_meta_source self)"""
        return _blocks_swig0.file_meta_source_do_update(self)

    __swig_destroy__ = _blocks_swig0.delete_file_meta_source
    __del__ = lambda self: None
file_meta_source_swigregister = _blocks_swig0.file_meta_source_swigregister
file_meta_source_swigregister(file_meta_source)

def file_meta_source_make(*args, **kwargs):
    """file_meta_source_make(std::string const & filename, bool repeat=False, bool detached_header=False, std::string const & hdr_filename) -> file_meta_source_sptr"""
    return _blocks_swig0.file_meta_source_make(*args, **kwargs)

class head(object):
    """Proxy of C++ gr::blocks::head 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(sizeof_stream_item, nitems):
        """make(size_t sizeof_stream_item, uint64_t nitems) -> head_sptr"""
        return _blocks_swig0.head_make(sizeof_stream_item, nitems)

    make = staticmethod(make)

    def reset(self):
        """reset(head self)"""
        return _blocks_swig0.head_reset(self)


    def set_length(self, nitems):
        """set_length(head self, int nitems)"""
        return _blocks_swig0.head_set_length(self, nitems)

    __swig_destroy__ = _blocks_swig0.delete_head
    __del__ = lambda self: None
head_swigregister = _blocks_swig0.head_swigregister
head_swigregister(head)

def head_make(sizeof_stream_item, nitems):
    """head_make(size_t sizeof_stream_item, uint64_t nitems) -> head_sptr"""
    return _blocks_swig0.head_make(sizeof_stream_item, nitems)

class message_debug(object):
    """Proxy of C++ gr::blocks::message_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():
        """make() -> message_debug_sptr"""
        return _blocks_swig0.message_debug_make()

    make = staticmethod(make)

    def num_messages(self):
        """num_messages(message_debug self) -> int"""
        return _blocks_swig0.message_debug_num_messages(self)


    def get_message(self, i):
        """get_message(message_debug self, int i) -> swig_int_ptr"""
        return _blocks_swig0.message_debug_get_message(self, i)

    __swig_destroy__ = _blocks_swig0.delete_message_debug
    __del__ = lambda self: None
message_debug_swigregister = _blocks_swig0.message_debug_swigregister
message_debug_swigregister(message_debug)

def message_debug_make():
    """message_debug_make() -> message_debug_sptr"""
    return _blocks_swig0.message_debug_make()

class message_sink(object):
    """Proxy of C++ gr::blocks::message_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(*args):
        """
        make(size_t itemsize, msg_queue_sptr msgq, bool dont_block) -> message_sink_sptr
        make(size_t itemsize, msg_queue_sptr msgq, bool dont_block, std::string const & lengthtagname) -> message_sink_sptr
        """
        return _blocks_swig0.message_sink_make(*args)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig0.delete_message_sink
    __del__ = lambda self: None
message_sink_swigregister = _blocks_swig0.message_sink_swigregister
message_sink_swigregister(message_sink)

def message_sink_make(*args):
    """
    make(size_t itemsize, msg_queue_sptr msgq, bool dont_block) -> message_sink_sptr
    message_sink_make(size_t itemsize, msg_queue_sptr msgq, bool dont_block, std::string const & lengthtagname) -> message_sink_sptr
    """
    return _blocks_swig0.message_sink_make(*args)

class message_source(object):
    """Proxy of C++ gr::blocks::message_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(*args):
        """
        make(size_t itemsize, int msgq_limit=0) -> message_source_sptr
        make(size_t itemsize, msg_queue_sptr msgq) -> message_source_sptr
        make(size_t itemsize, msg_queue_sptr msgq, std::string const & lengthtagname) -> message_source_sptr
        """
        return _blocks_swig0.message_source_make(*args)

    make = staticmethod(make)

    def msgq(self):
        """msgq(message_source self) -> msg_queue_sptr"""
        return _blocks_swig0.message_source_msgq(self)

    __swig_destroy__ = _blocks_swig0.delete_message_source
    __del__ = lambda self: None
message_source_swigregister = _blocks_swig0.message_source_swigregister
message_source_swigregister(message_source)

def message_source_make(*args):
    """
    make(size_t itemsize, int msgq_limit=0) -> message_source_sptr
    make(size_t itemsize, msg_queue_sptr msgq) -> message_source_sptr
    message_source_make(size_t itemsize, msg_queue_sptr msgq, std::string const & lengthtagname) -> message_source_sptr
    """
    return _blocks_swig0.message_source_make(*args)

class message_strobe(object):
    """Proxy of C++ gr::blocks::message_strobe 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(msg, period_ms):
        """make(swig_int_ptr msg, float period_ms) -> message_strobe_sptr"""
        return _blocks_swig0.message_strobe_make(msg, period_ms)

    make = staticmethod(make)

    def set_msg(self, msg):
        """set_msg(message_strobe self, swig_int_ptr msg)"""
        return _blocks_swig0.message_strobe_set_msg(self, msg)


    def msg(self):
        """msg(message_strobe self) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_msg(self)


    def set_period(self, period_ms):
        """set_period(message_strobe self, float period_ms)"""
        return _blocks_swig0.message_strobe_set_period(self, period_ms)


    def period(self):
        """period(message_strobe self) -> float"""
        return _blocks_swig0.message_strobe_period(self)

    __swig_destroy__ = _blocks_swig0.delete_message_strobe
    __del__ = lambda self: None
message_strobe_swigregister = _blocks_swig0.message_strobe_swigregister
message_strobe_swigregister(message_strobe)

def message_strobe_make(msg, period_ms):
    """message_strobe_make(swig_int_ptr msg, float period_ms) -> message_strobe_sptr"""
    return _blocks_swig0.message_strobe_make(msg, period_ms)


_blocks_swig0.STROBE_POISSON_swigconstant(_blocks_swig0)
STROBE_POISSON = _blocks_swig0.STROBE_POISSON

_blocks_swig0.STROBE_GAUSSIAN_swigconstant(_blocks_swig0)
STROBE_GAUSSIAN = _blocks_swig0.STROBE_GAUSSIAN

_blocks_swig0.STROBE_UNIFORM_swigconstant(_blocks_swig0)
STROBE_UNIFORM = _blocks_swig0.STROBE_UNIFORM
class message_strobe_random(object):
    """Proxy of C++ gr::blocks::message_strobe_random 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(msg, dist, mean_ms, std_ms):
        """make(swig_int_ptr msg, gr::blocks::message_strobe_random_distribution_t dist, float mean_ms, float std_ms) -> message_strobe_random_sptr"""
        return _blocks_swig0.message_strobe_random_make(msg, dist, mean_ms, std_ms)

    make = staticmethod(make)

    def set_msg(self, msg):
        """set_msg(message_strobe_random self, swig_int_ptr msg)"""
        return _blocks_swig0.message_strobe_random_set_msg(self, msg)


    def msg(self):
        """msg(message_strobe_random self) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_random_msg(self)


    def set_dist(self, dist):
        """set_dist(message_strobe_random self, gr::blocks::message_strobe_random_distribution_t dist)"""
        return _blocks_swig0.message_strobe_random_set_dist(self, dist)


    def dist(self):
        """dist(message_strobe_random self) -> gr::blocks::message_strobe_random_distribution_t"""
        return _blocks_swig0.message_strobe_random_dist(self)


    def set_mean(self, mean):
        """set_mean(message_strobe_random self, float mean)"""
        return _blocks_swig0.message_strobe_random_set_mean(self, mean)


    def mean(self):
        """mean(message_strobe_random self) -> float"""
        return _blocks_swig0.message_strobe_random_mean(self)


    def set_std(self, std):
        """set_std(message_strobe_random self, float std)"""
        return _blocks_swig0.message_strobe_random_set_std(self, std)


    def std(self):
        """std(message_strobe_random self) -> float"""
        return _blocks_swig0.message_strobe_random_std(self)

    __swig_destroy__ = _blocks_swig0.delete_message_strobe_random
    __del__ = lambda self: None
message_strobe_random_swigregister = _blocks_swig0.message_strobe_random_swigregister
message_strobe_random_swigregister(message_strobe_random)

def message_strobe_random_make(msg, dist, mean_ms, std_ms):
    """message_strobe_random_make(swig_int_ptr msg, gr::blocks::message_strobe_random_distribution_t dist, float mean_ms, float std_ms) -> message_strobe_random_sptr"""
    return _blocks_swig0.message_strobe_random_make(msg, dist, mean_ms, std_ms)

class message_burst_source(object):
    """Proxy of C++ gr::blocks::message_burst_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(*args):
        """
        make(size_t itemsize, int msgq_limit) -> message_burst_source_sptr
        make(size_t itemsize, msg_queue_sptr msgq) -> message_burst_source_sptr
        """
        return _blocks_swig0.message_burst_source_make(*args)

    make = staticmethod(make)

    def msgq(self):
        """msgq(message_burst_source self) -> msg_queue_sptr"""
        return _blocks_swig0.message_burst_source_msgq(self)

    __swig_destroy__ = _blocks_swig0.delete_message_burst_source
    __del__ = lambda self: None
message_burst_source_swigregister = _blocks_swig0.message_burst_source_swigregister
message_burst_source_swigregister(message_burst_source)

def message_burst_source_make(*args):
    """
    make(size_t itemsize, int msgq_limit) -> message_burst_source_sptr
    message_burst_source_make(size_t itemsize, msg_queue_sptr msgq) -> message_burst_source_sptr
    """
    return _blocks_swig0.message_burst_source_make(*args)

class nop(object):
    """Proxy of C++ gr::blocks::nop 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(sizeof_stream_item):
        """make(size_t sizeof_stream_item) -> nop_sptr"""
        return _blocks_swig0.nop_make(sizeof_stream_item)

    make = staticmethod(make)

    def nmsgs_received(self):
        """nmsgs_received(nop self) -> int"""
        return _blocks_swig0.nop_nmsgs_received(self)


    def ctrlport_test(self):
        """ctrlport_test(nop self) -> int"""
        return _blocks_swig0.nop_ctrlport_test(self)


    def set_ctrlport_test(self, x):
        """set_ctrlport_test(nop self, int x)"""
        return _blocks_swig0.nop_set_ctrlport_test(self, x)

    __swig_destroy__ = _blocks_swig0.delete_nop
    __del__ = lambda self: None
nop_swigregister = _blocks_swig0.nop_swigregister
nop_swigregister(nop)

def nop_make(sizeof_stream_item):
    """nop_make(size_t sizeof_stream_item) -> nop_sptr"""
    return _blocks_swig0.nop_make(sizeof_stream_item)

class null_sink(object):
    """Proxy of C++ gr::blocks::null_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(sizeof_stream_item):
        """make(size_t sizeof_stream_item) -> null_sink_sptr"""
        return _blocks_swig0.null_sink_make(sizeof_stream_item)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig0.delete_null_sink
    __del__ = lambda self: None
null_sink_swigregister = _blocks_swig0.null_sink_swigregister
null_sink_swigregister(null_sink)

def null_sink_make(sizeof_stream_item):
    """null_sink_make(size_t sizeof_stream_item) -> null_sink_sptr"""
    return _blocks_swig0.null_sink_make(sizeof_stream_item)

class null_source(object):
    """Proxy of C++ gr::blocks::null_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")
    __repr__ = _swig_repr

    def make(sizeof_stream_item):
        """make(size_t sizeof_stream_item) -> null_source_sptr"""
        return _blocks_swig0.null_source_make(sizeof_stream_item)

    make = staticmethod(make)
    __swig_destroy__ = _blocks_swig0.delete_null_source
    __del__ = lambda self: None
null_source_swigregister = _blocks_swig0.null_source_swigregister
null_source_swigregister(null_source)

def null_source_make(sizeof_stream_item):
    """null_source_make(size_t sizeof_stream_item) -> null_source_sptr"""
    return _blocks_swig0.null_source_make(sizeof_stream_item)

class annotator_1to1_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::annotator_1to1)> 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::annotator_1to1)> self) -> annotator_1to1_sptr
        __init__(boost::shared_ptr<(gr::blocks::annotator_1to1)> self, annotator_1to1 p) -> annotator_1to1_sptr
        """
        this = _blocks_swig0.new_annotator_1to1_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(annotator_1to1_sptr self) -> annotator_1to1"""
        return _blocks_swig0.annotator_1to1_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_annotator_1to1_sptr
    __del__ = lambda self: None

    def make(self, when, sizeof_stream_item):
        """make(annotator_1to1_sptr self, int when, size_t sizeof_stream_item) -> annotator_1to1_sptr"""
        return _blocks_swig0.annotator_1to1_sptr_make(self, when, sizeof_stream_item)


    def data(self):
        """data(annotator_1to1_sptr self) -> tags_vector_t"""
        return _blocks_swig0.annotator_1to1_sptr_data(self)


    def history(self):
        """history(annotator_1to1_sptr self) -> unsigned int"""
        return _blocks_swig0.annotator_1to1_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(annotator_1to1_sptr self, int which, int delay)
        declare_sample_delay(annotator_1to1_sptr self, unsigned int delay)
        """
        return _blocks_swig0.annotator_1to1_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(annotator_1to1_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.annotator_1to1_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(annotator_1to1_sptr self) -> int"""
        return _blocks_swig0.annotator_1to1_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(annotator_1to1_sptr self) -> double"""
        return _blocks_swig0.annotator_1to1_sptr_relative_rate(self)


    def start(self):
        """start(annotator_1to1_sptr self) -> bool"""
        return _blocks_swig0.annotator_1to1_sptr_start(self)


    def stop(self):
        """stop(annotator_1to1_sptr self) -> bool"""
        return _blocks_swig0.annotator_1to1_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(annotator_1to1_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.annotator_1to1_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(annotator_1to1_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.annotator_1to1_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(annotator_1to1_sptr self) -> int"""
        return _blocks_swig0.annotator_1to1_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(annotator_1to1_sptr self, int m)"""
        return _blocks_swig0.annotator_1to1_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(annotator_1to1_sptr self)"""
        return _blocks_swig0.annotator_1to1_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(annotator_1to1_sptr self) -> bool"""
        return _blocks_swig0.annotator_1to1_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(annotator_1to1_sptr self, int m)"""
        return _blocks_swig0.annotator_1to1_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(annotator_1to1_sptr self) -> int"""
        return _blocks_swig0.annotator_1to1_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(annotator_1to1_sptr self, int i) -> long"""
        return _blocks_swig0.annotator_1to1_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(annotator_1to1_sptr self, long max_output_buffer)
        set_max_output_buffer(annotator_1to1_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.annotator_1to1_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(annotator_1to1_sptr self, int i) -> long"""
        return _blocks_swig0.annotator_1to1_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(annotator_1to1_sptr self, long min_output_buffer)
        set_min_output_buffer(annotator_1to1_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.annotator_1to1_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(annotator_1to1_sptr self, int which) -> float
        pc_input_buffers_full(annotator_1to1_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_1to1_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(annotator_1to1_sptr self, int which) -> float
        pc_input_buffers_full_avg(annotator_1to1_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_1to1_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(annotator_1to1_sptr self, int which) -> float
        pc_input_buffers_full_var(annotator_1to1_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_1to1_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(annotator_1to1_sptr self, int which) -> float
        pc_output_buffers_full(annotator_1to1_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_1to1_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(annotator_1to1_sptr self, int which) -> float
        pc_output_buffers_full_avg(annotator_1to1_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_1to1_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(annotator_1to1_sptr self, int which) -> float
        pc_output_buffers_full_var(annotator_1to1_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_1to1_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(annotator_1to1_sptr self) -> float"""
        return _blocks_swig0.annotator_1to1_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(annotator_1to1_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.annotator_1to1_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(annotator_1to1_sptr self)"""
        return _blocks_swig0.annotator_1to1_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(annotator_1to1_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.annotator_1to1_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(annotator_1to1_sptr self) -> int"""
        return _blocks_swig0.annotator_1to1_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(annotator_1to1_sptr self) -> int"""
        return _blocks_swig0.annotator_1to1_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(annotator_1to1_sptr self, int priority) -> int"""
        return _blocks_swig0.annotator_1to1_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(annotator_1to1_sptr self) -> std::string"""
        return _blocks_swig0.annotator_1to1_sptr_name(self)


    def symbol_name(self):
        """symbol_name(annotator_1to1_sptr self) -> std::string"""
        return _blocks_swig0.annotator_1to1_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(annotator_1to1_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.annotator_1to1_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(annotator_1to1_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.annotator_1to1_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(annotator_1to1_sptr self) -> long"""
        return _blocks_swig0.annotator_1to1_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(annotator_1to1_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.annotator_1to1_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(annotator_1to1_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.annotator_1to1_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(annotator_1to1_sptr self) -> std::string"""
        return _blocks_swig0.annotator_1to1_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(annotator_1to1_sptr self, std::string name)"""
        return _blocks_swig0.annotator_1to1_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(annotator_1to1_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.annotator_1to1_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(annotator_1to1_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.annotator_1to1_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(annotator_1to1_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.annotator_1to1_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(annotator_1to1_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.annotator_1to1_sptr_message_subscribers(self, which_port)

annotator_1to1_sptr_swigregister = _blocks_swig0.annotator_1to1_sptr_swigregister
annotator_1to1_sptr_swigregister(annotator_1to1_sptr)


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

class annotator_alltoall_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::annotator_alltoall)> 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::annotator_alltoall)> self) -> annotator_alltoall_sptr
        __init__(boost::shared_ptr<(gr::blocks::annotator_alltoall)> self, annotator_alltoall p) -> annotator_alltoall_sptr
        """
        this = _blocks_swig0.new_annotator_alltoall_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(annotator_alltoall_sptr self) -> annotator_alltoall"""
        return _blocks_swig0.annotator_alltoall_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_annotator_alltoall_sptr
    __del__ = lambda self: None

    def make(self, when, sizeof_stream_item):
        """make(annotator_alltoall_sptr self, int when, size_t sizeof_stream_item) -> annotator_alltoall_sptr"""
        return _blocks_swig0.annotator_alltoall_sptr_make(self, when, sizeof_stream_item)


    def data(self):
        """data(annotator_alltoall_sptr self) -> tags_vector_t"""
        return _blocks_swig0.annotator_alltoall_sptr_data(self)


    def history(self):
        """history(annotator_alltoall_sptr self) -> unsigned int"""
        return _blocks_swig0.annotator_alltoall_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(annotator_alltoall_sptr self, int which, int delay)
        declare_sample_delay(annotator_alltoall_sptr self, unsigned int delay)
        """
        return _blocks_swig0.annotator_alltoall_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(annotator_alltoall_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.annotator_alltoall_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(annotator_alltoall_sptr self) -> int"""
        return _blocks_swig0.annotator_alltoall_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(annotator_alltoall_sptr self) -> double"""
        return _blocks_swig0.annotator_alltoall_sptr_relative_rate(self)


    def start(self):
        """start(annotator_alltoall_sptr self) -> bool"""
        return _blocks_swig0.annotator_alltoall_sptr_start(self)


    def stop(self):
        """stop(annotator_alltoall_sptr self) -> bool"""
        return _blocks_swig0.annotator_alltoall_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(annotator_alltoall_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.annotator_alltoall_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(annotator_alltoall_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.annotator_alltoall_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(annotator_alltoall_sptr self) -> int"""
        return _blocks_swig0.annotator_alltoall_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(annotator_alltoall_sptr self, int m)"""
        return _blocks_swig0.annotator_alltoall_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(annotator_alltoall_sptr self)"""
        return _blocks_swig0.annotator_alltoall_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(annotator_alltoall_sptr self) -> bool"""
        return _blocks_swig0.annotator_alltoall_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(annotator_alltoall_sptr self, int m)"""
        return _blocks_swig0.annotator_alltoall_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(annotator_alltoall_sptr self) -> int"""
        return _blocks_swig0.annotator_alltoall_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(annotator_alltoall_sptr self, int i) -> long"""
        return _blocks_swig0.annotator_alltoall_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(annotator_alltoall_sptr self, long max_output_buffer)
        set_max_output_buffer(annotator_alltoall_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.annotator_alltoall_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(annotator_alltoall_sptr self, int i) -> long"""
        return _blocks_swig0.annotator_alltoall_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(annotator_alltoall_sptr self, long min_output_buffer)
        set_min_output_buffer(annotator_alltoall_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.annotator_alltoall_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(annotator_alltoall_sptr self, int which) -> float
        pc_input_buffers_full(annotator_alltoall_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_alltoall_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(annotator_alltoall_sptr self, int which) -> float
        pc_input_buffers_full_avg(annotator_alltoall_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_alltoall_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(annotator_alltoall_sptr self, int which) -> float
        pc_input_buffers_full_var(annotator_alltoall_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_alltoall_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(annotator_alltoall_sptr self, int which) -> float
        pc_output_buffers_full(annotator_alltoall_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_alltoall_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(annotator_alltoall_sptr self, int which) -> float
        pc_output_buffers_full_avg(annotator_alltoall_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_alltoall_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(annotator_alltoall_sptr self, int which) -> float
        pc_output_buffers_full_var(annotator_alltoall_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_alltoall_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(annotator_alltoall_sptr self) -> float"""
        return _blocks_swig0.annotator_alltoall_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(annotator_alltoall_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.annotator_alltoall_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(annotator_alltoall_sptr self)"""
        return _blocks_swig0.annotator_alltoall_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(annotator_alltoall_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.annotator_alltoall_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(annotator_alltoall_sptr self) -> int"""
        return _blocks_swig0.annotator_alltoall_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(annotator_alltoall_sptr self) -> int"""
        return _blocks_swig0.annotator_alltoall_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(annotator_alltoall_sptr self, int priority) -> int"""
        return _blocks_swig0.annotator_alltoall_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(annotator_alltoall_sptr self) -> std::string"""
        return _blocks_swig0.annotator_alltoall_sptr_name(self)


    def symbol_name(self):
        """symbol_name(annotator_alltoall_sptr self) -> std::string"""
        return _blocks_swig0.annotator_alltoall_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(annotator_alltoall_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.annotator_alltoall_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(annotator_alltoall_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.annotator_alltoall_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(annotator_alltoall_sptr self) -> long"""
        return _blocks_swig0.annotator_alltoall_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(annotator_alltoall_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.annotator_alltoall_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(annotator_alltoall_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.annotator_alltoall_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(annotator_alltoall_sptr self) -> std::string"""
        return _blocks_swig0.annotator_alltoall_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(annotator_alltoall_sptr self, std::string name)"""
        return _blocks_swig0.annotator_alltoall_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(annotator_alltoall_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.annotator_alltoall_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(annotator_alltoall_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.annotator_alltoall_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(annotator_alltoall_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.annotator_alltoall_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(annotator_alltoall_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.annotator_alltoall_sptr_message_subscribers(self, which_port)

annotator_alltoall_sptr_swigregister = _blocks_swig0.annotator_alltoall_sptr_swigregister
annotator_alltoall_sptr_swigregister(annotator_alltoall_sptr)


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

class annotator_raw_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::annotator_raw)> 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::annotator_raw)> self) -> annotator_raw_sptr
        __init__(boost::shared_ptr<(gr::blocks::annotator_raw)> self, annotator_raw p) -> annotator_raw_sptr
        """
        this = _blocks_swig0.new_annotator_raw_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(annotator_raw_sptr self) -> annotator_raw"""
        return _blocks_swig0.annotator_raw_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_annotator_raw_sptr
    __del__ = lambda self: None

    def make(self, sizeof_stream_item):
        """make(annotator_raw_sptr self, size_t sizeof_stream_item) -> annotator_raw_sptr"""
        return _blocks_swig0.annotator_raw_sptr_make(self, sizeof_stream_item)


    def add_tag(self, offset, key, val):
        """add_tag(annotator_raw_sptr self, uint64_t offset, swig_int_ptr key, swig_int_ptr val)"""
        return _blocks_swig0.annotator_raw_sptr_add_tag(self, offset, key, val)


    def history(self):
        """history(annotator_raw_sptr self) -> unsigned int"""
        return _blocks_swig0.annotator_raw_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(annotator_raw_sptr self, int which, int delay)
        declare_sample_delay(annotator_raw_sptr self, unsigned int delay)
        """
        return _blocks_swig0.annotator_raw_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(annotator_raw_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.annotator_raw_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(annotator_raw_sptr self) -> int"""
        return _blocks_swig0.annotator_raw_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(annotator_raw_sptr self) -> double"""
        return _blocks_swig0.annotator_raw_sptr_relative_rate(self)


    def start(self):
        """start(annotator_raw_sptr self) -> bool"""
        return _blocks_swig0.annotator_raw_sptr_start(self)


    def stop(self):
        """stop(annotator_raw_sptr self) -> bool"""
        return _blocks_swig0.annotator_raw_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(annotator_raw_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.annotator_raw_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(annotator_raw_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.annotator_raw_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(annotator_raw_sptr self) -> int"""
        return _blocks_swig0.annotator_raw_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(annotator_raw_sptr self, int m)"""
        return _blocks_swig0.annotator_raw_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(annotator_raw_sptr self)"""
        return _blocks_swig0.annotator_raw_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(annotator_raw_sptr self) -> bool"""
        return _blocks_swig0.annotator_raw_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(annotator_raw_sptr self, int m)"""
        return _blocks_swig0.annotator_raw_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(annotator_raw_sptr self) -> int"""
        return _blocks_swig0.annotator_raw_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(annotator_raw_sptr self, int i) -> long"""
        return _blocks_swig0.annotator_raw_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(annotator_raw_sptr self, long max_output_buffer)
        set_max_output_buffer(annotator_raw_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.annotator_raw_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(annotator_raw_sptr self, int i) -> long"""
        return _blocks_swig0.annotator_raw_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(annotator_raw_sptr self, long min_output_buffer)
        set_min_output_buffer(annotator_raw_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.annotator_raw_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(annotator_raw_sptr self, int which) -> float
        pc_input_buffers_full(annotator_raw_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_raw_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(annotator_raw_sptr self, int which) -> float
        pc_input_buffers_full_avg(annotator_raw_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_raw_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(annotator_raw_sptr self, int which) -> float
        pc_input_buffers_full_var(annotator_raw_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_raw_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(annotator_raw_sptr self, int which) -> float
        pc_output_buffers_full(annotator_raw_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_raw_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(annotator_raw_sptr self, int which) -> float
        pc_output_buffers_full_avg(annotator_raw_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_raw_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(annotator_raw_sptr self, int which) -> float
        pc_output_buffers_full_var(annotator_raw_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.annotator_raw_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(annotator_raw_sptr self) -> float"""
        return _blocks_swig0.annotator_raw_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(annotator_raw_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.annotator_raw_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(annotator_raw_sptr self)"""
        return _blocks_swig0.annotator_raw_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(annotator_raw_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.annotator_raw_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(annotator_raw_sptr self) -> int"""
        return _blocks_swig0.annotator_raw_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(annotator_raw_sptr self) -> int"""
        return _blocks_swig0.annotator_raw_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(annotator_raw_sptr self, int priority) -> int"""
        return _blocks_swig0.annotator_raw_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(annotator_raw_sptr self) -> std::string"""
        return _blocks_swig0.annotator_raw_sptr_name(self)


    def symbol_name(self):
        """symbol_name(annotator_raw_sptr self) -> std::string"""
        return _blocks_swig0.annotator_raw_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(annotator_raw_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.annotator_raw_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(annotator_raw_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.annotator_raw_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(annotator_raw_sptr self) -> long"""
        return _blocks_swig0.annotator_raw_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(annotator_raw_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.annotator_raw_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(annotator_raw_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.annotator_raw_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(annotator_raw_sptr self) -> std::string"""
        return _blocks_swig0.annotator_raw_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(annotator_raw_sptr self, std::string name)"""
        return _blocks_swig0.annotator_raw_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(annotator_raw_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.annotator_raw_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(annotator_raw_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.annotator_raw_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(annotator_raw_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.annotator_raw_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(annotator_raw_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.annotator_raw_sptr_message_subscribers(self, which_port)

annotator_raw_sptr_swigregister = _blocks_swig0.annotator_raw_sptr_swigregister
annotator_raw_sptr_swigregister(annotator_raw_sptr)


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

class copy_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::copy)> 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::copy)> self) -> copy_sptr
        __init__(boost::shared_ptr<(gr::blocks::copy)> self, copy p) -> copy_sptr
        """
        this = _blocks_swig0.new_copy_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(copy_sptr self) -> copy"""
        return _blocks_swig0.copy_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_copy_sptr
    __del__ = lambda self: None

    def make(self, itemsize):
        """make(copy_sptr self, size_t itemsize) -> copy_sptr"""
        return _blocks_swig0.copy_sptr_make(self, itemsize)


    def set_enabled(self, enable):
        """set_enabled(copy_sptr self, bool enable)"""
        return _blocks_swig0.copy_sptr_set_enabled(self, enable)


    def enabled(self):
        """enabled(copy_sptr self) -> bool"""
        return _blocks_swig0.copy_sptr_enabled(self)


    def history(self):
        """history(copy_sptr self) -> unsigned int"""
        return _blocks_swig0.copy_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(copy_sptr self, int which, int delay)
        declare_sample_delay(copy_sptr self, unsigned int delay)
        """
        return _blocks_swig0.copy_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(copy_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.copy_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(copy_sptr self) -> int"""
        return _blocks_swig0.copy_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(copy_sptr self) -> double"""
        return _blocks_swig0.copy_sptr_relative_rate(self)


    def start(self):
        """start(copy_sptr self) -> bool"""
        return _blocks_swig0.copy_sptr_start(self)


    def stop(self):
        """stop(copy_sptr self) -> bool"""
        return _blocks_swig0.copy_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(copy_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.copy_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(copy_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.copy_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(copy_sptr self) -> int"""
        return _blocks_swig0.copy_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(copy_sptr self, int m)"""
        return _blocks_swig0.copy_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(copy_sptr self)"""
        return _blocks_swig0.copy_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(copy_sptr self) -> bool"""
        return _blocks_swig0.copy_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(copy_sptr self, int m)"""
        return _blocks_swig0.copy_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(copy_sptr self) -> int"""
        return _blocks_swig0.copy_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(copy_sptr self, int i) -> long"""
        return _blocks_swig0.copy_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(copy_sptr self, long max_output_buffer)
        set_max_output_buffer(copy_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.copy_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(copy_sptr self, int i) -> long"""
        return _blocks_swig0.copy_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(copy_sptr self, long min_output_buffer)
        set_min_output_buffer(copy_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.copy_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(copy_sptr self, int which) -> float
        pc_input_buffers_full(copy_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.copy_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(copy_sptr self, int which) -> float
        pc_input_buffers_full_avg(copy_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.copy_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(copy_sptr self, int which) -> float
        pc_input_buffers_full_var(copy_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.copy_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(copy_sptr self, int which) -> float
        pc_output_buffers_full(copy_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.copy_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(copy_sptr self, int which) -> float
        pc_output_buffers_full_avg(copy_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.copy_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(copy_sptr self, int which) -> float
        pc_output_buffers_full_var(copy_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.copy_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(copy_sptr self) -> float"""
        return _blocks_swig0.copy_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(copy_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.copy_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(copy_sptr self)"""
        return _blocks_swig0.copy_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(copy_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.copy_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(copy_sptr self) -> int"""
        return _blocks_swig0.copy_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(copy_sptr self) -> int"""
        return _blocks_swig0.copy_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(copy_sptr self, int priority) -> int"""
        return _blocks_swig0.copy_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(copy_sptr self) -> std::string"""
        return _blocks_swig0.copy_sptr_name(self)


    def symbol_name(self):
        """symbol_name(copy_sptr self) -> std::string"""
        return _blocks_swig0.copy_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(copy_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.copy_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(copy_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.copy_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(copy_sptr self) -> long"""
        return _blocks_swig0.copy_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(copy_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.copy_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(copy_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.copy_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(copy_sptr self) -> std::string"""
        return _blocks_swig0.copy_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(copy_sptr self, std::string name)"""
        return _blocks_swig0.copy_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(copy_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.copy_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(copy_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.copy_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(copy_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.copy_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(copy_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.copy_sptr_message_subscribers(self, which_port)

copy_sptr_swigregister = _blocks_swig0.copy_sptr_swigregister
copy_sptr_swigregister(copy_sptr)


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

class delay_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::delay)> 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::delay)> self) -> delay_sptr
        __init__(boost::shared_ptr<(gr::blocks::delay)> self, delay p) -> delay_sptr
        """
        this = _blocks_swig0.new_delay_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(delay_sptr self) -> delay"""
        return _blocks_swig0.delay_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_delay_sptr
    __del__ = lambda self: None

    def make(self, itemsize, delay):
        """make(delay_sptr self, size_t itemsize, int delay) -> delay_sptr"""
        return _blocks_swig0.delay_sptr_make(self, itemsize, delay)


    def dly(self):
        """dly(delay_sptr self) -> int"""
        return _blocks_swig0.delay_sptr_dly(self)


    def set_dly(self, d):
        """set_dly(delay_sptr self, int d)"""
        return _blocks_swig0.delay_sptr_set_dly(self, d)


    def history(self):
        """history(delay_sptr self) -> unsigned int"""
        return _blocks_swig0.delay_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(delay_sptr self, int which, int delay)
        declare_sample_delay(delay_sptr self, unsigned int delay)
        """
        return _blocks_swig0.delay_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(delay_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.delay_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(delay_sptr self) -> int"""
        return _blocks_swig0.delay_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(delay_sptr self) -> double"""
        return _blocks_swig0.delay_sptr_relative_rate(self)


    def start(self):
        """start(delay_sptr self) -> bool"""
        return _blocks_swig0.delay_sptr_start(self)


    def stop(self):
        """stop(delay_sptr self) -> bool"""
        return _blocks_swig0.delay_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(delay_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.delay_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(delay_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.delay_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(delay_sptr self) -> int"""
        return _blocks_swig0.delay_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(delay_sptr self, int m)"""
        return _blocks_swig0.delay_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(delay_sptr self)"""
        return _blocks_swig0.delay_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(delay_sptr self) -> bool"""
        return _blocks_swig0.delay_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(delay_sptr self, int m)"""
        return _blocks_swig0.delay_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(delay_sptr self) -> int"""
        return _blocks_swig0.delay_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(delay_sptr self, int i) -> long"""
        return _blocks_swig0.delay_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(delay_sptr self, long max_output_buffer)
        set_max_output_buffer(delay_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.delay_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(delay_sptr self, int i) -> long"""
        return _blocks_swig0.delay_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(delay_sptr self, long min_output_buffer)
        set_min_output_buffer(delay_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.delay_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(delay_sptr self, int which) -> float
        pc_input_buffers_full(delay_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.delay_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(delay_sptr self, int which) -> float
        pc_input_buffers_full_avg(delay_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.delay_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(delay_sptr self, int which) -> float
        pc_input_buffers_full_var(delay_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.delay_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(delay_sptr self, int which) -> float
        pc_output_buffers_full(delay_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.delay_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(delay_sptr self, int which) -> float
        pc_output_buffers_full_avg(delay_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.delay_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(delay_sptr self, int which) -> float
        pc_output_buffers_full_var(delay_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.delay_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(delay_sptr self) -> float"""
        return _blocks_swig0.delay_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(delay_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.delay_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(delay_sptr self)"""
        return _blocks_swig0.delay_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(delay_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.delay_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(delay_sptr self) -> int"""
        return _blocks_swig0.delay_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(delay_sptr self) -> int"""
        return _blocks_swig0.delay_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(delay_sptr self, int priority) -> int"""
        return _blocks_swig0.delay_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(delay_sptr self) -> std::string"""
        return _blocks_swig0.delay_sptr_name(self)


    def symbol_name(self):
        """symbol_name(delay_sptr self) -> std::string"""
        return _blocks_swig0.delay_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(delay_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.delay_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(delay_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.delay_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(delay_sptr self) -> long"""
        return _blocks_swig0.delay_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(delay_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.delay_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(delay_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.delay_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(delay_sptr self) -> std::string"""
        return _blocks_swig0.delay_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(delay_sptr self, std::string name)"""
        return _blocks_swig0.delay_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(delay_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.delay_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(delay_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.delay_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(delay_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.delay_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(delay_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.delay_sptr_message_subscribers(self, which_port)

delay_sptr_swigregister = _blocks_swig0.delay_sptr_swigregister
delay_sptr_swigregister(delay_sptr)


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

class endian_swap_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::endian_swap)> 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::endian_swap)> self) -> endian_swap_sptr
        __init__(boost::shared_ptr<(gr::blocks::endian_swap)> self, endian_swap p) -> endian_swap_sptr
        """
        this = _blocks_swig0.new_endian_swap_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(endian_swap_sptr self) -> endian_swap"""
        return _blocks_swig0.endian_swap_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_endian_swap_sptr
    __del__ = lambda self: None

    def make(self, item_size_bytes=1):
        """make(endian_swap_sptr self, size_t item_size_bytes=1) -> endian_swap_sptr"""
        return _blocks_swig0.endian_swap_sptr_make(self, item_size_bytes)


    def history(self):
        """history(endian_swap_sptr self) -> unsigned int"""
        return _blocks_swig0.endian_swap_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(endian_swap_sptr self, int which, int delay)
        declare_sample_delay(endian_swap_sptr self, unsigned int delay)
        """
        return _blocks_swig0.endian_swap_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(endian_swap_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.endian_swap_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(endian_swap_sptr self) -> int"""
        return _blocks_swig0.endian_swap_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(endian_swap_sptr self) -> double"""
        return _blocks_swig0.endian_swap_sptr_relative_rate(self)


    def start(self):
        """start(endian_swap_sptr self) -> bool"""
        return _blocks_swig0.endian_swap_sptr_start(self)


    def stop(self):
        """stop(endian_swap_sptr self) -> bool"""
        return _blocks_swig0.endian_swap_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(endian_swap_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.endian_swap_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(endian_swap_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.endian_swap_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(endian_swap_sptr self) -> int"""
        return _blocks_swig0.endian_swap_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(endian_swap_sptr self, int m)"""
        return _blocks_swig0.endian_swap_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(endian_swap_sptr self)"""
        return _blocks_swig0.endian_swap_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(endian_swap_sptr self) -> bool"""
        return _blocks_swig0.endian_swap_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(endian_swap_sptr self, int m)"""
        return _blocks_swig0.endian_swap_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(endian_swap_sptr self) -> int"""
        return _blocks_swig0.endian_swap_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(endian_swap_sptr self, int i) -> long"""
        return _blocks_swig0.endian_swap_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(endian_swap_sptr self, long max_output_buffer)
        set_max_output_buffer(endian_swap_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.endian_swap_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(endian_swap_sptr self, int i) -> long"""
        return _blocks_swig0.endian_swap_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(endian_swap_sptr self, long min_output_buffer)
        set_min_output_buffer(endian_swap_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.endian_swap_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(endian_swap_sptr self, int which) -> float
        pc_input_buffers_full(endian_swap_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.endian_swap_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(endian_swap_sptr self, int which) -> float
        pc_input_buffers_full_avg(endian_swap_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.endian_swap_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(endian_swap_sptr self, int which) -> float
        pc_input_buffers_full_var(endian_swap_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.endian_swap_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(endian_swap_sptr self, int which) -> float
        pc_output_buffers_full(endian_swap_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.endian_swap_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(endian_swap_sptr self, int which) -> float
        pc_output_buffers_full_avg(endian_swap_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.endian_swap_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(endian_swap_sptr self, int which) -> float
        pc_output_buffers_full_var(endian_swap_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.endian_swap_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(endian_swap_sptr self) -> float"""
        return _blocks_swig0.endian_swap_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(endian_swap_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.endian_swap_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(endian_swap_sptr self)"""
        return _blocks_swig0.endian_swap_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(endian_swap_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.endian_swap_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(endian_swap_sptr self) -> int"""
        return _blocks_swig0.endian_swap_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(endian_swap_sptr self) -> int"""
        return _blocks_swig0.endian_swap_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(endian_swap_sptr self, int priority) -> int"""
        return _blocks_swig0.endian_swap_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(endian_swap_sptr self) -> std::string"""
        return _blocks_swig0.endian_swap_sptr_name(self)


    def symbol_name(self):
        """symbol_name(endian_swap_sptr self) -> std::string"""
        return _blocks_swig0.endian_swap_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(endian_swap_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.endian_swap_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(endian_swap_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.endian_swap_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(endian_swap_sptr self) -> long"""
        return _blocks_swig0.endian_swap_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(endian_swap_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.endian_swap_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(endian_swap_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.endian_swap_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(endian_swap_sptr self) -> std::string"""
        return _blocks_swig0.endian_swap_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(endian_swap_sptr self, std::string name)"""
        return _blocks_swig0.endian_swap_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(endian_swap_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.endian_swap_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(endian_swap_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.endian_swap_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(endian_swap_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.endian_swap_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(endian_swap_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.endian_swap_sptr_message_subscribers(self, which_port)

endian_swap_sptr_swigregister = _blocks_swig0.endian_swap_sptr_swigregister
endian_swap_sptr_swigregister(endian_swap_sptr)


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

class file_descriptor_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::file_descriptor_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::file_descriptor_sink)> self) -> file_descriptor_sink_sptr
        __init__(boost::shared_ptr<(gr::blocks::file_descriptor_sink)> self, file_descriptor_sink p) -> file_descriptor_sink_sptr
        """
        this = _blocks_swig0.new_file_descriptor_sink_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(file_descriptor_sink_sptr self) -> file_descriptor_sink"""
        return _blocks_swig0.file_descriptor_sink_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_file_descriptor_sink_sptr
    __del__ = lambda self: None

    def make(self, itemsize, fd):
        """make(file_descriptor_sink_sptr self, size_t itemsize, int fd) -> file_descriptor_sink_sptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_make(self, itemsize, fd)


    def history(self):
        """history(file_descriptor_sink_sptr self) -> unsigned int"""
        return _blocks_swig0.file_descriptor_sink_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(file_descriptor_sink_sptr self, int which, int delay)
        declare_sample_delay(file_descriptor_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig0.file_descriptor_sink_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(file_descriptor_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.file_descriptor_sink_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(file_descriptor_sink_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_sink_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(file_descriptor_sink_sptr self) -> double"""
        return _blocks_swig0.file_descriptor_sink_sptr_relative_rate(self)


    def start(self):
        """start(file_descriptor_sink_sptr self) -> bool"""
        return _blocks_swig0.file_descriptor_sink_sptr_start(self)


    def stop(self):
        """stop(file_descriptor_sink_sptr self) -> bool"""
        return _blocks_swig0.file_descriptor_sink_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(file_descriptor_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.file_descriptor_sink_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(file_descriptor_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.file_descriptor_sink_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(file_descriptor_sink_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_sink_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(file_descriptor_sink_sptr self, int m)"""
        return _blocks_swig0.file_descriptor_sink_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(file_descriptor_sink_sptr self)"""
        return _blocks_swig0.file_descriptor_sink_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(file_descriptor_sink_sptr self) -> bool"""
        return _blocks_swig0.file_descriptor_sink_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(file_descriptor_sink_sptr self, int m)"""
        return _blocks_swig0.file_descriptor_sink_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(file_descriptor_sink_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_sink_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(file_descriptor_sink_sptr self, int i) -> long"""
        return _blocks_swig0.file_descriptor_sink_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(file_descriptor_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(file_descriptor_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.file_descriptor_sink_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(file_descriptor_sink_sptr self, int i) -> long"""
        return _blocks_swig0.file_descriptor_sink_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(file_descriptor_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(file_descriptor_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.file_descriptor_sink_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(file_descriptor_sink_sptr self, int which) -> float
        pc_input_buffers_full(file_descriptor_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_sink_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(file_descriptor_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(file_descriptor_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_sink_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(file_descriptor_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(file_descriptor_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_sink_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(file_descriptor_sink_sptr self, int which) -> float
        pc_output_buffers_full(file_descriptor_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_sink_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(file_descriptor_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(file_descriptor_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_sink_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(file_descriptor_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(file_descriptor_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_sink_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(file_descriptor_sink_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_sink_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(file_descriptor_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.file_descriptor_sink_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(file_descriptor_sink_sptr self)"""
        return _blocks_swig0.file_descriptor_sink_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(file_descriptor_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.file_descriptor_sink_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(file_descriptor_sink_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_sink_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(file_descriptor_sink_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_sink_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(file_descriptor_sink_sptr self, int priority) -> int"""
        return _blocks_swig0.file_descriptor_sink_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(file_descriptor_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_sink_sptr_name(self)


    def symbol_name(self):
        """symbol_name(file_descriptor_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_sink_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(file_descriptor_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(file_descriptor_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(file_descriptor_sink_sptr self) -> long"""
        return _blocks_swig0.file_descriptor_sink_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(file_descriptor_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(file_descriptor_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.file_descriptor_sink_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(file_descriptor_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_sink_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(file_descriptor_sink_sptr self, std::string name)"""
        return _blocks_swig0.file_descriptor_sink_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(file_descriptor_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.file_descriptor_sink_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(file_descriptor_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(file_descriptor_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(file_descriptor_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.file_descriptor_sink_sptr_message_subscribers(self, which_port)

file_descriptor_sink_sptr_swigregister = _blocks_swig0.file_descriptor_sink_sptr_swigregister
file_descriptor_sink_sptr_swigregister(file_descriptor_sink_sptr)


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

class file_descriptor_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::file_descriptor_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::file_descriptor_source)> self) -> file_descriptor_source_sptr
        __init__(boost::shared_ptr<(gr::blocks::file_descriptor_source)> self, file_descriptor_source p) -> file_descriptor_source_sptr
        """
        this = _blocks_swig0.new_file_descriptor_source_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(file_descriptor_source_sptr self) -> file_descriptor_source"""
        return _blocks_swig0.file_descriptor_source_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_file_descriptor_source_sptr
    __del__ = lambda self: None

    def make(self, itemsize, fd, repeat=False):
        """make(file_descriptor_source_sptr self, size_t itemsize, int fd, bool repeat=False) -> file_descriptor_source_sptr"""
        return _blocks_swig0.file_descriptor_source_sptr_make(self, itemsize, fd, repeat)


    def history(self):
        """history(file_descriptor_source_sptr self) -> unsigned int"""
        return _blocks_swig0.file_descriptor_source_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(file_descriptor_source_sptr self, int which, int delay)
        declare_sample_delay(file_descriptor_source_sptr self, unsigned int delay)
        """
        return _blocks_swig0.file_descriptor_source_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(file_descriptor_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.file_descriptor_source_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(file_descriptor_source_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_source_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(file_descriptor_source_sptr self) -> double"""
        return _blocks_swig0.file_descriptor_source_sptr_relative_rate(self)


    def start(self):
        """start(file_descriptor_source_sptr self) -> bool"""
        return _blocks_swig0.file_descriptor_source_sptr_start(self)


    def stop(self):
        """stop(file_descriptor_source_sptr self) -> bool"""
        return _blocks_swig0.file_descriptor_source_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(file_descriptor_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.file_descriptor_source_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(file_descriptor_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.file_descriptor_source_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(file_descriptor_source_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_source_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(file_descriptor_source_sptr self, int m)"""
        return _blocks_swig0.file_descriptor_source_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(file_descriptor_source_sptr self)"""
        return _blocks_swig0.file_descriptor_source_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(file_descriptor_source_sptr self) -> bool"""
        return _blocks_swig0.file_descriptor_source_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(file_descriptor_source_sptr self, int m)"""
        return _blocks_swig0.file_descriptor_source_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(file_descriptor_source_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_source_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(file_descriptor_source_sptr self, int i) -> long"""
        return _blocks_swig0.file_descriptor_source_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(file_descriptor_source_sptr self, long max_output_buffer)
        set_max_output_buffer(file_descriptor_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.file_descriptor_source_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(file_descriptor_source_sptr self, int i) -> long"""
        return _blocks_swig0.file_descriptor_source_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(file_descriptor_source_sptr self, long min_output_buffer)
        set_min_output_buffer(file_descriptor_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.file_descriptor_source_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(file_descriptor_source_sptr self, int which) -> float
        pc_input_buffers_full(file_descriptor_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_source_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(file_descriptor_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(file_descriptor_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_source_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(file_descriptor_source_sptr self, int which) -> float
        pc_input_buffers_full_var(file_descriptor_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_source_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(file_descriptor_source_sptr self, int which) -> float
        pc_output_buffers_full(file_descriptor_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_source_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(file_descriptor_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(file_descriptor_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_source_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(file_descriptor_source_sptr self, int which) -> float
        pc_output_buffers_full_var(file_descriptor_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_descriptor_source_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(file_descriptor_source_sptr self) -> float"""
        return _blocks_swig0.file_descriptor_source_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(file_descriptor_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.file_descriptor_source_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(file_descriptor_source_sptr self)"""
        return _blocks_swig0.file_descriptor_source_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(file_descriptor_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.file_descriptor_source_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(file_descriptor_source_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_source_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(file_descriptor_source_sptr self) -> int"""
        return _blocks_swig0.file_descriptor_source_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(file_descriptor_source_sptr self, int priority) -> int"""
        return _blocks_swig0.file_descriptor_source_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(file_descriptor_source_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_source_sptr_name(self)


    def symbol_name(self):
        """symbol_name(file_descriptor_source_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_source_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(file_descriptor_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_descriptor_source_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(file_descriptor_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_descriptor_source_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(file_descriptor_source_sptr self) -> long"""
        return _blocks_swig0.file_descriptor_source_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(file_descriptor_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.file_descriptor_source_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(file_descriptor_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.file_descriptor_source_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(file_descriptor_source_sptr self) -> std::string"""
        return _blocks_swig0.file_descriptor_source_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(file_descriptor_source_sptr self, std::string name)"""
        return _blocks_swig0.file_descriptor_source_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(file_descriptor_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.file_descriptor_source_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(file_descriptor_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_descriptor_source_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(file_descriptor_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_descriptor_source_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(file_descriptor_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.file_descriptor_source_sptr_message_subscribers(self, which_port)

file_descriptor_source_sptr_swigregister = _blocks_swig0.file_descriptor_source_sptr_swigregister
file_descriptor_source_sptr_swigregister(file_descriptor_source_sptr)


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

class file_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::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::file_sink)> self) -> file_sink_sptr
        __init__(boost::shared_ptr<(gr::blocks::file_sink)> self, file_sink p) -> file_sink_sptr
        """
        this = _blocks_swig0.new_file_sink_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(file_sink_sptr self) -> file_sink"""
        return _blocks_swig0.file_sink_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_file_sink_sptr
    __del__ = lambda self: None

    def make(self, itemsize, filename, append=False):
        """make(file_sink_sptr self, size_t itemsize, char const * filename, bool append=False) -> file_sink_sptr"""
        return _blocks_swig0.file_sink_sptr_make(self, itemsize, filename, append)


    def history(self):
        """history(file_sink_sptr self) -> unsigned int"""
        return _blocks_swig0.file_sink_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(file_sink_sptr self, int which, int delay)
        declare_sample_delay(file_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig0.file_sink_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(file_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.file_sink_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(file_sink_sptr self) -> int"""
        return _blocks_swig0.file_sink_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(file_sink_sptr self) -> double"""
        return _blocks_swig0.file_sink_sptr_relative_rate(self)


    def start(self):
        """start(file_sink_sptr self) -> bool"""
        return _blocks_swig0.file_sink_sptr_start(self)


    def stop(self):
        """stop(file_sink_sptr self) -> bool"""
        return _blocks_swig0.file_sink_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(file_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.file_sink_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(file_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.file_sink_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(file_sink_sptr self) -> int"""
        return _blocks_swig0.file_sink_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(file_sink_sptr self, int m)"""
        return _blocks_swig0.file_sink_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(file_sink_sptr self)"""
        return _blocks_swig0.file_sink_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(file_sink_sptr self) -> bool"""
        return _blocks_swig0.file_sink_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(file_sink_sptr self, int m)"""
        return _blocks_swig0.file_sink_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(file_sink_sptr self) -> int"""
        return _blocks_swig0.file_sink_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(file_sink_sptr self, int i) -> long"""
        return _blocks_swig0.file_sink_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(file_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(file_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.file_sink_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(file_sink_sptr self, int i) -> long"""
        return _blocks_swig0.file_sink_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(file_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(file_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.file_sink_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(file_sink_sptr self, int which) -> float
        pc_input_buffers_full(file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_sink_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(file_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_sink_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(file_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_sink_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(file_sink_sptr self, int which) -> float
        pc_output_buffers_full(file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_sink_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(file_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_sink_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(file_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(file_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_sink_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(file_sink_sptr self) -> float"""
        return _blocks_swig0.file_sink_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(file_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.file_sink_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(file_sink_sptr self)"""
        return _blocks_swig0.file_sink_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(file_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.file_sink_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(file_sink_sptr self) -> int"""
        return _blocks_swig0.file_sink_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(file_sink_sptr self) -> int"""
        return _blocks_swig0.file_sink_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(file_sink_sptr self, int priority) -> int"""
        return _blocks_swig0.file_sink_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(file_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_sink_sptr_name(self)


    def symbol_name(self):
        """symbol_name(file_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_sink_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(file_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_sink_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(file_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_sink_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(file_sink_sptr self) -> long"""
        return _blocks_swig0.file_sink_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(file_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.file_sink_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(file_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.file_sink_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(file_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_sink_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(file_sink_sptr self, std::string name)"""
        return _blocks_swig0.file_sink_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(file_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.file_sink_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(file_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_sink_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(file_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_sink_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(file_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.file_sink_sptr_message_subscribers(self, which_port)


    def open(self, filename):
        """open(file_sink_sptr self, char const * filename) -> bool"""
        return _blocks_swig0.file_sink_sptr_open(self, filename)


    def close(self):
        """close(file_sink_sptr self)"""
        return _blocks_swig0.file_sink_sptr_close(self)


    def do_update(self):
        """do_update(file_sink_sptr self)"""
        return _blocks_swig0.file_sink_sptr_do_update(self)


    def set_unbuffered(self, unbuffered):
        """set_unbuffered(file_sink_sptr self, bool unbuffered)"""
        return _blocks_swig0.file_sink_sptr_set_unbuffered(self, unbuffered)

file_sink_sptr_swigregister = _blocks_swig0.file_sink_sptr_swigregister
file_sink_sptr_swigregister(file_sink_sptr)


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

class file_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::file_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::file_source)> self) -> file_source_sptr
        __init__(boost::shared_ptr<(gr::blocks::file_source)> self, file_source p) -> file_source_sptr
        """
        this = _blocks_swig0.new_file_source_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(file_source_sptr self) -> file_source"""
        return _blocks_swig0.file_source_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_file_source_sptr
    __del__ = lambda self: None

    def make(self, itemsize, filename, repeat=False):
        """make(file_source_sptr self, size_t itemsize, char const * filename, bool repeat=False) -> file_source_sptr"""
        return _blocks_swig0.file_source_sptr_make(self, itemsize, filename, repeat)


    def seek(self, seek_point, whence):
        """seek(file_source_sptr self, long seek_point, int whence) -> bool"""
        return _blocks_swig0.file_source_sptr_seek(self, seek_point, whence)


    def open(self, filename, repeat):
        """open(file_source_sptr self, char const * filename, bool repeat)"""
        return _blocks_swig0.file_source_sptr_open(self, filename, repeat)


    def close(self):
        """close(file_source_sptr self)"""
        return _blocks_swig0.file_source_sptr_close(self)


    def history(self):
        """history(file_source_sptr self) -> unsigned int"""
        return _blocks_swig0.file_source_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(file_source_sptr self, int which, int delay)
        declare_sample_delay(file_source_sptr self, unsigned int delay)
        """
        return _blocks_swig0.file_source_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(file_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.file_source_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(file_source_sptr self) -> int"""
        return _blocks_swig0.file_source_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(file_source_sptr self) -> double"""
        return _blocks_swig0.file_source_sptr_relative_rate(self)


    def start(self):
        """start(file_source_sptr self) -> bool"""
        return _blocks_swig0.file_source_sptr_start(self)


    def stop(self):
        """stop(file_source_sptr self) -> bool"""
        return _blocks_swig0.file_source_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(file_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.file_source_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(file_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.file_source_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(file_source_sptr self) -> int"""
        return _blocks_swig0.file_source_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(file_source_sptr self, int m)"""
        return _blocks_swig0.file_source_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(file_source_sptr self)"""
        return _blocks_swig0.file_source_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(file_source_sptr self) -> bool"""
        return _blocks_swig0.file_source_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(file_source_sptr self, int m)"""
        return _blocks_swig0.file_source_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(file_source_sptr self) -> int"""
        return _blocks_swig0.file_source_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(file_source_sptr self, int i) -> long"""
        return _blocks_swig0.file_source_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(file_source_sptr self, long max_output_buffer)
        set_max_output_buffer(file_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.file_source_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(file_source_sptr self, int i) -> long"""
        return _blocks_swig0.file_source_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(file_source_sptr self, long min_output_buffer)
        set_min_output_buffer(file_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.file_source_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(file_source_sptr self, int which) -> float
        pc_input_buffers_full(file_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_source_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(file_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(file_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_source_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(file_source_sptr self, int which) -> float
        pc_input_buffers_full_var(file_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_source_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(file_source_sptr self, int which) -> float
        pc_output_buffers_full(file_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_source_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(file_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(file_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_source_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(file_source_sptr self, int which) -> float
        pc_output_buffers_full_var(file_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_source_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(file_source_sptr self) -> float"""
        return _blocks_swig0.file_source_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(file_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.file_source_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(file_source_sptr self)"""
        return _blocks_swig0.file_source_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(file_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.file_source_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(file_source_sptr self) -> int"""
        return _blocks_swig0.file_source_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(file_source_sptr self) -> int"""
        return _blocks_swig0.file_source_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(file_source_sptr self, int priority) -> int"""
        return _blocks_swig0.file_source_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(file_source_sptr self) -> std::string"""
        return _blocks_swig0.file_source_sptr_name(self)


    def symbol_name(self):
        """symbol_name(file_source_sptr self) -> std::string"""
        return _blocks_swig0.file_source_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(file_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_source_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(file_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_source_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(file_source_sptr self) -> long"""
        return _blocks_swig0.file_source_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(file_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.file_source_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(file_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.file_source_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(file_source_sptr self) -> std::string"""
        return _blocks_swig0.file_source_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(file_source_sptr self, std::string name)"""
        return _blocks_swig0.file_source_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(file_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.file_source_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(file_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_source_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(file_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_source_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(file_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.file_source_sptr_message_subscribers(self, which_port)

file_source_sptr_swigregister = _blocks_swig0.file_source_sptr_swigregister
file_source_sptr_swigregister(file_source_sptr)


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

class file_meta_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::file_meta_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::file_meta_sink)> self) -> file_meta_sink_sptr
        __init__(boost::shared_ptr<(gr::blocks::file_meta_sink)> self, file_meta_sink p) -> file_meta_sink_sptr
        """
        this = _blocks_swig0.new_file_meta_sink_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(file_meta_sink_sptr self) -> file_meta_sink"""
        return _blocks_swig0.file_meta_sink_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_file_meta_sink_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(file_meta_sink_sptr self, size_t itemsize, std::string const & filename, double samp_rate=1, double relative_rate=1, gr::blocks::gr_file_types type, bool complex=True, size_t max_segment_size=1000000, std::string const & extra_dict, bool detached_header=False) -> file_meta_sink_sptr"""
        return _blocks_swig0.file_meta_sink_sptr_make(self, *args, **kwargs)


    def open(self, filename):
        """open(file_meta_sink_sptr self, std::string const & filename) -> bool"""
        return _blocks_swig0.file_meta_sink_sptr_open(self, filename)


    def close(self):
        """close(file_meta_sink_sptr self)"""
        return _blocks_swig0.file_meta_sink_sptr_close(self)


    def do_update(self):
        """do_update(file_meta_sink_sptr self)"""
        return _blocks_swig0.file_meta_sink_sptr_do_update(self)


    def set_unbuffered(self, unbuffered):
        """set_unbuffered(file_meta_sink_sptr self, bool unbuffered)"""
        return _blocks_swig0.file_meta_sink_sptr_set_unbuffered(self, unbuffered)


    def history(self):
        """history(file_meta_sink_sptr self) -> unsigned int"""
        return _blocks_swig0.file_meta_sink_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(file_meta_sink_sptr self, int which, int delay)
        declare_sample_delay(file_meta_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig0.file_meta_sink_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(file_meta_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.file_meta_sink_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(file_meta_sink_sptr self) -> int"""
        return _blocks_swig0.file_meta_sink_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(file_meta_sink_sptr self) -> double"""
        return _blocks_swig0.file_meta_sink_sptr_relative_rate(self)


    def start(self):
        """start(file_meta_sink_sptr self) -> bool"""
        return _blocks_swig0.file_meta_sink_sptr_start(self)


    def stop(self):
        """stop(file_meta_sink_sptr self) -> bool"""
        return _blocks_swig0.file_meta_sink_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(file_meta_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.file_meta_sink_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(file_meta_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.file_meta_sink_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(file_meta_sink_sptr self) -> int"""
        return _blocks_swig0.file_meta_sink_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(file_meta_sink_sptr self, int m)"""
        return _blocks_swig0.file_meta_sink_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(file_meta_sink_sptr self)"""
        return _blocks_swig0.file_meta_sink_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(file_meta_sink_sptr self) -> bool"""
        return _blocks_swig0.file_meta_sink_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(file_meta_sink_sptr self, int m)"""
        return _blocks_swig0.file_meta_sink_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(file_meta_sink_sptr self) -> int"""
        return _blocks_swig0.file_meta_sink_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(file_meta_sink_sptr self, int i) -> long"""
        return _blocks_swig0.file_meta_sink_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(file_meta_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(file_meta_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.file_meta_sink_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(file_meta_sink_sptr self, int i) -> long"""
        return _blocks_swig0.file_meta_sink_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(file_meta_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(file_meta_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.file_meta_sink_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(file_meta_sink_sptr self, int which) -> float
        pc_input_buffers_full(file_meta_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_sink_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(file_meta_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(file_meta_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_sink_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(file_meta_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(file_meta_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_sink_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(file_meta_sink_sptr self, int which) -> float
        pc_output_buffers_full(file_meta_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_sink_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(file_meta_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(file_meta_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_sink_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(file_meta_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(file_meta_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_sink_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(file_meta_sink_sptr self) -> float"""
        return _blocks_swig0.file_meta_sink_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(file_meta_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.file_meta_sink_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(file_meta_sink_sptr self)"""
        return _blocks_swig0.file_meta_sink_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(file_meta_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.file_meta_sink_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(file_meta_sink_sptr self) -> int"""
        return _blocks_swig0.file_meta_sink_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(file_meta_sink_sptr self) -> int"""
        return _blocks_swig0.file_meta_sink_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(file_meta_sink_sptr self, int priority) -> int"""
        return _blocks_swig0.file_meta_sink_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(file_meta_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_sink_sptr_name(self)


    def symbol_name(self):
        """symbol_name(file_meta_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_sink_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(file_meta_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_meta_sink_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(file_meta_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_meta_sink_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(file_meta_sink_sptr self) -> long"""
        return _blocks_swig0.file_meta_sink_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(file_meta_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.file_meta_sink_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(file_meta_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.file_meta_sink_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(file_meta_sink_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_sink_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(file_meta_sink_sptr self, std::string name)"""
        return _blocks_swig0.file_meta_sink_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(file_meta_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.file_meta_sink_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(file_meta_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_meta_sink_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(file_meta_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_meta_sink_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(file_meta_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.file_meta_sink_sptr_message_subscribers(self, which_port)

file_meta_sink_sptr_swigregister = _blocks_swig0.file_meta_sink_sptr_swigregister
file_meta_sink_sptr_swigregister(file_meta_sink_sptr)


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

class file_meta_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::file_meta_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::file_meta_source)> self) -> file_meta_source_sptr
        __init__(boost::shared_ptr<(gr::blocks::file_meta_source)> self, file_meta_source p) -> file_meta_source_sptr
        """
        this = _blocks_swig0.new_file_meta_source_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(file_meta_source_sptr self) -> file_meta_source"""
        return _blocks_swig0.file_meta_source_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_file_meta_source_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(file_meta_source_sptr self, std::string const & filename, bool repeat=False, bool detached_header=False, std::string const & hdr_filename) -> file_meta_source_sptr"""
        return _blocks_swig0.file_meta_source_sptr_make(self, *args, **kwargs)


    def open(self, *args, **kwargs):
        """open(file_meta_source_sptr self, std::string const & filename, std::string const & hdr_filename) -> bool"""
        return _blocks_swig0.file_meta_source_sptr_open(self, *args, **kwargs)


    def close(self):
        """close(file_meta_source_sptr self)"""
        return _blocks_swig0.file_meta_source_sptr_close(self)


    def do_update(self):
        """do_update(file_meta_source_sptr self)"""
        return _blocks_swig0.file_meta_source_sptr_do_update(self)


    def history(self):
        """history(file_meta_source_sptr self) -> unsigned int"""
        return _blocks_swig0.file_meta_source_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(file_meta_source_sptr self, int which, int delay)
        declare_sample_delay(file_meta_source_sptr self, unsigned int delay)
        """
        return _blocks_swig0.file_meta_source_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(file_meta_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.file_meta_source_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(file_meta_source_sptr self) -> int"""
        return _blocks_swig0.file_meta_source_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(file_meta_source_sptr self) -> double"""
        return _blocks_swig0.file_meta_source_sptr_relative_rate(self)


    def start(self):
        """start(file_meta_source_sptr self) -> bool"""
        return _blocks_swig0.file_meta_source_sptr_start(self)


    def stop(self):
        """stop(file_meta_source_sptr self) -> bool"""
        return _blocks_swig0.file_meta_source_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(file_meta_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.file_meta_source_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(file_meta_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.file_meta_source_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(file_meta_source_sptr self) -> int"""
        return _blocks_swig0.file_meta_source_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(file_meta_source_sptr self, int m)"""
        return _blocks_swig0.file_meta_source_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(file_meta_source_sptr self)"""
        return _blocks_swig0.file_meta_source_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(file_meta_source_sptr self) -> bool"""
        return _blocks_swig0.file_meta_source_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(file_meta_source_sptr self, int m)"""
        return _blocks_swig0.file_meta_source_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(file_meta_source_sptr self) -> int"""
        return _blocks_swig0.file_meta_source_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(file_meta_source_sptr self, int i) -> long"""
        return _blocks_swig0.file_meta_source_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(file_meta_source_sptr self, long max_output_buffer)
        set_max_output_buffer(file_meta_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.file_meta_source_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(file_meta_source_sptr self, int i) -> long"""
        return _blocks_swig0.file_meta_source_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(file_meta_source_sptr self, long min_output_buffer)
        set_min_output_buffer(file_meta_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.file_meta_source_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(file_meta_source_sptr self, int which) -> float
        pc_input_buffers_full(file_meta_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_source_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(file_meta_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(file_meta_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_source_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(file_meta_source_sptr self, int which) -> float
        pc_input_buffers_full_var(file_meta_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_source_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(file_meta_source_sptr self, int which) -> float
        pc_output_buffers_full(file_meta_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_source_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(file_meta_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(file_meta_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_source_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(file_meta_source_sptr self, int which) -> float
        pc_output_buffers_full_var(file_meta_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.file_meta_source_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(file_meta_source_sptr self) -> float"""
        return _blocks_swig0.file_meta_source_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(file_meta_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.file_meta_source_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(file_meta_source_sptr self)"""
        return _blocks_swig0.file_meta_source_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(file_meta_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.file_meta_source_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(file_meta_source_sptr self) -> int"""
        return _blocks_swig0.file_meta_source_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(file_meta_source_sptr self) -> int"""
        return _blocks_swig0.file_meta_source_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(file_meta_source_sptr self, int priority) -> int"""
        return _blocks_swig0.file_meta_source_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(file_meta_source_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_source_sptr_name(self)


    def symbol_name(self):
        """symbol_name(file_meta_source_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_source_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(file_meta_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_meta_source_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(file_meta_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.file_meta_source_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(file_meta_source_sptr self) -> long"""
        return _blocks_swig0.file_meta_source_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(file_meta_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.file_meta_source_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(file_meta_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.file_meta_source_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(file_meta_source_sptr self) -> std::string"""
        return _blocks_swig0.file_meta_source_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(file_meta_source_sptr self, std::string name)"""
        return _blocks_swig0.file_meta_source_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(file_meta_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.file_meta_source_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(file_meta_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_meta_source_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(file_meta_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.file_meta_source_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(file_meta_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.file_meta_source_sptr_message_subscribers(self, which_port)

file_meta_source_sptr_swigregister = _blocks_swig0.file_meta_source_sptr_swigregister
file_meta_source_sptr_swigregister(file_meta_source_sptr)


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

class head_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::head)> 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::head)> self) -> head_sptr
        __init__(boost::shared_ptr<(gr::blocks::head)> self, head p) -> head_sptr
        """
        this = _blocks_swig0.new_head_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(head_sptr self) -> head"""
        return _blocks_swig0.head_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_head_sptr
    __del__ = lambda self: None

    def make(self, sizeof_stream_item, nitems):
        """make(head_sptr self, size_t sizeof_stream_item, uint64_t nitems) -> head_sptr"""
        return _blocks_swig0.head_sptr_make(self, sizeof_stream_item, nitems)


    def reset(self):
        """reset(head_sptr self)"""
        return _blocks_swig0.head_sptr_reset(self)


    def set_length(self, nitems):
        """set_length(head_sptr self, int nitems)"""
        return _blocks_swig0.head_sptr_set_length(self, nitems)


    def history(self):
        """history(head_sptr self) -> unsigned int"""
        return _blocks_swig0.head_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(head_sptr self, int which, int delay)
        declare_sample_delay(head_sptr self, unsigned int delay)
        """
        return _blocks_swig0.head_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(head_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.head_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(head_sptr self) -> int"""
        return _blocks_swig0.head_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(head_sptr self) -> double"""
        return _blocks_swig0.head_sptr_relative_rate(self)


    def start(self):
        """start(head_sptr self) -> bool"""
        return _blocks_swig0.head_sptr_start(self)


    def stop(self):
        """stop(head_sptr self) -> bool"""
        return _blocks_swig0.head_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(head_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.head_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(head_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.head_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(head_sptr self) -> int"""
        return _blocks_swig0.head_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(head_sptr self, int m)"""
        return _blocks_swig0.head_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(head_sptr self)"""
        return _blocks_swig0.head_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(head_sptr self) -> bool"""
        return _blocks_swig0.head_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(head_sptr self, int m)"""
        return _blocks_swig0.head_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(head_sptr self) -> int"""
        return _blocks_swig0.head_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(head_sptr self, int i) -> long"""
        return _blocks_swig0.head_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(head_sptr self, long max_output_buffer)
        set_max_output_buffer(head_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.head_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(head_sptr self, int i) -> long"""
        return _blocks_swig0.head_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(head_sptr self, long min_output_buffer)
        set_min_output_buffer(head_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.head_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(head_sptr self, int which) -> float
        pc_input_buffers_full(head_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.head_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(head_sptr self, int which) -> float
        pc_input_buffers_full_avg(head_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.head_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(head_sptr self, int which) -> float
        pc_input_buffers_full_var(head_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.head_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(head_sptr self, int which) -> float
        pc_output_buffers_full(head_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.head_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(head_sptr self, int which) -> float
        pc_output_buffers_full_avg(head_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.head_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(head_sptr self, int which) -> float
        pc_output_buffers_full_var(head_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.head_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(head_sptr self) -> float"""
        return _blocks_swig0.head_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(head_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.head_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(head_sptr self)"""
        return _blocks_swig0.head_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(head_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.head_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(head_sptr self) -> int"""
        return _blocks_swig0.head_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(head_sptr self) -> int"""
        return _blocks_swig0.head_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(head_sptr self, int priority) -> int"""
        return _blocks_swig0.head_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(head_sptr self) -> std::string"""
        return _blocks_swig0.head_sptr_name(self)


    def symbol_name(self):
        """symbol_name(head_sptr self) -> std::string"""
        return _blocks_swig0.head_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(head_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.head_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(head_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.head_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(head_sptr self) -> long"""
        return _blocks_swig0.head_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(head_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.head_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(head_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.head_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(head_sptr self) -> std::string"""
        return _blocks_swig0.head_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(head_sptr self, std::string name)"""
        return _blocks_swig0.head_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(head_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.head_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(head_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.head_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(head_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.head_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(head_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.head_sptr_message_subscribers(self, which_port)

head_sptr_swigregister = _blocks_swig0.head_sptr_swigregister
head_sptr_swigregister(head_sptr)


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

class message_debug_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::message_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::message_debug)> self) -> message_debug_sptr
        __init__(boost::shared_ptr<(gr::blocks::message_debug)> self, message_debug p) -> message_debug_sptr
        """
        this = _blocks_swig0.new_message_debug_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(message_debug_sptr self) -> message_debug"""
        return _blocks_swig0.message_debug_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_message_debug_sptr
    __del__ = lambda self: None

    def make(self):
        """make(message_debug_sptr self) -> message_debug_sptr"""
        return _blocks_swig0.message_debug_sptr_make(self)


    def num_messages(self):
        """num_messages(message_debug_sptr self) -> int"""
        return _blocks_swig0.message_debug_sptr_num_messages(self)


    def get_message(self, i):
        """get_message(message_debug_sptr self, int i) -> swig_int_ptr"""
        return _blocks_swig0.message_debug_sptr_get_message(self, i)


    def history(self):
        """history(message_debug_sptr self) -> unsigned int"""
        return _blocks_swig0.message_debug_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(message_debug_sptr self, int which, int delay)
        declare_sample_delay(message_debug_sptr self, unsigned int delay)
        """
        return _blocks_swig0.message_debug_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(message_debug_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.message_debug_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(message_debug_sptr self) -> int"""
        return _blocks_swig0.message_debug_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(message_debug_sptr self) -> double"""
        return _blocks_swig0.message_debug_sptr_relative_rate(self)


    def start(self):
        """start(message_debug_sptr self) -> bool"""
        return _blocks_swig0.message_debug_sptr_start(self)


    def stop(self):
        """stop(message_debug_sptr self) -> bool"""
        return _blocks_swig0.message_debug_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(message_debug_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.message_debug_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(message_debug_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.message_debug_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(message_debug_sptr self) -> int"""
        return _blocks_swig0.message_debug_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(message_debug_sptr self, int m)"""
        return _blocks_swig0.message_debug_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(message_debug_sptr self)"""
        return _blocks_swig0.message_debug_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(message_debug_sptr self) -> bool"""
        return _blocks_swig0.message_debug_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(message_debug_sptr self, int m)"""
        return _blocks_swig0.message_debug_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(message_debug_sptr self) -> int"""
        return _blocks_swig0.message_debug_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(message_debug_sptr self, int i) -> long"""
        return _blocks_swig0.message_debug_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(message_debug_sptr self, long max_output_buffer)
        set_max_output_buffer(message_debug_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.message_debug_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(message_debug_sptr self, int i) -> long"""
        return _blocks_swig0.message_debug_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(message_debug_sptr self, long min_output_buffer)
        set_min_output_buffer(message_debug_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.message_debug_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(message_debug_sptr self, int which) -> float
        pc_input_buffers_full(message_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_debug_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(message_debug_sptr self, int which) -> float
        pc_input_buffers_full_avg(message_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_debug_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(message_debug_sptr self, int which) -> float
        pc_input_buffers_full_var(message_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_debug_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(message_debug_sptr self, int which) -> float
        pc_output_buffers_full(message_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_debug_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(message_debug_sptr self, int which) -> float
        pc_output_buffers_full_avg(message_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_debug_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(message_debug_sptr self, int which) -> float
        pc_output_buffers_full_var(message_debug_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_debug_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(message_debug_sptr self) -> float"""
        return _blocks_swig0.message_debug_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(message_debug_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.message_debug_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(message_debug_sptr self)"""
        return _blocks_swig0.message_debug_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(message_debug_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.message_debug_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(message_debug_sptr self) -> int"""
        return _blocks_swig0.message_debug_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(message_debug_sptr self) -> int"""
        return _blocks_swig0.message_debug_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(message_debug_sptr self, int priority) -> int"""
        return _blocks_swig0.message_debug_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(message_debug_sptr self) -> std::string"""
        return _blocks_swig0.message_debug_sptr_name(self)


    def symbol_name(self):
        """symbol_name(message_debug_sptr self) -> std::string"""
        return _blocks_swig0.message_debug_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(message_debug_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_debug_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(message_debug_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_debug_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(message_debug_sptr self) -> long"""
        return _blocks_swig0.message_debug_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(message_debug_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.message_debug_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(message_debug_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.message_debug_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(message_debug_sptr self) -> std::string"""
        return _blocks_swig0.message_debug_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(message_debug_sptr self, std::string name)"""
        return _blocks_swig0.message_debug_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(message_debug_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.message_debug_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(message_debug_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_debug_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(message_debug_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_debug_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(message_debug_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.message_debug_sptr_message_subscribers(self, which_port)

message_debug_sptr_swigregister = _blocks_swig0.message_debug_sptr_swigregister
message_debug_sptr_swigregister(message_debug_sptr)


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

class message_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::message_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::message_sink)> self) -> message_sink_sptr
        __init__(boost::shared_ptr<(gr::blocks::message_sink)> self, message_sink p) -> message_sink_sptr
        """
        this = _blocks_swig0.new_message_sink_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(message_sink_sptr self) -> message_sink"""
        return _blocks_swig0.message_sink_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_message_sink_sptr
    __del__ = lambda self: None

    def make(self, *args):
        """
        make(message_sink_sptr self, size_t itemsize, msg_queue_sptr msgq, bool dont_block) -> message_sink_sptr
        make(message_sink_sptr self, size_t itemsize, msg_queue_sptr msgq, bool dont_block, std::string const & lengthtagname) -> message_sink_sptr
        """
        return _blocks_swig0.message_sink_sptr_make(self, *args)


    def history(self):
        """history(message_sink_sptr self) -> unsigned int"""
        return _blocks_swig0.message_sink_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(message_sink_sptr self, int which, int delay)
        declare_sample_delay(message_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig0.message_sink_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(message_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.message_sink_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(message_sink_sptr self) -> int"""
        return _blocks_swig0.message_sink_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(message_sink_sptr self) -> double"""
        return _blocks_swig0.message_sink_sptr_relative_rate(self)


    def start(self):
        """start(message_sink_sptr self) -> bool"""
        return _blocks_swig0.message_sink_sptr_start(self)


    def stop(self):
        """stop(message_sink_sptr self) -> bool"""
        return _blocks_swig0.message_sink_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(message_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.message_sink_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(message_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.message_sink_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(message_sink_sptr self) -> int"""
        return _blocks_swig0.message_sink_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(message_sink_sptr self, int m)"""
        return _blocks_swig0.message_sink_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(message_sink_sptr self)"""
        return _blocks_swig0.message_sink_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(message_sink_sptr self) -> bool"""
        return _blocks_swig0.message_sink_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(message_sink_sptr self, int m)"""
        return _blocks_swig0.message_sink_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(message_sink_sptr self) -> int"""
        return _blocks_swig0.message_sink_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(message_sink_sptr self, int i) -> long"""
        return _blocks_swig0.message_sink_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(message_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(message_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.message_sink_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(message_sink_sptr self, int i) -> long"""
        return _blocks_swig0.message_sink_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(message_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(message_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.message_sink_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(message_sink_sptr self, int which) -> float
        pc_input_buffers_full(message_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_sink_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(message_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(message_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_sink_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(message_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(message_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_sink_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(message_sink_sptr self, int which) -> float
        pc_output_buffers_full(message_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_sink_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(message_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(message_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_sink_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(message_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(message_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_sink_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(message_sink_sptr self) -> float"""
        return _blocks_swig0.message_sink_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(message_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.message_sink_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(message_sink_sptr self)"""
        return _blocks_swig0.message_sink_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(message_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.message_sink_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(message_sink_sptr self) -> int"""
        return _blocks_swig0.message_sink_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(message_sink_sptr self) -> int"""
        return _blocks_swig0.message_sink_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(message_sink_sptr self, int priority) -> int"""
        return _blocks_swig0.message_sink_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(message_sink_sptr self) -> std::string"""
        return _blocks_swig0.message_sink_sptr_name(self)


    def symbol_name(self):
        """symbol_name(message_sink_sptr self) -> std::string"""
        return _blocks_swig0.message_sink_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(message_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_sink_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(message_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_sink_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(message_sink_sptr self) -> long"""
        return _blocks_swig0.message_sink_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(message_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.message_sink_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(message_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.message_sink_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(message_sink_sptr self) -> std::string"""
        return _blocks_swig0.message_sink_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(message_sink_sptr self, std::string name)"""
        return _blocks_swig0.message_sink_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(message_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.message_sink_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(message_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_sink_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(message_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_sink_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(message_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.message_sink_sptr_message_subscribers(self, which_port)

message_sink_sptr_swigregister = _blocks_swig0.message_sink_sptr_swigregister
message_sink_sptr_swigregister(message_sink_sptr)


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

class message_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::message_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::message_source)> self) -> message_source_sptr
        __init__(boost::shared_ptr<(gr::blocks::message_source)> self, message_source p) -> message_source_sptr
        """
        this = _blocks_swig0.new_message_source_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(message_source_sptr self) -> message_source"""
        return _blocks_swig0.message_source_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_message_source_sptr
    __del__ = lambda self: None

    def make(self, *args):
        """
        make(message_source_sptr self, size_t itemsize, int msgq_limit=0) -> message_source_sptr
        make(message_source_sptr self, size_t itemsize, msg_queue_sptr msgq) -> message_source_sptr
        make(message_source_sptr self, size_t itemsize, msg_queue_sptr msgq, std::string const & lengthtagname) -> message_source_sptr
        """
        return _blocks_swig0.message_source_sptr_make(self, *args)


    def msgq(self):
        """msgq(message_source_sptr self) -> msg_queue_sptr"""
        return _blocks_swig0.message_source_sptr_msgq(self)


    def history(self):
        """history(message_source_sptr self) -> unsigned int"""
        return _blocks_swig0.message_source_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(message_source_sptr self, int which, int delay)
        declare_sample_delay(message_source_sptr self, unsigned int delay)
        """
        return _blocks_swig0.message_source_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(message_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.message_source_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(message_source_sptr self) -> int"""
        return _blocks_swig0.message_source_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(message_source_sptr self) -> double"""
        return _blocks_swig0.message_source_sptr_relative_rate(self)


    def start(self):
        """start(message_source_sptr self) -> bool"""
        return _blocks_swig0.message_source_sptr_start(self)


    def stop(self):
        """stop(message_source_sptr self) -> bool"""
        return _blocks_swig0.message_source_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(message_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.message_source_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(message_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.message_source_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(message_source_sptr self) -> int"""
        return _blocks_swig0.message_source_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(message_source_sptr self, int m)"""
        return _blocks_swig0.message_source_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(message_source_sptr self)"""
        return _blocks_swig0.message_source_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(message_source_sptr self) -> bool"""
        return _blocks_swig0.message_source_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(message_source_sptr self, int m)"""
        return _blocks_swig0.message_source_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(message_source_sptr self) -> int"""
        return _blocks_swig0.message_source_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(message_source_sptr self, int i) -> long"""
        return _blocks_swig0.message_source_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(message_source_sptr self, long max_output_buffer)
        set_max_output_buffer(message_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.message_source_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(message_source_sptr self, int i) -> long"""
        return _blocks_swig0.message_source_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(message_source_sptr self, long min_output_buffer)
        set_min_output_buffer(message_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.message_source_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(message_source_sptr self, int which) -> float
        pc_input_buffers_full(message_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_source_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(message_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(message_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_source_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(message_source_sptr self, int which) -> float
        pc_input_buffers_full_var(message_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_source_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(message_source_sptr self, int which) -> float
        pc_output_buffers_full(message_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_source_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(message_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(message_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_source_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(message_source_sptr self, int which) -> float
        pc_output_buffers_full_var(message_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_source_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(message_source_sptr self) -> float"""
        return _blocks_swig0.message_source_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(message_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.message_source_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(message_source_sptr self)"""
        return _blocks_swig0.message_source_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(message_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.message_source_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(message_source_sptr self) -> int"""
        return _blocks_swig0.message_source_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(message_source_sptr self) -> int"""
        return _blocks_swig0.message_source_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(message_source_sptr self, int priority) -> int"""
        return _blocks_swig0.message_source_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(message_source_sptr self) -> std::string"""
        return _blocks_swig0.message_source_sptr_name(self)


    def symbol_name(self):
        """symbol_name(message_source_sptr self) -> std::string"""
        return _blocks_swig0.message_source_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(message_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_source_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(message_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_source_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(message_source_sptr self) -> long"""
        return _blocks_swig0.message_source_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(message_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.message_source_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(message_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.message_source_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(message_source_sptr self) -> std::string"""
        return _blocks_swig0.message_source_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(message_source_sptr self, std::string name)"""
        return _blocks_swig0.message_source_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(message_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.message_source_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(message_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_source_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(message_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_source_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(message_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.message_source_sptr_message_subscribers(self, which_port)

message_source_sptr_swigregister = _blocks_swig0.message_source_sptr_swigregister
message_source_sptr_swigregister(message_source_sptr)


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

class message_strobe_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::message_strobe)> 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::message_strobe)> self) -> message_strobe_sptr
        __init__(boost::shared_ptr<(gr::blocks::message_strobe)> self, message_strobe p) -> message_strobe_sptr
        """
        this = _blocks_swig0.new_message_strobe_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(message_strobe_sptr self) -> message_strobe"""
        return _blocks_swig0.message_strobe_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_message_strobe_sptr
    __del__ = lambda self: None

    def make(self, msg, period_ms):
        """make(message_strobe_sptr self, swig_int_ptr msg, float period_ms) -> message_strobe_sptr"""
        return _blocks_swig0.message_strobe_sptr_make(self, msg, period_ms)


    def set_msg(self, msg):
        """set_msg(message_strobe_sptr self, swig_int_ptr msg)"""
        return _blocks_swig0.message_strobe_sptr_set_msg(self, msg)


    def msg(self):
        """msg(message_strobe_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_sptr_msg(self)


    def set_period(self, period_ms):
        """set_period(message_strobe_sptr self, float period_ms)"""
        return _blocks_swig0.message_strobe_sptr_set_period(self, period_ms)


    def period(self):
        """period(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_period(self)


    def history(self):
        """history(message_strobe_sptr self) -> unsigned int"""
        return _blocks_swig0.message_strobe_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(message_strobe_sptr self, int which, int delay)
        declare_sample_delay(message_strobe_sptr self, unsigned int delay)
        """
        return _blocks_swig0.message_strobe_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(message_strobe_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.message_strobe_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(message_strobe_sptr self) -> int"""
        return _blocks_swig0.message_strobe_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(message_strobe_sptr self) -> double"""
        return _blocks_swig0.message_strobe_sptr_relative_rate(self)


    def start(self):
        """start(message_strobe_sptr self) -> bool"""
        return _blocks_swig0.message_strobe_sptr_start(self)


    def stop(self):
        """stop(message_strobe_sptr self) -> bool"""
        return _blocks_swig0.message_strobe_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(message_strobe_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.message_strobe_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(message_strobe_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.message_strobe_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(message_strobe_sptr self) -> int"""
        return _blocks_swig0.message_strobe_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(message_strobe_sptr self, int m)"""
        return _blocks_swig0.message_strobe_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(message_strobe_sptr self)"""
        return _blocks_swig0.message_strobe_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(message_strobe_sptr self) -> bool"""
        return _blocks_swig0.message_strobe_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(message_strobe_sptr self, int m)"""
        return _blocks_swig0.message_strobe_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(message_strobe_sptr self) -> int"""
        return _blocks_swig0.message_strobe_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(message_strobe_sptr self, int i) -> long"""
        return _blocks_swig0.message_strobe_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(message_strobe_sptr self, long max_output_buffer)
        set_max_output_buffer(message_strobe_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.message_strobe_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(message_strobe_sptr self, int i) -> long"""
        return _blocks_swig0.message_strobe_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(message_strobe_sptr self, long min_output_buffer)
        set_min_output_buffer(message_strobe_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.message_strobe_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(message_strobe_sptr self, int which) -> float
        pc_input_buffers_full(message_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(message_strobe_sptr self, int which) -> float
        pc_input_buffers_full_avg(message_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(message_strobe_sptr self, int which) -> float
        pc_input_buffers_full_var(message_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(message_strobe_sptr self, int which) -> float
        pc_output_buffers_full(message_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(message_strobe_sptr self, int which) -> float
        pc_output_buffers_full_avg(message_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(message_strobe_sptr self, int which) -> float
        pc_output_buffers_full_var(message_strobe_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(message_strobe_sptr self) -> float"""
        return _blocks_swig0.message_strobe_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(message_strobe_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.message_strobe_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(message_strobe_sptr self)"""
        return _blocks_swig0.message_strobe_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(message_strobe_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.message_strobe_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(message_strobe_sptr self) -> int"""
        return _blocks_swig0.message_strobe_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(message_strobe_sptr self) -> int"""
        return _blocks_swig0.message_strobe_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(message_strobe_sptr self, int priority) -> int"""
        return _blocks_swig0.message_strobe_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(message_strobe_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_sptr_name(self)


    def symbol_name(self):
        """symbol_name(message_strobe_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(message_strobe_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_strobe_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(message_strobe_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_strobe_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(message_strobe_sptr self) -> long"""
        return _blocks_swig0.message_strobe_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(message_strobe_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.message_strobe_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(message_strobe_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.message_strobe_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(message_strobe_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(message_strobe_sptr self, std::string name)"""
        return _blocks_swig0.message_strobe_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(message_strobe_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.message_strobe_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(message_strobe_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(message_strobe_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(message_strobe_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_sptr_message_subscribers(self, which_port)

message_strobe_sptr_swigregister = _blocks_swig0.message_strobe_sptr_swigregister
message_strobe_sptr_swigregister(message_strobe_sptr)


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

class message_strobe_random_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::message_strobe_random)> 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::message_strobe_random)> self) -> message_strobe_random_sptr
        __init__(boost::shared_ptr<(gr::blocks::message_strobe_random)> self, message_strobe_random p) -> message_strobe_random_sptr
        """
        this = _blocks_swig0.new_message_strobe_random_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(message_strobe_random_sptr self) -> message_strobe_random"""
        return _blocks_swig0.message_strobe_random_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_message_strobe_random_sptr
    __del__ = lambda self: None

    def make(self, msg, dist, mean_ms, std_ms):
        """make(message_strobe_random_sptr self, swig_int_ptr msg, gr::blocks::message_strobe_random_distribution_t dist, float mean_ms, float std_ms) -> message_strobe_random_sptr"""
        return _blocks_swig0.message_strobe_random_sptr_make(self, msg, dist, mean_ms, std_ms)


    def set_msg(self, msg):
        """set_msg(message_strobe_random_sptr self, swig_int_ptr msg)"""
        return _blocks_swig0.message_strobe_random_sptr_set_msg(self, msg)


    def msg(self):
        """msg(message_strobe_random_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_random_sptr_msg(self)


    def set_dist(self, dist):
        """set_dist(message_strobe_random_sptr self, gr::blocks::message_strobe_random_distribution_t dist)"""
        return _blocks_swig0.message_strobe_random_sptr_set_dist(self, dist)


    def dist(self):
        """dist(message_strobe_random_sptr self) -> gr::blocks::message_strobe_random_distribution_t"""
        return _blocks_swig0.message_strobe_random_sptr_dist(self)


    def set_mean(self, mean):
        """set_mean(message_strobe_random_sptr self, float mean)"""
        return _blocks_swig0.message_strobe_random_sptr_set_mean(self, mean)


    def mean(self):
        """mean(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_mean(self)


    def set_std(self, std):
        """set_std(message_strobe_random_sptr self, float std)"""
        return _blocks_swig0.message_strobe_random_sptr_set_std(self, std)


    def std(self):
        """std(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_std(self)


    def history(self):
        """history(message_strobe_random_sptr self) -> unsigned int"""
        return _blocks_swig0.message_strobe_random_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(message_strobe_random_sptr self, int which, int delay)
        declare_sample_delay(message_strobe_random_sptr self, unsigned int delay)
        """
        return _blocks_swig0.message_strobe_random_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(message_strobe_random_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.message_strobe_random_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(message_strobe_random_sptr self) -> int"""
        return _blocks_swig0.message_strobe_random_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(message_strobe_random_sptr self) -> double"""
        return _blocks_swig0.message_strobe_random_sptr_relative_rate(self)


    def start(self):
        """start(message_strobe_random_sptr self) -> bool"""
        return _blocks_swig0.message_strobe_random_sptr_start(self)


    def stop(self):
        """stop(message_strobe_random_sptr self) -> bool"""
        return _blocks_swig0.message_strobe_random_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(message_strobe_random_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.message_strobe_random_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(message_strobe_random_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.message_strobe_random_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(message_strobe_random_sptr self) -> int"""
        return _blocks_swig0.message_strobe_random_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(message_strobe_random_sptr self, int m)"""
        return _blocks_swig0.message_strobe_random_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(message_strobe_random_sptr self)"""
        return _blocks_swig0.message_strobe_random_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(message_strobe_random_sptr self) -> bool"""
        return _blocks_swig0.message_strobe_random_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(message_strobe_random_sptr self, int m)"""
        return _blocks_swig0.message_strobe_random_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(message_strobe_random_sptr self) -> int"""
        return _blocks_swig0.message_strobe_random_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(message_strobe_random_sptr self, int i) -> long"""
        return _blocks_swig0.message_strobe_random_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(message_strobe_random_sptr self, long max_output_buffer)
        set_max_output_buffer(message_strobe_random_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.message_strobe_random_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(message_strobe_random_sptr self, int i) -> long"""
        return _blocks_swig0.message_strobe_random_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(message_strobe_random_sptr self, long min_output_buffer)
        set_min_output_buffer(message_strobe_random_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.message_strobe_random_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(message_strobe_random_sptr self, int which) -> float
        pc_input_buffers_full(message_strobe_random_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_random_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(message_strobe_random_sptr self, int which) -> float
        pc_input_buffers_full_avg(message_strobe_random_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_random_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(message_strobe_random_sptr self, int which) -> float
        pc_input_buffers_full_var(message_strobe_random_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_random_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(message_strobe_random_sptr self, int which) -> float
        pc_output_buffers_full(message_strobe_random_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_random_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(message_strobe_random_sptr self, int which) -> float
        pc_output_buffers_full_avg(message_strobe_random_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_random_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(message_strobe_random_sptr self, int which) -> float
        pc_output_buffers_full_var(message_strobe_random_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_strobe_random_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(message_strobe_random_sptr self) -> float"""
        return _blocks_swig0.message_strobe_random_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(message_strobe_random_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.message_strobe_random_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(message_strobe_random_sptr self)"""
        return _blocks_swig0.message_strobe_random_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(message_strobe_random_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.message_strobe_random_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(message_strobe_random_sptr self) -> int"""
        return _blocks_swig0.message_strobe_random_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(message_strobe_random_sptr self) -> int"""
        return _blocks_swig0.message_strobe_random_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(message_strobe_random_sptr self, int priority) -> int"""
        return _blocks_swig0.message_strobe_random_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(message_strobe_random_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_random_sptr_name(self)


    def symbol_name(self):
        """symbol_name(message_strobe_random_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_random_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(message_strobe_random_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_strobe_random_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(message_strobe_random_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_strobe_random_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(message_strobe_random_sptr self) -> long"""
        return _blocks_swig0.message_strobe_random_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(message_strobe_random_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.message_strobe_random_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(message_strobe_random_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.message_strobe_random_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(message_strobe_random_sptr self) -> std::string"""
        return _blocks_swig0.message_strobe_random_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(message_strobe_random_sptr self, std::string name)"""
        return _blocks_swig0.message_strobe_random_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(message_strobe_random_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.message_strobe_random_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(message_strobe_random_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_random_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(message_strobe_random_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_random_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(message_strobe_random_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.message_strobe_random_sptr_message_subscribers(self, which_port)

message_strobe_random_sptr_swigregister = _blocks_swig0.message_strobe_random_sptr_swigregister
message_strobe_random_sptr_swigregister(message_strobe_random_sptr)


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

class message_burst_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::message_burst_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::message_burst_source)> self) -> message_burst_source_sptr
        __init__(boost::shared_ptr<(gr::blocks::message_burst_source)> self, message_burst_source p) -> message_burst_source_sptr
        """
        this = _blocks_swig0.new_message_burst_source_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(message_burst_source_sptr self) -> message_burst_source"""
        return _blocks_swig0.message_burst_source_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_message_burst_source_sptr
    __del__ = lambda self: None

    def make(self, *args):
        """
        make(message_burst_source_sptr self, size_t itemsize, int msgq_limit) -> message_burst_source_sptr
        make(message_burst_source_sptr self, size_t itemsize, msg_queue_sptr msgq) -> message_burst_source_sptr
        """
        return _blocks_swig0.message_burst_source_sptr_make(self, *args)


    def msgq(self):
        """msgq(message_burst_source_sptr self) -> msg_queue_sptr"""
        return _blocks_swig0.message_burst_source_sptr_msgq(self)


    def history(self):
        """history(message_burst_source_sptr self) -> unsigned int"""
        return _blocks_swig0.message_burst_source_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(message_burst_source_sptr self, int which, int delay)
        declare_sample_delay(message_burst_source_sptr self, unsigned int delay)
        """
        return _blocks_swig0.message_burst_source_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(message_burst_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.message_burst_source_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(message_burst_source_sptr self) -> int"""
        return _blocks_swig0.message_burst_source_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(message_burst_source_sptr self) -> double"""
        return _blocks_swig0.message_burst_source_sptr_relative_rate(self)


    def start(self):
        """start(message_burst_source_sptr self) -> bool"""
        return _blocks_swig0.message_burst_source_sptr_start(self)


    def stop(self):
        """stop(message_burst_source_sptr self) -> bool"""
        return _blocks_swig0.message_burst_source_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(message_burst_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.message_burst_source_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(message_burst_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.message_burst_source_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(message_burst_source_sptr self) -> int"""
        return _blocks_swig0.message_burst_source_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(message_burst_source_sptr self, int m)"""
        return _blocks_swig0.message_burst_source_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(message_burst_source_sptr self)"""
        return _blocks_swig0.message_burst_source_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(message_burst_source_sptr self) -> bool"""
        return _blocks_swig0.message_burst_source_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(message_burst_source_sptr self, int m)"""
        return _blocks_swig0.message_burst_source_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(message_burst_source_sptr self) -> int"""
        return _blocks_swig0.message_burst_source_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(message_burst_source_sptr self, int i) -> long"""
        return _blocks_swig0.message_burst_source_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(message_burst_source_sptr self, long max_output_buffer)
        set_max_output_buffer(message_burst_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.message_burst_source_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(message_burst_source_sptr self, int i) -> long"""
        return _blocks_swig0.message_burst_source_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(message_burst_source_sptr self, long min_output_buffer)
        set_min_output_buffer(message_burst_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.message_burst_source_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(message_burst_source_sptr self, int which) -> float
        pc_input_buffers_full(message_burst_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_burst_source_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(message_burst_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(message_burst_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_burst_source_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(message_burst_source_sptr self, int which) -> float
        pc_input_buffers_full_var(message_burst_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_burst_source_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(message_burst_source_sptr self, int which) -> float
        pc_output_buffers_full(message_burst_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_burst_source_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(message_burst_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(message_burst_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_burst_source_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(message_burst_source_sptr self, int which) -> float
        pc_output_buffers_full_var(message_burst_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.message_burst_source_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(message_burst_source_sptr self) -> float"""
        return _blocks_swig0.message_burst_source_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(message_burst_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.message_burst_source_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(message_burst_source_sptr self)"""
        return _blocks_swig0.message_burst_source_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(message_burst_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.message_burst_source_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(message_burst_source_sptr self) -> int"""
        return _blocks_swig0.message_burst_source_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(message_burst_source_sptr self) -> int"""
        return _blocks_swig0.message_burst_source_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(message_burst_source_sptr self, int priority) -> int"""
        return _blocks_swig0.message_burst_source_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(message_burst_source_sptr self) -> std::string"""
        return _blocks_swig0.message_burst_source_sptr_name(self)


    def symbol_name(self):
        """symbol_name(message_burst_source_sptr self) -> std::string"""
        return _blocks_swig0.message_burst_source_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(message_burst_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_burst_source_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(message_burst_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.message_burst_source_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(message_burst_source_sptr self) -> long"""
        return _blocks_swig0.message_burst_source_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(message_burst_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.message_burst_source_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(message_burst_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.message_burst_source_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(message_burst_source_sptr self) -> std::string"""
        return _blocks_swig0.message_burst_source_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(message_burst_source_sptr self, std::string name)"""
        return _blocks_swig0.message_burst_source_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(message_burst_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.message_burst_source_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(message_burst_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_burst_source_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(message_burst_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.message_burst_source_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(message_burst_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.message_burst_source_sptr_message_subscribers(self, which_port)

message_burst_source_sptr_swigregister = _blocks_swig0.message_burst_source_sptr_swigregister
message_burst_source_sptr_swigregister(message_burst_source_sptr)


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

class nop_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::nop)> 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::nop)> self) -> nop_sptr
        __init__(boost::shared_ptr<(gr::blocks::nop)> self, nop p) -> nop_sptr
        """
        this = _blocks_swig0.new_nop_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(nop_sptr self) -> nop"""
        return _blocks_swig0.nop_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_nop_sptr
    __del__ = lambda self: None

    def make(self, sizeof_stream_item):
        """make(nop_sptr self, size_t sizeof_stream_item) -> nop_sptr"""
        return _blocks_swig0.nop_sptr_make(self, sizeof_stream_item)


    def nmsgs_received(self):
        """nmsgs_received(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_nmsgs_received(self)


    def ctrlport_test(self):
        """ctrlport_test(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_ctrlport_test(self)


    def set_ctrlport_test(self, x):
        """set_ctrlport_test(nop_sptr self, int x)"""
        return _blocks_swig0.nop_sptr_set_ctrlport_test(self, x)


    def history(self):
        """history(nop_sptr self) -> unsigned int"""
        return _blocks_swig0.nop_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(nop_sptr self, int which, int delay)
        declare_sample_delay(nop_sptr self, unsigned int delay)
        """
        return _blocks_swig0.nop_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(nop_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.nop_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(nop_sptr self) -> double"""
        return _blocks_swig0.nop_sptr_relative_rate(self)


    def start(self):
        """start(nop_sptr self) -> bool"""
        return _blocks_swig0.nop_sptr_start(self)


    def stop(self):
        """stop(nop_sptr self) -> bool"""
        return _blocks_swig0.nop_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(nop_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.nop_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(nop_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.nop_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(nop_sptr self, int m)"""
        return _blocks_swig0.nop_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(nop_sptr self)"""
        return _blocks_swig0.nop_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(nop_sptr self) -> bool"""
        return _blocks_swig0.nop_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(nop_sptr self, int m)"""
        return _blocks_swig0.nop_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(nop_sptr self, int i) -> long"""
        return _blocks_swig0.nop_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(nop_sptr self, long max_output_buffer)
        set_max_output_buffer(nop_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.nop_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(nop_sptr self, int i) -> long"""
        return _blocks_swig0.nop_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(nop_sptr self, long min_output_buffer)
        set_min_output_buffer(nop_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.nop_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(nop_sptr self, int which) -> float
        pc_input_buffers_full(nop_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.nop_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(nop_sptr self, int which) -> float
        pc_input_buffers_full_avg(nop_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.nop_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(nop_sptr self, int which) -> float
        pc_input_buffers_full_var(nop_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.nop_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(nop_sptr self, int which) -> float
        pc_output_buffers_full(nop_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.nop_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(nop_sptr self, int which) -> float
        pc_output_buffers_full_avg(nop_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.nop_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(nop_sptr self, int which) -> float
        pc_output_buffers_full_var(nop_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.nop_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(nop_sptr self) -> float"""
        return _blocks_swig0.nop_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(nop_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.nop_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(nop_sptr self)"""
        return _blocks_swig0.nop_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(nop_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.nop_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(nop_sptr self) -> int"""
        return _blocks_swig0.nop_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(nop_sptr self, int priority) -> int"""
        return _blocks_swig0.nop_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(nop_sptr self) -> std::string"""
        return _blocks_swig0.nop_sptr_name(self)


    def symbol_name(self):
        """symbol_name(nop_sptr self) -> std::string"""
        return _blocks_swig0.nop_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(nop_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.nop_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(nop_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.nop_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(nop_sptr self) -> long"""
        return _blocks_swig0.nop_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(nop_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.nop_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(nop_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.nop_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(nop_sptr self) -> std::string"""
        return _blocks_swig0.nop_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(nop_sptr self, std::string name)"""
        return _blocks_swig0.nop_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(nop_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.nop_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(nop_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.nop_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(nop_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.nop_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(nop_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.nop_sptr_message_subscribers(self, which_port)

nop_sptr_swigregister = _blocks_swig0.nop_sptr_swigregister
nop_sptr_swigregister(nop_sptr)


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

class null_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::null_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::null_sink)> self) -> null_sink_sptr
        __init__(boost::shared_ptr<(gr::blocks::null_sink)> self, null_sink p) -> null_sink_sptr
        """
        this = _blocks_swig0.new_null_sink_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(null_sink_sptr self) -> null_sink"""
        return _blocks_swig0.null_sink_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_null_sink_sptr
    __del__ = lambda self: None

    def make(self, sizeof_stream_item):
        """make(null_sink_sptr self, size_t sizeof_stream_item) -> null_sink_sptr"""
        return _blocks_swig0.null_sink_sptr_make(self, sizeof_stream_item)


    def history(self):
        """history(null_sink_sptr self) -> unsigned int"""
        return _blocks_swig0.null_sink_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(null_sink_sptr self, int which, int delay)
        declare_sample_delay(null_sink_sptr self, unsigned int delay)
        """
        return _blocks_swig0.null_sink_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(null_sink_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.null_sink_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(null_sink_sptr self) -> int"""
        return _blocks_swig0.null_sink_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(null_sink_sptr self) -> double"""
        return _blocks_swig0.null_sink_sptr_relative_rate(self)


    def start(self):
        """start(null_sink_sptr self) -> bool"""
        return _blocks_swig0.null_sink_sptr_start(self)


    def stop(self):
        """stop(null_sink_sptr self) -> bool"""
        return _blocks_swig0.null_sink_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(null_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.null_sink_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(null_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.null_sink_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(null_sink_sptr self) -> int"""
        return _blocks_swig0.null_sink_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(null_sink_sptr self, int m)"""
        return _blocks_swig0.null_sink_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(null_sink_sptr self)"""
        return _blocks_swig0.null_sink_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(null_sink_sptr self) -> bool"""
        return _blocks_swig0.null_sink_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(null_sink_sptr self, int m)"""
        return _blocks_swig0.null_sink_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(null_sink_sptr self) -> int"""
        return _blocks_swig0.null_sink_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(null_sink_sptr self, int i) -> long"""
        return _blocks_swig0.null_sink_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(null_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(null_sink_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.null_sink_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(null_sink_sptr self, int i) -> long"""
        return _blocks_swig0.null_sink_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(null_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(null_sink_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.null_sink_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(null_sink_sptr self, int which) -> float
        pc_input_buffers_full(null_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_sink_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(null_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(null_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_sink_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(null_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(null_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_sink_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(null_sink_sptr self, int which) -> float
        pc_output_buffers_full(null_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_sink_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(null_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(null_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_sink_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(null_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(null_sink_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_sink_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(null_sink_sptr self) -> float"""
        return _blocks_swig0.null_sink_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(null_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.null_sink_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(null_sink_sptr self)"""
        return _blocks_swig0.null_sink_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(null_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.null_sink_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(null_sink_sptr self) -> int"""
        return _blocks_swig0.null_sink_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(null_sink_sptr self) -> int"""
        return _blocks_swig0.null_sink_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(null_sink_sptr self, int priority) -> int"""
        return _blocks_swig0.null_sink_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(null_sink_sptr self) -> std::string"""
        return _blocks_swig0.null_sink_sptr_name(self)


    def symbol_name(self):
        """symbol_name(null_sink_sptr self) -> std::string"""
        return _blocks_swig0.null_sink_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(null_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.null_sink_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(null_sink_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.null_sink_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(null_sink_sptr self) -> long"""
        return _blocks_swig0.null_sink_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(null_sink_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.null_sink_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(null_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.null_sink_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(null_sink_sptr self) -> std::string"""
        return _blocks_swig0.null_sink_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(null_sink_sptr self, std::string name)"""
        return _blocks_swig0.null_sink_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(null_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.null_sink_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(null_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.null_sink_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(null_sink_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.null_sink_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(null_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.null_sink_sptr_message_subscribers(self, which_port)

null_sink_sptr_swigregister = _blocks_swig0.null_sink_sptr_swigregister
null_sink_sptr_swigregister(null_sink_sptr)


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

class null_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::null_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::null_source)> self) -> null_source_sptr
        __init__(boost::shared_ptr<(gr::blocks::null_source)> self, null_source p) -> null_source_sptr
        """
        this = _blocks_swig0.new_null_source_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(null_source_sptr self) -> null_source"""
        return _blocks_swig0.null_source_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_null_source_sptr
    __del__ = lambda self: None

    def make(self, sizeof_stream_item):
        """make(null_source_sptr self, size_t sizeof_stream_item) -> null_source_sptr"""
        return _blocks_swig0.null_source_sptr_make(self, sizeof_stream_item)


    def history(self):
        """history(null_source_sptr self) -> unsigned int"""
        return _blocks_swig0.null_source_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(null_source_sptr self, int which, int delay)
        declare_sample_delay(null_source_sptr self, unsigned int delay)
        """
        return _blocks_swig0.null_source_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(null_source_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.null_source_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(null_source_sptr self) -> int"""
        return _blocks_swig0.null_source_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(null_source_sptr self) -> double"""
        return _blocks_swig0.null_source_sptr_relative_rate(self)


    def start(self):
        """start(null_source_sptr self) -> bool"""
        return _blocks_swig0.null_source_sptr_start(self)


    def stop(self):
        """stop(null_source_sptr self) -> bool"""
        return _blocks_swig0.null_source_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(null_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.null_source_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(null_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.null_source_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(null_source_sptr self) -> int"""
        return _blocks_swig0.null_source_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(null_source_sptr self, int m)"""
        return _blocks_swig0.null_source_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(null_source_sptr self)"""
        return _blocks_swig0.null_source_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(null_source_sptr self) -> bool"""
        return _blocks_swig0.null_source_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(null_source_sptr self, int m)"""
        return _blocks_swig0.null_source_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(null_source_sptr self) -> int"""
        return _blocks_swig0.null_source_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(null_source_sptr self, int i) -> long"""
        return _blocks_swig0.null_source_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(null_source_sptr self, long max_output_buffer)
        set_max_output_buffer(null_source_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.null_source_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(null_source_sptr self, int i) -> long"""
        return _blocks_swig0.null_source_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(null_source_sptr self, long min_output_buffer)
        set_min_output_buffer(null_source_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.null_source_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(null_source_sptr self, int which) -> float
        pc_input_buffers_full(null_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_source_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(null_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(null_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_source_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(null_source_sptr self, int which) -> float
        pc_input_buffers_full_var(null_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_source_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(null_source_sptr self, int which) -> float
        pc_output_buffers_full(null_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_source_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(null_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(null_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_source_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(null_source_sptr self, int which) -> float
        pc_output_buffers_full_var(null_source_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.null_source_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(null_source_sptr self) -> float"""
        return _blocks_swig0.null_source_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(null_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.null_source_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(null_source_sptr self)"""
        return _blocks_swig0.null_source_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(null_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.null_source_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(null_source_sptr self) -> int"""
        return _blocks_swig0.null_source_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(null_source_sptr self) -> int"""
        return _blocks_swig0.null_source_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(null_source_sptr self, int priority) -> int"""
        return _blocks_swig0.null_source_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(null_source_sptr self) -> std::string"""
        return _blocks_swig0.null_source_sptr_name(self)


    def symbol_name(self):
        """symbol_name(null_source_sptr self) -> std::string"""
        return _blocks_swig0.null_source_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(null_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.null_source_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(null_source_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.null_source_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(null_source_sptr self) -> long"""
        return _blocks_swig0.null_source_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(null_source_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.null_source_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(null_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.null_source_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(null_source_sptr self) -> std::string"""
        return _blocks_swig0.null_source_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(null_source_sptr self, std::string name)"""
        return _blocks_swig0.null_source_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(null_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.null_source_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(null_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.null_source_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(null_source_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.null_source_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(null_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.null_source_sptr_message_subscribers(self, which_port)

null_source_sptr_swigregister = _blocks_swig0.null_source_sptr_swigregister
null_source_sptr_swigregister(null_source_sptr)


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

class ctrlport_probe_c(object):
    """Proxy of C++ gr::blocks::ctrlport_probe_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(id, desc):
        """make(std::string const & id, std::string const & desc) -> ctrlport_probe_c_sptr"""
        return _blocks_swig0.ctrlport_probe_c_make(id, desc)

    make = staticmethod(make)

    def get(self):
        """get(ctrlport_probe_c self) -> pmt_vector_cfloat"""
        return _blocks_swig0.ctrlport_probe_c_get(self)

    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe_c
    __del__ = lambda self: None
ctrlport_probe_c_swigregister = _blocks_swig0.ctrlport_probe_c_swigregister
ctrlport_probe_c_swigregister(ctrlport_probe_c)

def ctrlport_probe_c_make(id, desc):
    """ctrlport_probe_c_make(std::string const & id, std::string const & desc) -> ctrlport_probe_c_sptr"""
    return _blocks_swig0.ctrlport_probe_c_make(id, desc)

class ctrlport_probe2_c(object):
    """Proxy of C++ gr::blocks::ctrlport_probe2_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(id, desc, len, disp_mask):
        """make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_c_sptr"""
        return _blocks_swig0.ctrlport_probe2_c_make(id, desc, len, disp_mask)

    make = staticmethod(make)

    def get(self):
        """get(ctrlport_probe2_c self) -> pmt_vector_cfloat"""
        return _blocks_swig0.ctrlport_probe2_c_get(self)


    def set_length(self, len):
        """set_length(ctrlport_probe2_c self, int len)"""
        return _blocks_swig0.ctrlport_probe2_c_set_length(self, len)


    def length(self):
        """length(ctrlport_probe2_c self) -> int"""
        return _blocks_swig0.ctrlport_probe2_c_length(self)

    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_c
    __del__ = lambda self: None
ctrlport_probe2_c_swigregister = _blocks_swig0.ctrlport_probe2_c_swigregister
ctrlport_probe2_c_swigregister(ctrlport_probe2_c)

def ctrlport_probe2_c_make(id, desc, len, disp_mask):
    """ctrlport_probe2_c_make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_c_sptr"""
    return _blocks_swig0.ctrlport_probe2_c_make(id, desc, len, disp_mask)

class ctrlport_probe2_f(object):
    """Proxy of C++ gr::blocks::ctrlport_probe2_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(id, desc, len, disp_mask):
        """make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_f_sptr"""
        return _blocks_swig0.ctrlport_probe2_f_make(id, desc, len, disp_mask)

    make = staticmethod(make)

    def get(self):
        """get(ctrlport_probe2_f self) -> pmt_vector_float"""
        return _blocks_swig0.ctrlport_probe2_f_get(self)


    def set_length(self, len):
        """set_length(ctrlport_probe2_f self, int len)"""
        return _blocks_swig0.ctrlport_probe2_f_set_length(self, len)


    def length(self):
        """length(ctrlport_probe2_f self) -> int"""
        return _blocks_swig0.ctrlport_probe2_f_length(self)

    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_f
    __del__ = lambda self: None
ctrlport_probe2_f_swigregister = _blocks_swig0.ctrlport_probe2_f_swigregister
ctrlport_probe2_f_swigregister(ctrlport_probe2_f)

def ctrlport_probe2_f_make(id, desc, len, disp_mask):
    """ctrlport_probe2_f_make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_f_sptr"""
    return _blocks_swig0.ctrlport_probe2_f_make(id, desc, len, disp_mask)

class ctrlport_probe2_s(object):
    """Proxy of C++ gr::blocks::ctrlport_probe2_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(id, desc, len, disp_mask):
        """make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_s_sptr"""
        return _blocks_swig0.ctrlport_probe2_s_make(id, desc, len, disp_mask)

    make = staticmethod(make)

    def get(self):
        """get(ctrlport_probe2_s self) -> std::vector< short,std::allocator< short > >"""
        return _blocks_swig0.ctrlport_probe2_s_get(self)


    def set_length(self, len):
        """set_length(ctrlport_probe2_s self, int len)"""
        return _blocks_swig0.ctrlport_probe2_s_set_length(self, len)


    def length(self):
        """length(ctrlport_probe2_s self) -> int"""
        return _blocks_swig0.ctrlport_probe2_s_length(self)

    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_s
    __del__ = lambda self: None
ctrlport_probe2_s_swigregister = _blocks_swig0.ctrlport_probe2_s_swigregister
ctrlport_probe2_s_swigregister(ctrlport_probe2_s)

def ctrlport_probe2_s_make(id, desc, len, disp_mask):
    """ctrlport_probe2_s_make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_s_sptr"""
    return _blocks_swig0.ctrlport_probe2_s_make(id, desc, len, disp_mask)

class ctrlport_probe2_i(object):
    """Proxy of C++ gr::blocks::ctrlport_probe2_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(id, desc, len, disp_mask):
        """make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_i_sptr"""
        return _blocks_swig0.ctrlport_probe2_i_make(id, desc, len, disp_mask)

    make = staticmethod(make)

    def get(self):
        """get(ctrlport_probe2_i self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.ctrlport_probe2_i_get(self)


    def set_length(self, len):
        """set_length(ctrlport_probe2_i self, int len)"""
        return _blocks_swig0.ctrlport_probe2_i_set_length(self, len)


    def length(self):
        """length(ctrlport_probe2_i self) -> int"""
        return _blocks_swig0.ctrlport_probe2_i_length(self)

    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_i
    __del__ = lambda self: None
ctrlport_probe2_i_swigregister = _blocks_swig0.ctrlport_probe2_i_swigregister
ctrlport_probe2_i_swigregister(ctrlport_probe2_i)

def ctrlport_probe2_i_make(id, desc, len, disp_mask):
    """ctrlport_probe2_i_make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_i_sptr"""
    return _blocks_swig0.ctrlport_probe2_i_make(id, desc, len, disp_mask)

class ctrlport_probe2_b(object):
    """Proxy of C++ gr::blocks::ctrlport_probe2_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(id, desc, len, disp_mask):
        """make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_b_sptr"""
        return _blocks_swig0.ctrlport_probe2_b_make(id, desc, len, disp_mask)

    make = staticmethod(make)

    def get(self):
        """get(ctrlport_probe2_b self) -> std::vector< signed char,std::allocator< signed char > >"""
        return _blocks_swig0.ctrlport_probe2_b_get(self)


    def set_length(self, len):
        """set_length(ctrlport_probe2_b self, int len)"""
        return _blocks_swig0.ctrlport_probe2_b_set_length(self, len)


    def length(self):
        """length(ctrlport_probe2_b self) -> int"""
        return _blocks_swig0.ctrlport_probe2_b_length(self)

    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_b
    __del__ = lambda self: None
ctrlport_probe2_b_swigregister = _blocks_swig0.ctrlport_probe2_b_swigregister
ctrlport_probe2_b_swigregister(ctrlport_probe2_b)

def ctrlport_probe2_b_make(id, desc, len, disp_mask):
    """ctrlport_probe2_b_make(std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_b_sptr"""
    return _blocks_swig0.ctrlport_probe2_b_make(id, desc, len, disp_mask)

class ctrlport_probe_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::ctrlport_probe_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::ctrlport_probe_c)> self) -> ctrlport_probe_c_sptr
        __init__(boost::shared_ptr<(gr::blocks::ctrlport_probe_c)> self, ctrlport_probe_c p) -> ctrlport_probe_c_sptr
        """
        this = _blocks_swig0.new_ctrlport_probe_c_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(ctrlport_probe_c_sptr self) -> ctrlport_probe_c"""
        return _blocks_swig0.ctrlport_probe_c_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe_c_sptr
    __del__ = lambda self: None

    def make(self, id, desc):
        """make(ctrlport_probe_c_sptr self, std::string const & id, std::string const & desc) -> ctrlport_probe_c_sptr"""
        return _blocks_swig0.ctrlport_probe_c_sptr_make(self, id, desc)


    def get(self):
        """get(ctrlport_probe_c_sptr self) -> pmt_vector_cfloat"""
        return _blocks_swig0.ctrlport_probe_c_sptr_get(self)


    def history(self):
        """history(ctrlport_probe_c_sptr self) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe_c_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(ctrlport_probe_c_sptr self, int which, int delay)
        declare_sample_delay(ctrlport_probe_c_sptr self, unsigned int delay)
        """
        return _blocks_swig0.ctrlport_probe_c_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(ctrlport_probe_c_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe_c_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(ctrlport_probe_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe_c_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(ctrlport_probe_c_sptr self) -> double"""
        return _blocks_swig0.ctrlport_probe_c_sptr_relative_rate(self)


    def start(self):
        """start(ctrlport_probe_c_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe_c_sptr_start(self)


    def stop(self):
        """stop(ctrlport_probe_c_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe_c_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(ctrlport_probe_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe_c_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(ctrlport_probe_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe_c_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(ctrlport_probe_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe_c_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(ctrlport_probe_c_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe_c_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(ctrlport_probe_c_sptr self)"""
        return _blocks_swig0.ctrlport_probe_c_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(ctrlport_probe_c_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe_c_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(ctrlport_probe_c_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe_c_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(ctrlport_probe_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe_c_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(ctrlport_probe_c_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe_c_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(ctrlport_probe_c_sptr self, long max_output_buffer)
        set_max_output_buffer(ctrlport_probe_c_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe_c_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(ctrlport_probe_c_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe_c_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(ctrlport_probe_c_sptr self, long min_output_buffer)
        set_min_output_buffer(ctrlport_probe_c_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe_c_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(ctrlport_probe_c_sptr self, int which) -> float
        pc_input_buffers_full(ctrlport_probe_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(ctrlport_probe_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(ctrlport_probe_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(ctrlport_probe_c_sptr self, int which) -> float
        pc_input_buffers_full_var(ctrlport_probe_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(ctrlport_probe_c_sptr self, int which) -> float
        pc_output_buffers_full(ctrlport_probe_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(ctrlport_probe_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(ctrlport_probe_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(ctrlport_probe_c_sptr self, int which) -> float
        pc_output_buffers_full_var(ctrlport_probe_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(ctrlport_probe_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe_c_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(ctrlport_probe_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.ctrlport_probe_c_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(ctrlport_probe_c_sptr self)"""
        return _blocks_swig0.ctrlport_probe_c_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(ctrlport_probe_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.ctrlport_probe_c_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(ctrlport_probe_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe_c_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(ctrlport_probe_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe_c_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(ctrlport_probe_c_sptr self, int priority) -> int"""
        return _blocks_swig0.ctrlport_probe_c_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(ctrlport_probe_c_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe_c_sptr_name(self)


    def symbol_name(self):
        """symbol_name(ctrlport_probe_c_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe_c_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(ctrlport_probe_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe_c_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(ctrlport_probe_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe_c_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(ctrlport_probe_c_sptr self) -> long"""
        return _blocks_swig0.ctrlport_probe_c_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(ctrlport_probe_c_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.ctrlport_probe_c_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(ctrlport_probe_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.ctrlport_probe_c_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(ctrlport_probe_c_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe_c_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(ctrlport_probe_c_sptr self, std::string name)"""
        return _blocks_swig0.ctrlport_probe_c_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(ctrlport_probe_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.ctrlport_probe_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(ctrlport_probe_c_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.ctrlport_probe_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(ctrlport_probe_c_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.ctrlport_probe_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(ctrlport_probe_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.ctrlport_probe_c_sptr_message_subscribers(self, which_port)

ctrlport_probe_c_sptr_swigregister = _blocks_swig0.ctrlport_probe_c_sptr_swigregister
ctrlport_probe_c_sptr_swigregister(ctrlport_probe_c_sptr)


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

class ctrlport_probe2_c_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::ctrlport_probe2_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::ctrlport_probe2_c)> self) -> ctrlport_probe2_c_sptr
        __init__(boost::shared_ptr<(gr::blocks::ctrlport_probe2_c)> self, ctrlport_probe2_c p) -> ctrlport_probe2_c_sptr
        """
        this = _blocks_swig0.new_ctrlport_probe2_c_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(ctrlport_probe2_c_sptr self) -> ctrlport_probe2_c"""
        return _blocks_swig0.ctrlport_probe2_c_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_c_sptr
    __del__ = lambda self: None

    def make(self, id, desc, len, disp_mask):
        """make(ctrlport_probe2_c_sptr self, std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_c_sptr"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_make(self, id, desc, len, disp_mask)


    def get(self):
        """get(ctrlport_probe2_c_sptr self) -> pmt_vector_cfloat"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_get(self)


    def set_length(self, len):
        """set_length(ctrlport_probe2_c_sptr self, int len)"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_set_length(self, len)


    def length(self):
        """length(ctrlport_probe2_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_length(self)


    def history(self):
        """history(ctrlport_probe2_c_sptr self) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(ctrlport_probe2_c_sptr self, int which, int delay)
        declare_sample_delay(ctrlport_probe2_c_sptr self, unsigned int delay)
        """
        return _blocks_swig0.ctrlport_probe2_c_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(ctrlport_probe2_c_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(ctrlport_probe2_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(ctrlport_probe2_c_sptr self) -> double"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_relative_rate(self)


    def start(self):
        """start(ctrlport_probe2_c_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_start(self)


    def stop(self):
        """stop(ctrlport_probe2_c_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(ctrlport_probe2_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(ctrlport_probe2_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(ctrlport_probe2_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(ctrlport_probe2_c_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(ctrlport_probe2_c_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(ctrlport_probe2_c_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(ctrlport_probe2_c_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(ctrlport_probe2_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(ctrlport_probe2_c_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(ctrlport_probe2_c_sptr self, long max_output_buffer)
        set_max_output_buffer(ctrlport_probe2_c_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_c_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(ctrlport_probe2_c_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(ctrlport_probe2_c_sptr self, long min_output_buffer)
        set_min_output_buffer(ctrlport_probe2_c_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_c_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(ctrlport_probe2_c_sptr self, int which) -> float
        pc_input_buffers_full(ctrlport_probe2_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(ctrlport_probe2_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(ctrlport_probe2_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(ctrlport_probe2_c_sptr self, int which) -> float
        pc_input_buffers_full_var(ctrlport_probe2_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(ctrlport_probe2_c_sptr self, int which) -> float
        pc_output_buffers_full(ctrlport_probe2_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(ctrlport_probe2_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(ctrlport_probe2_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(ctrlport_probe2_c_sptr self, int which) -> float
        pc_output_buffers_full_var(ctrlport_probe2_c_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(ctrlport_probe2_c_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(ctrlport_probe2_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(ctrlport_probe2_c_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(ctrlport_probe2_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(ctrlport_probe2_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(ctrlport_probe2_c_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(ctrlport_probe2_c_sptr self, int priority) -> int"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(ctrlport_probe2_c_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_name(self)


    def symbol_name(self):
        """symbol_name(ctrlport_probe2_c_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(ctrlport_probe2_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(ctrlport_probe2_c_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(ctrlport_probe2_c_sptr self) -> long"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(ctrlport_probe2_c_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(ctrlport_probe2_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(ctrlport_probe2_c_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(ctrlport_probe2_c_sptr self, std::string name)"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(ctrlport_probe2_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.ctrlport_probe2_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(ctrlport_probe2_c_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(ctrlport_probe2_c_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(ctrlport_probe2_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.ctrlport_probe2_c_sptr_message_subscribers(self, which_port)

ctrlport_probe2_c_sptr_swigregister = _blocks_swig0.ctrlport_probe2_c_sptr_swigregister
ctrlport_probe2_c_sptr_swigregister(ctrlport_probe2_c_sptr)


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

class ctrlport_probe2_f_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::ctrlport_probe2_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::ctrlport_probe2_f)> self) -> ctrlport_probe2_f_sptr
        __init__(boost::shared_ptr<(gr::blocks::ctrlport_probe2_f)> self, ctrlport_probe2_f p) -> ctrlport_probe2_f_sptr
        """
        this = _blocks_swig0.new_ctrlport_probe2_f_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(ctrlport_probe2_f_sptr self) -> ctrlport_probe2_f"""
        return _blocks_swig0.ctrlport_probe2_f_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_f_sptr
    __del__ = lambda self: None

    def make(self, id, desc, len, disp_mask):
        """make(ctrlport_probe2_f_sptr self, std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_f_sptr"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_make(self, id, desc, len, disp_mask)


    def get(self):
        """get(ctrlport_probe2_f_sptr self) -> pmt_vector_float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_get(self)


    def set_length(self, len):
        """set_length(ctrlport_probe2_f_sptr self, int len)"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_set_length(self, len)


    def length(self):
        """length(ctrlport_probe2_f_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_length(self)


    def history(self):
        """history(ctrlport_probe2_f_sptr self) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(ctrlport_probe2_f_sptr self, int which, int delay)
        declare_sample_delay(ctrlport_probe2_f_sptr self, unsigned int delay)
        """
        return _blocks_swig0.ctrlport_probe2_f_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(ctrlport_probe2_f_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(ctrlport_probe2_f_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(ctrlport_probe2_f_sptr self) -> double"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_relative_rate(self)


    def start(self):
        """start(ctrlport_probe2_f_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_start(self)


    def stop(self):
        """stop(ctrlport_probe2_f_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(ctrlport_probe2_f_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(ctrlport_probe2_f_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(ctrlport_probe2_f_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(ctrlport_probe2_f_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(ctrlport_probe2_f_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(ctrlport_probe2_f_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(ctrlport_probe2_f_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(ctrlport_probe2_f_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(ctrlport_probe2_f_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(ctrlport_probe2_f_sptr self, long max_output_buffer)
        set_max_output_buffer(ctrlport_probe2_f_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_f_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(ctrlport_probe2_f_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(ctrlport_probe2_f_sptr self, long min_output_buffer)
        set_min_output_buffer(ctrlport_probe2_f_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_f_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(ctrlport_probe2_f_sptr self, int which) -> float
        pc_input_buffers_full(ctrlport_probe2_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(ctrlport_probe2_f_sptr self, int which) -> float
        pc_input_buffers_full_avg(ctrlport_probe2_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(ctrlport_probe2_f_sptr self, int which) -> float
        pc_input_buffers_full_var(ctrlport_probe2_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(ctrlport_probe2_f_sptr self, int which) -> float
        pc_output_buffers_full(ctrlport_probe2_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(ctrlport_probe2_f_sptr self, int which) -> float
        pc_output_buffers_full_avg(ctrlport_probe2_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(ctrlport_probe2_f_sptr self, int which) -> float
        pc_output_buffers_full_var(ctrlport_probe2_f_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(ctrlport_probe2_f_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(ctrlport_probe2_f_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(ctrlport_probe2_f_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(ctrlport_probe2_f_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(ctrlport_probe2_f_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(ctrlport_probe2_f_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(ctrlport_probe2_f_sptr self, int priority) -> int"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(ctrlport_probe2_f_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_name(self)


    def symbol_name(self):
        """symbol_name(ctrlport_probe2_f_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(ctrlport_probe2_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(ctrlport_probe2_f_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(ctrlport_probe2_f_sptr self) -> long"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(ctrlport_probe2_f_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(ctrlport_probe2_f_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(ctrlport_probe2_f_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(ctrlport_probe2_f_sptr self, std::string name)"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(ctrlport_probe2_f_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.ctrlport_probe2_f_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(ctrlport_probe2_f_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(ctrlport_probe2_f_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(ctrlport_probe2_f_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.ctrlport_probe2_f_sptr_message_subscribers(self, which_port)

ctrlport_probe2_f_sptr_swigregister = _blocks_swig0.ctrlport_probe2_f_sptr_swigregister
ctrlport_probe2_f_sptr_swigregister(ctrlport_probe2_f_sptr)


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

class ctrlport_probe2_s_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::ctrlport_probe2_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::ctrlport_probe2_s)> self) -> ctrlport_probe2_s_sptr
        __init__(boost::shared_ptr<(gr::blocks::ctrlport_probe2_s)> self, ctrlport_probe2_s p) -> ctrlport_probe2_s_sptr
        """
        this = _blocks_swig0.new_ctrlport_probe2_s_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(ctrlport_probe2_s_sptr self) -> ctrlport_probe2_s"""
        return _blocks_swig0.ctrlport_probe2_s_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_s_sptr
    __del__ = lambda self: None

    def make(self, id, desc, len, disp_mask):
        """make(ctrlport_probe2_s_sptr self, std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_s_sptr"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_make(self, id, desc, len, disp_mask)


    def get(self):
        """get(ctrlport_probe2_s_sptr self) -> std::vector< short,std::allocator< short > >"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_get(self)


    def set_length(self, len):
        """set_length(ctrlport_probe2_s_sptr self, int len)"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_set_length(self, len)


    def length(self):
        """length(ctrlport_probe2_s_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_length(self)


    def history(self):
        """history(ctrlport_probe2_s_sptr self) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(ctrlport_probe2_s_sptr self, int which, int delay)
        declare_sample_delay(ctrlport_probe2_s_sptr self, unsigned int delay)
        """
        return _blocks_swig0.ctrlport_probe2_s_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(ctrlport_probe2_s_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(ctrlport_probe2_s_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(ctrlport_probe2_s_sptr self) -> double"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_relative_rate(self)


    def start(self):
        """start(ctrlport_probe2_s_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_start(self)


    def stop(self):
        """stop(ctrlport_probe2_s_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(ctrlport_probe2_s_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(ctrlport_probe2_s_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(ctrlport_probe2_s_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(ctrlport_probe2_s_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(ctrlport_probe2_s_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(ctrlport_probe2_s_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(ctrlport_probe2_s_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(ctrlport_probe2_s_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(ctrlport_probe2_s_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(ctrlport_probe2_s_sptr self, long max_output_buffer)
        set_max_output_buffer(ctrlport_probe2_s_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_s_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(ctrlport_probe2_s_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(ctrlport_probe2_s_sptr self, long min_output_buffer)
        set_min_output_buffer(ctrlport_probe2_s_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_s_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(ctrlport_probe2_s_sptr self, int which) -> float
        pc_input_buffers_full(ctrlport_probe2_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(ctrlport_probe2_s_sptr self, int which) -> float
        pc_input_buffers_full_avg(ctrlport_probe2_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(ctrlport_probe2_s_sptr self, int which) -> float
        pc_input_buffers_full_var(ctrlport_probe2_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(ctrlport_probe2_s_sptr self, int which) -> float
        pc_output_buffers_full(ctrlport_probe2_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(ctrlport_probe2_s_sptr self, int which) -> float
        pc_output_buffers_full_avg(ctrlport_probe2_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(ctrlport_probe2_s_sptr self, int which) -> float
        pc_output_buffers_full_var(ctrlport_probe2_s_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(ctrlport_probe2_s_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(ctrlport_probe2_s_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(ctrlport_probe2_s_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(ctrlport_probe2_s_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(ctrlport_probe2_s_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(ctrlport_probe2_s_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(ctrlport_probe2_s_sptr self, int priority) -> int"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(ctrlport_probe2_s_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_name(self)


    def symbol_name(self):
        """symbol_name(ctrlport_probe2_s_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(ctrlport_probe2_s_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(ctrlport_probe2_s_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(ctrlport_probe2_s_sptr self) -> long"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(ctrlport_probe2_s_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(ctrlport_probe2_s_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(ctrlport_probe2_s_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(ctrlport_probe2_s_sptr self, std::string name)"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(ctrlport_probe2_s_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.ctrlport_probe2_s_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(ctrlport_probe2_s_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(ctrlport_probe2_s_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(ctrlport_probe2_s_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.ctrlport_probe2_s_sptr_message_subscribers(self, which_port)

ctrlport_probe2_s_sptr_swigregister = _blocks_swig0.ctrlport_probe2_s_sptr_swigregister
ctrlport_probe2_s_sptr_swigregister(ctrlport_probe2_s_sptr)


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

class ctrlport_probe2_i_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::ctrlport_probe2_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::ctrlport_probe2_i)> self) -> ctrlport_probe2_i_sptr
        __init__(boost::shared_ptr<(gr::blocks::ctrlport_probe2_i)> self, ctrlport_probe2_i p) -> ctrlport_probe2_i_sptr
        """
        this = _blocks_swig0.new_ctrlport_probe2_i_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(ctrlport_probe2_i_sptr self) -> ctrlport_probe2_i"""
        return _blocks_swig0.ctrlport_probe2_i_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_i_sptr
    __del__ = lambda self: None

    def make(self, id, desc, len, disp_mask):
        """make(ctrlport_probe2_i_sptr self, std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_i_sptr"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_make(self, id, desc, len, disp_mask)


    def get(self):
        """get(ctrlport_probe2_i_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_get(self)


    def set_length(self, len):
        """set_length(ctrlport_probe2_i_sptr self, int len)"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_set_length(self, len)


    def length(self):
        """length(ctrlport_probe2_i_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_length(self)


    def history(self):
        """history(ctrlport_probe2_i_sptr self) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(ctrlport_probe2_i_sptr self, int which, int delay)
        declare_sample_delay(ctrlport_probe2_i_sptr self, unsigned int delay)
        """
        return _blocks_swig0.ctrlport_probe2_i_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(ctrlport_probe2_i_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(ctrlport_probe2_i_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(ctrlport_probe2_i_sptr self) -> double"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_relative_rate(self)


    def start(self):
        """start(ctrlport_probe2_i_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_start(self)


    def stop(self):
        """stop(ctrlport_probe2_i_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(ctrlport_probe2_i_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(ctrlport_probe2_i_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(ctrlport_probe2_i_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(ctrlport_probe2_i_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(ctrlport_probe2_i_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(ctrlport_probe2_i_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(ctrlport_probe2_i_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(ctrlport_probe2_i_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(ctrlport_probe2_i_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(ctrlport_probe2_i_sptr self, long max_output_buffer)
        set_max_output_buffer(ctrlport_probe2_i_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_i_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(ctrlport_probe2_i_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(ctrlport_probe2_i_sptr self, long min_output_buffer)
        set_min_output_buffer(ctrlport_probe2_i_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_i_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(ctrlport_probe2_i_sptr self, int which) -> float
        pc_input_buffers_full(ctrlport_probe2_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(ctrlport_probe2_i_sptr self, int which) -> float
        pc_input_buffers_full_avg(ctrlport_probe2_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(ctrlport_probe2_i_sptr self, int which) -> float
        pc_input_buffers_full_var(ctrlport_probe2_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(ctrlport_probe2_i_sptr self, int which) -> float
        pc_output_buffers_full(ctrlport_probe2_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(ctrlport_probe2_i_sptr self, int which) -> float
        pc_output_buffers_full_avg(ctrlport_probe2_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(ctrlport_probe2_i_sptr self, int which) -> float
        pc_output_buffers_full_var(ctrlport_probe2_i_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(ctrlport_probe2_i_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(ctrlport_probe2_i_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(ctrlport_probe2_i_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(ctrlport_probe2_i_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(ctrlport_probe2_i_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(ctrlport_probe2_i_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(ctrlport_probe2_i_sptr self, int priority) -> int"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(ctrlport_probe2_i_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_name(self)


    def symbol_name(self):
        """symbol_name(ctrlport_probe2_i_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(ctrlport_probe2_i_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(ctrlport_probe2_i_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(ctrlport_probe2_i_sptr self) -> long"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(ctrlport_probe2_i_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(ctrlport_probe2_i_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(ctrlport_probe2_i_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(ctrlport_probe2_i_sptr self, std::string name)"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(ctrlport_probe2_i_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.ctrlport_probe2_i_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(ctrlport_probe2_i_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(ctrlport_probe2_i_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(ctrlport_probe2_i_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.ctrlport_probe2_i_sptr_message_subscribers(self, which_port)

ctrlport_probe2_i_sptr_swigregister = _blocks_swig0.ctrlport_probe2_i_sptr_swigregister
ctrlport_probe2_i_sptr_swigregister(ctrlport_probe2_i_sptr)


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

class ctrlport_probe2_b_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::blocks::ctrlport_probe2_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::ctrlport_probe2_b)> self) -> ctrlport_probe2_b_sptr
        __init__(boost::shared_ptr<(gr::blocks::ctrlport_probe2_b)> self, ctrlport_probe2_b p) -> ctrlport_probe2_b_sptr
        """
        this = _blocks_swig0.new_ctrlport_probe2_b_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(ctrlport_probe2_b_sptr self) -> ctrlport_probe2_b"""
        return _blocks_swig0.ctrlport_probe2_b_sptr___deref__(self)

    __swig_destroy__ = _blocks_swig0.delete_ctrlport_probe2_b_sptr
    __del__ = lambda self: None

    def make(self, id, desc, len, disp_mask):
        """make(ctrlport_probe2_b_sptr self, std::string const & id, std::string const & desc, int len, unsigned int disp_mask) -> ctrlport_probe2_b_sptr"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_make(self, id, desc, len, disp_mask)


    def get(self):
        """get(ctrlport_probe2_b_sptr self) -> std::vector< signed char,std::allocator< signed char > >"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_get(self)


    def set_length(self, len):
        """set_length(ctrlport_probe2_b_sptr self, int len)"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_set_length(self, len)


    def length(self):
        """length(ctrlport_probe2_b_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_length(self)


    def history(self):
        """history(ctrlport_probe2_b_sptr self) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(ctrlport_probe2_b_sptr self, int which, int delay)
        declare_sample_delay(ctrlport_probe2_b_sptr self, unsigned int delay)
        """
        return _blocks_swig0.ctrlport_probe2_b_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(ctrlport_probe2_b_sptr self, int which) -> unsigned int"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(ctrlport_probe2_b_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(ctrlport_probe2_b_sptr self) -> double"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_relative_rate(self)


    def start(self):
        """start(ctrlport_probe2_b_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_start(self)


    def stop(self):
        """stop(ctrlport_probe2_b_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(ctrlport_probe2_b_sptr self, unsigned int which_input) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(ctrlport_probe2_b_sptr self, unsigned int which_output) -> uint64_t"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(ctrlport_probe2_b_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(ctrlport_probe2_b_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(ctrlport_probe2_b_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(ctrlport_probe2_b_sptr self) -> bool"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(ctrlport_probe2_b_sptr self, int m)"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(ctrlport_probe2_b_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(ctrlport_probe2_b_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(ctrlport_probe2_b_sptr self, long max_output_buffer)
        set_max_output_buffer(ctrlport_probe2_b_sptr self, int port, long max_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_b_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(ctrlport_probe2_b_sptr self, int i) -> long"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(ctrlport_probe2_b_sptr self, long min_output_buffer)
        set_min_output_buffer(ctrlport_probe2_b_sptr self, int port, long min_output_buffer)
        """
        return _blocks_swig0.ctrlport_probe2_b_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(ctrlport_probe2_b_sptr self, int which) -> float
        pc_input_buffers_full(ctrlport_probe2_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(ctrlport_probe2_b_sptr self, int which) -> float
        pc_input_buffers_full_avg(ctrlport_probe2_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(ctrlport_probe2_b_sptr self, int which) -> float
        pc_input_buffers_full_var(ctrlport_probe2_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(ctrlport_probe2_b_sptr self, int which) -> float
        pc_output_buffers_full(ctrlport_probe2_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(ctrlport_probe2_b_sptr self, int which) -> float
        pc_output_buffers_full_avg(ctrlport_probe2_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(ctrlport_probe2_b_sptr self, int which) -> float
        pc_output_buffers_full_var(ctrlport_probe2_b_sptr self) -> pmt_vector_float
        """
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(ctrlport_probe2_b_sptr self) -> float"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(ctrlport_probe2_b_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(ctrlport_probe2_b_sptr self)"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(ctrlport_probe2_b_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(ctrlport_probe2_b_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(ctrlport_probe2_b_sptr self) -> int"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(ctrlport_probe2_b_sptr self, int priority) -> int"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(ctrlport_probe2_b_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_name(self)


    def symbol_name(self):
        """symbol_name(ctrlport_probe2_b_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(ctrlport_probe2_b_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(ctrlport_probe2_b_sptr self) -> io_signature_sptr"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(ctrlport_probe2_b_sptr self) -> long"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(ctrlport_probe2_b_sptr self) -> basic_block_sptr"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(ctrlport_probe2_b_sptr self, int ninputs, int noutputs) -> bool"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(ctrlport_probe2_b_sptr self) -> std::string"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(ctrlport_probe2_b_sptr self, std::string name)"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(ctrlport_probe2_b_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _blocks_swig0.ctrlport_probe2_b_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(ctrlport_probe2_b_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(ctrlport_probe2_b_sptr self) -> swig_int_ptr"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(ctrlport_probe2_b_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _blocks_swig0.ctrlport_probe2_b_sptr_message_subscribers(self, which_port)

ctrlport_probe2_b_sptr_swigregister = _blocks_swig0.ctrlport_probe2_b_sptr_swigregister
ctrlport_probe2_b_sptr_swigregister(ctrlport_probe2_b_sptr)


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



