# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# 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 as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_fec_swig')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_fec_swig')
    _fec_swig = swig_import_helper()
    del swig_import_helper
elif _swig_python_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('_fec_swig', [dirname(__file__)])
        except ImportError:
            import _fec_swig
            return _fec_swig
        try:
            _mod = imp.load_module('_fec_swig', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _fec_swig = swig_import_helper()
    del swig_import_helper
else:
    import _fec_swig
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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


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 _fec_swig.high_res_timer_now()

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

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

def high_res_timer_epoch():
    """high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _fec_swig.high_res_timer_epoch()
CC_STREAMING = _fec_swig.CC_STREAMING
CC_TERMINATED = _fec_swig.CC_TERMINATED
CC_TRUNCATED = _fec_swig.CC_TRUNCATED
CC_TAILBITING = _fec_swig.CC_TAILBITING
class decision_t(object):
    """Proxy of C++ decision_t class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    t = _swig_property(_fec_swig.decision_t_t_get, _fec_swig.decision_t_t_set)
    w = _swig_property(_fec_swig.decision_t_w_get, _fec_swig.decision_t_w_set)
    s = _swig_property(_fec_swig.decision_t_s_get, _fec_swig.decision_t_s_set)
    c = _swig_property(_fec_swig.decision_t_c_get, _fec_swig.decision_t_c_set)

    def __init__(self):
        """__init__(decision_t self) -> decision_t"""
        this = _fec_swig.new_decision_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fec_swig.delete_decision_t
    __del__ = lambda self: None
decision_t_swigregister = _fec_swig.decision_t_swigregister
decision_t_swigregister(decision_t)

class metric_t(object):
    """Proxy of C++ metric_t class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    t = _swig_property(_fec_swig.metric_t_t_get, _fec_swig.metric_t_t_set)

    def __init__(self):
        """__init__(metric_t self) -> metric_t"""
        this = _fec_swig.new_metric_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fec_swig.delete_metric_t
    __del__ = lambda self: None
metric_t_swigregister = _fec_swig.metric_t_swigregister
metric_t_swigregister(metric_t)

class v(object):
    """Proxy of C++ v class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    metrics = _swig_property(_fec_swig.v_metrics_get, _fec_swig.v_metrics_set)
    old_metrics = _swig_property(_fec_swig.v_old_metrics_get, _fec_swig.v_old_metrics_set)
    new_metrics = _swig_property(_fec_swig.v_new_metrics_get, _fec_swig.v_new_metrics_set)
    metrics1 = _swig_property(_fec_swig.v_metrics1_get, _fec_swig.v_metrics1_set)
    metrics2 = _swig_property(_fec_swig.v_metrics2_get, _fec_swig.v_metrics2_set)
    decisions = _swig_property(_fec_swig.v_decisions_get, _fec_swig.v_decisions_set)

    def __init__(self):
        """__init__(v self) -> v"""
        this = _fec_swig.new_v()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fec_swig.delete_v
    __del__ = lambda self: None
v_swigregister = _fec_swig.v_swigregister
v_swigregister(v)

class generic_encoder_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::generic_encoder)> 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::fec::generic_encoder)> self) -> generic_encoder_sptr
        __init__(boost::shared_ptr<(gr::fec::generic_encoder)> self, generic_encoder p) -> generic_encoder_sptr
        """
        this = _fec_swig.new_generic_encoder_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(generic_encoder_sptr self) -> generic_encoder"""
        return _fec_swig.generic_encoder_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_generic_encoder_sptr
    __del__ = lambda self: None

    def generic_work(self, in_buffer, out_buffer):
        """generic_work(generic_encoder_sptr self, void * in_buffer, void * out_buffer)"""
        return _fec_swig.generic_encoder_sptr_generic_work(self, in_buffer, out_buffer)

    base_unique_id = _swig_property(_fec_swig.generic_encoder_sptr_base_unique_id_get, _fec_swig.generic_encoder_sptr_base_unique_id_set)
    my_id = _swig_property(_fec_swig.generic_encoder_sptr_my_id_get, _fec_swig.generic_encoder_sptr_my_id_set)

    def unique_id(self):
        """unique_id(generic_encoder_sptr self) -> int"""
        return _fec_swig.generic_encoder_sptr_unique_id(self)

    d_name = _swig_property(_fec_swig.generic_encoder_sptr_d_name_get, _fec_swig.generic_encoder_sptr_d_name_set)

    def alias(self):
        """alias(generic_encoder_sptr self) -> std::string"""
        return _fec_swig.generic_encoder_sptr_alias(self)


    def rate(self):
        """rate(generic_encoder_sptr self) -> double"""
        return _fec_swig.generic_encoder_sptr_rate(self)


    def get_input_size(self):
        """get_input_size(generic_encoder_sptr self) -> int"""
        return _fec_swig.generic_encoder_sptr_get_input_size(self)


    def get_output_size(self):
        """get_output_size(generic_encoder_sptr self) -> int"""
        return _fec_swig.generic_encoder_sptr_get_output_size(self)


    def get_input_conversion(self):
        """get_input_conversion(generic_encoder_sptr self) -> char const *"""
        return _fec_swig.generic_encoder_sptr_get_input_conversion(self)


    def get_output_conversion(self):
        """get_output_conversion(generic_encoder_sptr self) -> char const *"""
        return _fec_swig.generic_encoder_sptr_get_output_conversion(self)


    def set_frame_size(self, frame_size):
        """set_frame_size(generic_encoder_sptr self, unsigned int frame_size) -> bool"""
        return _fec_swig.generic_encoder_sptr_set_frame_size(self, frame_size)

generic_encoder_sptr_swigregister = _fec_swig.generic_encoder_sptr_swigregister
generic_encoder_sptr_swigregister(generic_encoder_sptr)

class generic_decoder_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::generic_decoder)> 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::fec::generic_decoder)> self) -> generic_decoder_sptr
        __init__(boost::shared_ptr<(gr::fec::generic_decoder)> self, generic_decoder p) -> generic_decoder_sptr
        """
        this = _fec_swig.new_generic_decoder_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(generic_decoder_sptr self) -> generic_decoder"""
        return _fec_swig.generic_decoder_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_generic_decoder_sptr
    __del__ = lambda self: None

    def generic_work(self, inbuffer, outbuffer):
        """generic_work(generic_decoder_sptr self, void * inbuffer, void * outbuffer)"""
        return _fec_swig.generic_decoder_sptr_generic_work(self, inbuffer, outbuffer)

    base_unique_id = _swig_property(_fec_swig.generic_decoder_sptr_base_unique_id_get, _fec_swig.generic_decoder_sptr_base_unique_id_set)
    my_id = _swig_property(_fec_swig.generic_decoder_sptr_my_id_get, _fec_swig.generic_decoder_sptr_my_id_set)

    def unique_id(self):
        """unique_id(generic_decoder_sptr self) -> int"""
        return _fec_swig.generic_decoder_sptr_unique_id(self)

    d_name = _swig_property(_fec_swig.generic_decoder_sptr_d_name_get, _fec_swig.generic_decoder_sptr_d_name_set)

    def alias(self):
        """alias(generic_decoder_sptr self) -> std::string"""
        return _fec_swig.generic_decoder_sptr_alias(self)


    def rate(self):
        """rate(generic_decoder_sptr self) -> double"""
        return _fec_swig.generic_decoder_sptr_rate(self)


    def get_input_size(self):
        """get_input_size(generic_decoder_sptr self) -> int"""
        return _fec_swig.generic_decoder_sptr_get_input_size(self)


    def get_output_size(self):
        """get_output_size(generic_decoder_sptr self) -> int"""
        return _fec_swig.generic_decoder_sptr_get_output_size(self)


    def get_history(self):
        """get_history(generic_decoder_sptr self) -> int"""
        return _fec_swig.generic_decoder_sptr_get_history(self)


    def get_shift(self):
        """get_shift(generic_decoder_sptr self) -> float"""
        return _fec_swig.generic_decoder_sptr_get_shift(self)


    def get_input_item_size(self):
        """get_input_item_size(generic_decoder_sptr self) -> int"""
        return _fec_swig.generic_decoder_sptr_get_input_item_size(self)


    def get_output_item_size(self):
        """get_output_item_size(generic_decoder_sptr self) -> int"""
        return _fec_swig.generic_decoder_sptr_get_output_item_size(self)


    def get_input_conversion(self):
        """get_input_conversion(generic_decoder_sptr self) -> char const *"""
        return _fec_swig.generic_decoder_sptr_get_input_conversion(self)


    def get_output_conversion(self):
        """get_output_conversion(generic_decoder_sptr self) -> char const *"""
        return _fec_swig.generic_decoder_sptr_get_output_conversion(self)


    def set_frame_size(self, frame_size):
        """set_frame_size(generic_decoder_sptr self, unsigned int frame_size) -> bool"""
        return _fec_swig.generic_decoder_sptr_set_frame_size(self, frame_size)


    def get_iterations(self):
        """get_iterations(generic_decoder_sptr self) -> float"""
        return _fec_swig.generic_decoder_sptr_get_iterations(self)

generic_decoder_sptr_swigregister = _fec_swig.generic_decoder_sptr_swigregister
generic_decoder_sptr_swigregister(generic_decoder_sptr)

class generic_decoder(object):
    """Proxy of C++ gr::fec::generic_decoder 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 generic_work(self, inbuffer, outbuffer):
        """generic_work(generic_decoder self, void * inbuffer, void * outbuffer)"""
        return _fec_swig.generic_decoder_generic_work(self, inbuffer, outbuffer)

    base_unique_id = _swig_property(_fec_swig.generic_decoder_base_unique_id_get, _fec_swig.generic_decoder_base_unique_id_set)
    my_id = _swig_property(_fec_swig.generic_decoder_my_id_get, _fec_swig.generic_decoder_my_id_set)

    def unique_id(self):
        """unique_id(generic_decoder self) -> int"""
        return _fec_swig.generic_decoder_unique_id(self)

    d_name = _swig_property(_fec_swig.generic_decoder_d_name_get, _fec_swig.generic_decoder_d_name_set)

    def alias(self):
        """alias(generic_decoder self) -> std::string"""
        return _fec_swig.generic_decoder_alias(self)

    __swig_destroy__ = _fec_swig.delete_generic_decoder
    __del__ = lambda self: None

    def rate(self):
        """rate(generic_decoder self) -> double"""
        return _fec_swig.generic_decoder_rate(self)


    def get_input_size(self):
        """get_input_size(generic_decoder self) -> int"""
        return _fec_swig.generic_decoder_get_input_size(self)


    def get_output_size(self):
        """get_output_size(generic_decoder self) -> int"""
        return _fec_swig.generic_decoder_get_output_size(self)


    def get_history(self):
        """get_history(generic_decoder self) -> int"""
        return _fec_swig.generic_decoder_get_history(self)


    def get_shift(self):
        """get_shift(generic_decoder self) -> float"""
        return _fec_swig.generic_decoder_get_shift(self)


    def get_input_item_size(self):
        """get_input_item_size(generic_decoder self) -> int"""
        return _fec_swig.generic_decoder_get_input_item_size(self)


    def get_output_item_size(self):
        """get_output_item_size(generic_decoder self) -> int"""
        return _fec_swig.generic_decoder_get_output_item_size(self)


    def get_input_conversion(self):
        """get_input_conversion(generic_decoder self) -> char const *"""
        return _fec_swig.generic_decoder_get_input_conversion(self)


    def get_output_conversion(self):
        """get_output_conversion(generic_decoder self) -> char const *"""
        return _fec_swig.generic_decoder_get_output_conversion(self)


    def set_frame_size(self, frame_size):
        """set_frame_size(generic_decoder self, unsigned int frame_size) -> bool"""
        return _fec_swig.generic_decoder_set_frame_size(self, frame_size)


    def get_iterations(self):
        """get_iterations(generic_decoder self) -> float"""
        return _fec_swig.generic_decoder_get_iterations(self)

generic_decoder_swigregister = _fec_swig.generic_decoder_swigregister
generic_decoder_swigregister(generic_decoder)
cvar = _fec_swig.cvar


def get_decoder_output_size(my_decoder):
    """get_decoder_output_size(generic_decoder_sptr my_decoder) -> int"""
    return _fec_swig.get_decoder_output_size(my_decoder)

def get_decoder_input_size(my_decoder):
    """get_decoder_input_size(generic_decoder_sptr my_decoder) -> int"""
    return _fec_swig.get_decoder_input_size(my_decoder)

def get_shift(my_decoder):
    """get_shift(generic_decoder_sptr my_decoder) -> float"""
    return _fec_swig.get_shift(my_decoder)

def get_history(my_decoder):
    """get_history(generic_decoder_sptr my_decoder) -> int"""
    return _fec_swig.get_history(my_decoder)

def get_decoder_input_item_size(my_decoder):
    """get_decoder_input_item_size(generic_decoder_sptr my_decoder) -> int"""
    return _fec_swig.get_decoder_input_item_size(my_decoder)

def get_decoder_output_item_size(my_decoder):
    """get_decoder_output_item_size(generic_decoder_sptr my_decoder) -> int"""
    return _fec_swig.get_decoder_output_item_size(my_decoder)

def get_decoder_input_conversion(my_decoder):
    """get_decoder_input_conversion(generic_decoder_sptr my_decoder) -> char const *"""
    return _fec_swig.get_decoder_input_conversion(my_decoder)

def get_decoder_output_conversion(my_decoder):
    """get_decoder_output_conversion(generic_decoder_sptr my_decoder) -> char const *"""
    return _fec_swig.get_decoder_output_conversion(my_decoder)
class generic_encoder(object):
    """Proxy of C++ gr::fec::generic_encoder 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 generic_work(self, in_buffer, out_buffer):
        """generic_work(generic_encoder self, void * in_buffer, void * out_buffer)"""
        return _fec_swig.generic_encoder_generic_work(self, in_buffer, out_buffer)

    base_unique_id = _swig_property(_fec_swig.generic_encoder_base_unique_id_get, _fec_swig.generic_encoder_base_unique_id_set)
    my_id = _swig_property(_fec_swig.generic_encoder_my_id_get, _fec_swig.generic_encoder_my_id_set)

    def unique_id(self):
        """unique_id(generic_encoder self) -> int"""
        return _fec_swig.generic_encoder_unique_id(self)

    d_name = _swig_property(_fec_swig.generic_encoder_d_name_get, _fec_swig.generic_encoder_d_name_set)

    def alias(self):
        """alias(generic_encoder self) -> std::string"""
        return _fec_swig.generic_encoder_alias(self)


    def rate(self):
        """rate(generic_encoder self) -> double"""
        return _fec_swig.generic_encoder_rate(self)


    def get_input_size(self):
        """get_input_size(generic_encoder self) -> int"""
        return _fec_swig.generic_encoder_get_input_size(self)


    def get_output_size(self):
        """get_output_size(generic_encoder self) -> int"""
        return _fec_swig.generic_encoder_get_output_size(self)


    def get_input_conversion(self):
        """get_input_conversion(generic_encoder self) -> char const *"""
        return _fec_swig.generic_encoder_get_input_conversion(self)


    def get_output_conversion(self):
        """get_output_conversion(generic_encoder self) -> char const *"""
        return _fec_swig.generic_encoder_get_output_conversion(self)


    def set_frame_size(self, frame_size):
        """set_frame_size(generic_encoder self, unsigned int frame_size) -> bool"""
        return _fec_swig.generic_encoder_set_frame_size(self, frame_size)

    __swig_destroy__ = _fec_swig.delete_generic_encoder
    __del__ = lambda self: None
generic_encoder_swigregister = _fec_swig.generic_encoder_swigregister
generic_encoder_swigregister(generic_encoder)


def get_encoder_output_size(my_encoder):
    """get_encoder_output_size(generic_encoder_sptr my_encoder) -> int"""
    return _fec_swig.get_encoder_output_size(my_encoder)

def get_encoder_input_size(my_encoder):
    """get_encoder_input_size(generic_encoder_sptr my_encoder) -> int"""
    return _fec_swig.get_encoder_input_size(my_encoder)

def get_encoder_input_conversion(my_encoder):
    """get_encoder_input_conversion(generic_encoder_sptr my_encoder) -> char const *"""
    return _fec_swig.get_encoder_input_conversion(my_encoder)

def get_encoder_output_conversion(my_encoder):
    """get_encoder_output_conversion(generic_encoder_sptr my_encoder) -> char const *"""
    return _fec_swig.get_encoder_output_conversion(my_encoder)
class decoder(object):
    """Proxy of C++ gr::fec::decoder 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(my_decoder, input_item_size, output_item_size):
        """make(generic_decoder_sptr my_decoder, size_t input_item_size, size_t output_item_size) -> decoder_sptr"""
        return _fec_swig.decoder_make(my_decoder, input_item_size, output_item_size)

    make = staticmethod(make)

    def general_work(self, noutput_items, ninput_items, input_items, output_items):
        """general_work(decoder self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.decoder_general_work(self, noutput_items, ninput_items, input_items, output_items)


    def fixed_rate_ninput_to_noutput(self, ninput):
        """fixed_rate_ninput_to_noutput(decoder self, int ninput) -> int"""
        return _fec_swig.decoder_fixed_rate_ninput_to_noutput(self, ninput)


    def fixed_rate_noutput_to_ninput(self, noutput):
        """fixed_rate_noutput_to_ninput(decoder self, int noutput) -> int"""
        return _fec_swig.decoder_fixed_rate_noutput_to_ninput(self, noutput)


    def forecast(self, noutput_items, ninput_items_required):
        """forecast(decoder self, int noutput_items, gr_vector_int & ninput_items_required)"""
        return _fec_swig.decoder_forecast(self, noutput_items, ninput_items_required)

    __swig_destroy__ = _fec_swig.delete_decoder
    __del__ = lambda self: None
decoder_swigregister = _fec_swig.decoder_swigregister
decoder_swigregister(decoder)

def decoder_make(my_decoder, input_item_size, output_item_size):
    """decoder_make(generic_decoder_sptr my_decoder, size_t input_item_size, size_t output_item_size) -> decoder_sptr"""
    return _fec_swig.decoder_make(my_decoder, input_item_size, output_item_size)

class encoder(object):
    """Proxy of C++ gr::fec::encoder 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(my_encoder, input_item_size, output_item_size):
        """make(generic_encoder_sptr my_encoder, size_t input_item_size, size_t output_item_size) -> encoder_sptr"""
        return _fec_swig.encoder_make(my_encoder, input_item_size, output_item_size)

    make = staticmethod(make)

    def general_work(self, noutput_items, ninput_items, input_items, output_items):
        """general_work(encoder self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.encoder_general_work(self, noutput_items, ninput_items, input_items, output_items)


    def fixed_rate_ninput_to_noutput(self, ninput):
        """fixed_rate_ninput_to_noutput(encoder self, int ninput) -> int"""
        return _fec_swig.encoder_fixed_rate_ninput_to_noutput(self, ninput)


    def fixed_rate_noutput_to_ninput(self, noutput):
        """fixed_rate_noutput_to_ninput(encoder self, int noutput) -> int"""
        return _fec_swig.encoder_fixed_rate_noutput_to_ninput(self, noutput)


    def forecast(self, noutput_items, ninput_items_required):
        """forecast(encoder self, int noutput_items, gr_vector_int & ninput_items_required)"""
        return _fec_swig.encoder_forecast(self, noutput_items, ninput_items_required)

    __swig_destroy__ = _fec_swig.delete_encoder
    __del__ = lambda self: None
encoder_swigregister = _fec_swig.encoder_swigregister
encoder_swigregister(encoder)

def encoder_make(my_encoder, input_item_size, output_item_size):
    """encoder_make(generic_encoder_sptr my_encoder, size_t input_item_size, size_t output_item_size) -> encoder_sptr"""
    return _fec_swig.encoder_make(my_encoder, input_item_size, output_item_size)

class tagged_decoder(object):
    """Proxy of C++ gr::fec::tagged_decoder 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(generic_decoder_sptr my_decoder, size_t input_item_size, size_t output_item_size, std::string const & lengthtagname, int mtu=1500) -> tagged_decoder_sptr"""
        return _fec_swig.tagged_decoder_make(*args, **kwargs)

    make = staticmethod(make)

    def work(self, noutput_items, ninput_items, input_items, output_items):
        """work(tagged_decoder self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.tagged_decoder_work(self, noutput_items, ninput_items, input_items, output_items)


    def calculate_output_stream_length(self, ninput_items):
        """calculate_output_stream_length(tagged_decoder self, gr_vector_int const & ninput_items) -> int"""
        return _fec_swig.tagged_decoder_calculate_output_stream_length(self, ninput_items)

    __swig_destroy__ = _fec_swig.delete_tagged_decoder
    __del__ = lambda self: None
tagged_decoder_swigregister = _fec_swig.tagged_decoder_swigregister
tagged_decoder_swigregister(tagged_decoder)

def tagged_decoder_make(*args, **kwargs):
    """tagged_decoder_make(generic_decoder_sptr my_decoder, size_t input_item_size, size_t output_item_size, std::string const & lengthtagname, int mtu=1500) -> tagged_decoder_sptr"""
    return _fec_swig.tagged_decoder_make(*args, **kwargs)

class tagged_encoder(object):
    """Proxy of C++ gr::fec::tagged_encoder 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(generic_encoder_sptr my_encoder, size_t input_item_size, size_t output_item_size, std::string const & lengthtagname, int mtu=1500) -> tagged_encoder_sptr"""
        return _fec_swig.tagged_encoder_make(*args, **kwargs)

    make = staticmethod(make)

    def work(self, noutput_items, ninput_items, input_items, output_items):
        """work(tagged_encoder self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.tagged_encoder_work(self, noutput_items, ninput_items, input_items, output_items)


    def calculate_output_stream_length(self, ninput_items):
        """calculate_output_stream_length(tagged_encoder self, gr_vector_int const & ninput_items) -> int"""
        return _fec_swig.tagged_encoder_calculate_output_stream_length(self, ninput_items)

    __swig_destroy__ = _fec_swig.delete_tagged_encoder
    __del__ = lambda self: None
tagged_encoder_swigregister = _fec_swig.tagged_encoder_swigregister
tagged_encoder_swigregister(tagged_encoder)

def tagged_encoder_make(*args, **kwargs):
    """tagged_encoder_make(generic_encoder_sptr my_encoder, size_t input_item_size, size_t output_item_size, std::string const & lengthtagname, int mtu=1500) -> tagged_encoder_sptr"""
    return _fec_swig.tagged_encoder_make(*args, **kwargs)

class async_decoder(object):
    """Proxy of C++ gr::fec::async_decoder 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(my_decoder, packed=False, rev_pack=True, mtu=1500):
        """make(generic_decoder_sptr my_decoder, bool packed=False, bool rev_pack=True, int mtu=1500) -> async_decoder_sptr"""
        return _fec_swig.async_decoder_make(my_decoder, packed, rev_pack, mtu)

    make = staticmethod(make)

    def general_work(self, noutput_items, ninput_items, input_items, output_items):
        """general_work(async_decoder self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.async_decoder_general_work(self, noutput_items, ninput_items, input_items, output_items)

    __swig_destroy__ = _fec_swig.delete_async_decoder
    __del__ = lambda self: None
async_decoder_swigregister = _fec_swig.async_decoder_swigregister
async_decoder_swigregister(async_decoder)

def async_decoder_make(my_decoder, packed=False, rev_pack=True, mtu=1500):
    """async_decoder_make(generic_decoder_sptr my_decoder, bool packed=False, bool rev_pack=True, int mtu=1500) -> async_decoder_sptr"""
    return _fec_swig.async_decoder_make(my_decoder, packed, rev_pack, mtu)

class async_encoder(object):
    """Proxy of C++ gr::fec::async_encoder 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(my_encoder, packed=False, rev_unpack=True, rev_pack=True, mtu=1500):
        """make(generic_encoder_sptr my_encoder, bool packed=False, bool rev_unpack=True, bool rev_pack=True, int mtu=1500) -> async_encoder_sptr"""
        return _fec_swig.async_encoder_make(my_encoder, packed, rev_unpack, rev_pack, mtu)

    make = staticmethod(make)

    def general_work(self, noutput_items, ninput_items, input_items, output_items):
        """general_work(async_encoder self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.async_encoder_general_work(self, noutput_items, ninput_items, input_items, output_items)

    __swig_destroy__ = _fec_swig.delete_async_encoder
    __del__ = lambda self: None
async_encoder_swigregister = _fec_swig.async_encoder_swigregister
async_encoder_swigregister(async_encoder)

def async_encoder_make(my_encoder, packed=False, rev_unpack=True, rev_pack=True, mtu=1500):
    """async_encoder_make(generic_encoder_sptr my_encoder, bool packed=False, bool rev_unpack=True, bool rev_pack=True, int mtu=1500) -> async_encoder_sptr"""
    return _fec_swig.async_encoder_make(my_encoder, packed, rev_unpack, rev_pack, mtu)

class cc_decoder(generic_decoder):
    """Proxy of C++ gr::fec::code::cc_decoder 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(frame_size, k, rate, polys, start_state=0, end_state=-1, mode=CC_STREAMING, padded=False):
        """make(int frame_size, int k, int rate, std::vector< int,std::allocator< int > > polys, int start_state=0, int end_state=-1, cc_mode_t mode=CC_STREAMING, bool padded=False) -> generic_decoder_sptr"""
        return _fec_swig.cc_decoder_make(frame_size, k, rate, polys, start_state, end_state, mode, padded)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_cc_decoder
    __del__ = lambda self: None
cc_decoder_swigregister = _fec_swig.cc_decoder_swigregister
cc_decoder_swigregister(cc_decoder)

def cc_decoder_make(frame_size, k, rate, polys, start_state=0, end_state=-1, mode=CC_STREAMING, padded=False):
    """cc_decoder_make(int frame_size, int k, int rate, std::vector< int,std::allocator< int > > polys, int start_state=0, int end_state=-1, cc_mode_t mode=CC_STREAMING, bool padded=False) -> generic_decoder_sptr"""
    return _fec_swig.cc_decoder_make(frame_size, k, rate, polys, start_state, end_state, mode, padded)

class cc_encoder(generic_encoder):
    """Proxy of C++ gr::fec::code::cc_encoder 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(frame_size, k, rate, polys, start_state=0, mode=CC_STREAMING, padded=False):
        """make(int frame_size, int k, int rate, std::vector< int,std::allocator< int > > polys, int start_state=0, cc_mode_t mode=CC_STREAMING, bool padded=False) -> generic_encoder_sptr"""
        return _fec_swig.cc_encoder_make(frame_size, k, rate, polys, start_state, mode, padded)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_cc_encoder
    __del__ = lambda self: None
cc_encoder_swigregister = _fec_swig.cc_encoder_swigregister
cc_encoder_swigregister(cc_encoder)

def cc_encoder_make(frame_size, k, rate, polys, start_state=0, mode=CC_STREAMING, padded=False):
    """cc_encoder_make(int frame_size, int k, int rate, std::vector< int,std::allocator< int > > polys, int start_state=0, cc_mode_t mode=CC_STREAMING, bool padded=False) -> generic_encoder_sptr"""
    return _fec_swig.cc_encoder_make(frame_size, k, rate, polys, start_state, mode, padded)

class ccsds_encoder(generic_encoder):
    """Proxy of C++ gr::fec::code::ccsds_encoder 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(frame_size, start_state=0, mode=CC_STREAMING):
        """make(int frame_size, int start_state=0, cc_mode_t mode=CC_STREAMING) -> generic_encoder_sptr"""
        return _fec_swig.ccsds_encoder_make(frame_size, start_state, mode)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_ccsds_encoder
    __del__ = lambda self: None
ccsds_encoder_swigregister = _fec_swig.ccsds_encoder_swigregister
ccsds_encoder_swigregister(ccsds_encoder)

def ccsds_encoder_make(frame_size, start_state=0, mode=CC_STREAMING):
    """ccsds_encoder_make(int frame_size, int start_state=0, cc_mode_t mode=CC_STREAMING) -> generic_encoder_sptr"""
    return _fec_swig.ccsds_encoder_make(frame_size, start_state, mode)

class dummy_decoder(generic_decoder):
    """Proxy of C++ gr::fec::code::dummy_decoder 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(frame_size):
        """make(int frame_size) -> generic_decoder_sptr"""
        return _fec_swig.dummy_decoder_make(frame_size)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_dummy_decoder
    __del__ = lambda self: None
dummy_decoder_swigregister = _fec_swig.dummy_decoder_swigregister
dummy_decoder_swigregister(dummy_decoder)

def dummy_decoder_make(frame_size):
    """dummy_decoder_make(int frame_size) -> generic_decoder_sptr"""
    return _fec_swig.dummy_decoder_make(frame_size)

class dummy_encoder(generic_encoder):
    """Proxy of C++ gr::fec::code::dummy_encoder 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(frame_size, pack=False, packed_bits=False):
        """make(int frame_size, bool pack=False, bool packed_bits=False) -> generic_encoder_sptr"""
        return _fec_swig.dummy_encoder_make(frame_size, pack, packed_bits)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_dummy_encoder
    __del__ = lambda self: None
dummy_encoder_swigregister = _fec_swig.dummy_encoder_swigregister
dummy_encoder_swigregister(dummy_encoder)

def dummy_encoder_make(frame_size, pack=False, packed_bits=False):
    """dummy_encoder_make(int frame_size, bool pack=False, bool packed_bits=False) -> generic_encoder_sptr"""
    return _fec_swig.dummy_encoder_make(frame_size, pack, packed_bits)

class repetition_decoder(generic_decoder):
    """Proxy of C++ gr::fec::code::repetition_decoder 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(frame_size, rep, ap_prob=0.5):
        """make(int frame_size, int rep, float ap_prob=0.5) -> generic_decoder_sptr"""
        return _fec_swig.repetition_decoder_make(frame_size, rep, ap_prob)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_repetition_decoder
    __del__ = lambda self: None
repetition_decoder_swigregister = _fec_swig.repetition_decoder_swigregister
repetition_decoder_swigregister(repetition_decoder)

def repetition_decoder_make(frame_size, rep, ap_prob=0.5):
    """repetition_decoder_make(int frame_size, int rep, float ap_prob=0.5) -> generic_decoder_sptr"""
    return _fec_swig.repetition_decoder_make(frame_size, rep, ap_prob)

class repetition_encoder(generic_encoder):
    """Proxy of C++ gr::fec::code::repetition_encoder 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(frame_size, rep):
        """make(int frame_size, int rep) -> generic_encoder_sptr"""
        return _fec_swig.repetition_encoder_make(frame_size, rep)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_repetition_encoder
    __del__ = lambda self: None
repetition_encoder_swigregister = _fec_swig.repetition_encoder_swigregister
repetition_encoder_swigregister(repetition_encoder)

def repetition_encoder_make(frame_size, rep):
    """repetition_encoder_make(int frame_size, int rep) -> generic_encoder_sptr"""
    return _fec_swig.repetition_encoder_make(frame_size, rep)

class decode_ccsds_27_fb(object):
    """Proxy of C++ gr::fec::decode_ccsds_27_fb 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():
        """make() -> decode_ccsds_27_fb_sptr"""
        return _fec_swig.decode_ccsds_27_fb_make()

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_decode_ccsds_27_fb
    __del__ = lambda self: None
decode_ccsds_27_fb_swigregister = _fec_swig.decode_ccsds_27_fb_swigregister
decode_ccsds_27_fb_swigregister(decode_ccsds_27_fb)

def decode_ccsds_27_fb_make():
    """decode_ccsds_27_fb_make() -> decode_ccsds_27_fb_sptr"""
    return _fec_swig.decode_ccsds_27_fb_make()

class encode_ccsds_27_bb(object):
    """Proxy of C++ gr::fec::encode_ccsds_27_bb 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():
        """make() -> encode_ccsds_27_bb_sptr"""
        return _fec_swig.encode_ccsds_27_bb_make()

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_encode_ccsds_27_bb
    __del__ = lambda self: None
encode_ccsds_27_bb_swigregister = _fec_swig.encode_ccsds_27_bb_swigregister
encode_ccsds_27_bb_swigregister(encode_ccsds_27_bb)

def encode_ccsds_27_bb_make():
    """encode_ccsds_27_bb_make() -> encode_ccsds_27_bb_sptr"""
    return _fec_swig.encode_ccsds_27_bb_make()

class ber_bf(object):
    """Proxy of C++ gr::fec::ber_bf 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 total_errors(self):
        """total_errors(ber_bf self) -> long"""
        return _fec_swig.ber_bf_total_errors(self)


    def make(test_mode=False, berminerrors=100, ber_limit=-7.0):
        """make(bool test_mode=False, int berminerrors=100, float ber_limit=-7.0) -> ber_bf_sptr"""
        return _fec_swig.ber_bf_make(test_mode, berminerrors, ber_limit)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_ber_bf
    __del__ = lambda self: None
ber_bf_swigregister = _fec_swig.ber_bf_swigregister
ber_bf_swigregister(ber_bf)

def ber_bf_make(test_mode=False, berminerrors=100, ber_limit=-7.0):
    """ber_bf_make(bool test_mode=False, int berminerrors=100, float ber_limit=-7.0) -> ber_bf_sptr"""
    return _fec_swig.ber_bf_make(test_mode, berminerrors, ber_limit)

class conv_bit_corr_bb(object):
    """Proxy of C++ gr::fec::conv_bit_corr_bb 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(correlator, corr_sym, corr_len, cut, flush, thresh):
        """make(std::vector< unsigned long long,std::allocator< unsigned long long > > correlator, int corr_sym, int corr_len, int cut, int flush, float thresh) -> conv_bit_corr_bb_sptr"""
        return _fec_swig.conv_bit_corr_bb_make(correlator, corr_sym, corr_len, cut, flush, thresh)

    make = staticmethod(make)

    def data_garble_rate(self, taps, syn_density):
        """data_garble_rate(conv_bit_corr_bb self, int taps, float syn_density) -> float"""
        return _fec_swig.conv_bit_corr_bb_data_garble_rate(self, taps, syn_density)

    __swig_destroy__ = _fec_swig.delete_conv_bit_corr_bb
    __del__ = lambda self: None
conv_bit_corr_bb_swigregister = _fec_swig.conv_bit_corr_bb_swigregister
conv_bit_corr_bb_swigregister(conv_bit_corr_bb)

def conv_bit_corr_bb_make(correlator, corr_sym, corr_len, cut, flush, thresh):
    """conv_bit_corr_bb_make(std::vector< unsigned long long,std::allocator< unsigned long long > > correlator, int corr_sym, int corr_len, int cut, int flush, float thresh) -> conv_bit_corr_bb_sptr"""
    return _fec_swig.conv_bit_corr_bb_make(correlator, corr_sym, corr_len, cut, flush, thresh)

class puncture_bb(object):
    """Proxy of C++ gr::fec::puncture_bb 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(puncsize, puncpat, delay=0):
        """make(int puncsize, int puncpat, int delay=0) -> puncture_bb_sptr"""
        return _fec_swig.puncture_bb_make(puncsize, puncpat, delay)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_puncture_bb
    __del__ = lambda self: None
puncture_bb_swigregister = _fec_swig.puncture_bb_swigregister
puncture_bb_swigregister(puncture_bb)

def puncture_bb_make(puncsize, puncpat, delay=0):
    """puncture_bb_make(int puncsize, int puncpat, int delay=0) -> puncture_bb_sptr"""
    return _fec_swig.puncture_bb_make(puncsize, puncpat, delay)

class puncture_ff(object):
    """Proxy of C++ gr::fec::puncture_ff 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(puncsize, puncpat, delay):
        """make(int puncsize, int puncpat, int delay) -> puncture_ff_sptr"""
        return _fec_swig.puncture_ff_make(puncsize, puncpat, delay)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_puncture_ff
    __del__ = lambda self: None
puncture_ff_swigregister = _fec_swig.puncture_ff_swigregister
puncture_ff_swigregister(puncture_ff)

def puncture_ff_make(puncsize, puncpat, delay):
    """puncture_ff_make(int puncsize, int puncpat, int delay) -> puncture_ff_sptr"""
    return _fec_swig.puncture_ff_make(puncsize, puncpat, delay)

class depuncture_bb(object):
    """Proxy of C++ gr::fec::depuncture_bb 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(puncsize, puncpat, delay=0, symbol=127):
        """make(int puncsize, int puncpat, int delay=0, char symbol=127) -> depuncture_bb_sptr"""
        return _fec_swig.depuncture_bb_make(puncsize, puncpat, delay, symbol)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_depuncture_bb
    __del__ = lambda self: None
depuncture_bb_swigregister = _fec_swig.depuncture_bb_swigregister
depuncture_bb_swigregister(depuncture_bb)

def depuncture_bb_make(puncsize, puncpat, delay=0, symbol=127):
    """depuncture_bb_make(int puncsize, int puncpat, int delay=0, char symbol=127) -> depuncture_bb_sptr"""
    return _fec_swig.depuncture_bb_make(puncsize, puncpat, delay, symbol)

class tpc_encoder(generic_encoder):
    """Proxy of C++ gr::fec::tpc_encoder 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
    __swig_destroy__ = _fec_swig.delete_tpc_encoder
    __del__ = lambda self: None

    def make(row_poly, col_poly, krow, kcol, bval, qval):
        """make(std::vector< int,std::allocator< int > > row_poly, std::vector< int,std::allocator< int > > col_poly, int krow, int kcol, int bval, int qval) -> generic_encoder_sptr"""
        return _fec_swig.tpc_encoder_make(row_poly, col_poly, krow, kcol, bval, qval)

    make = staticmethod(make)
tpc_encoder_swigregister = _fec_swig.tpc_encoder_swigregister
tpc_encoder_swigregister(tpc_encoder)

def tpc_encoder_make(row_poly, col_poly, krow, kcol, bval, qval):
    """tpc_encoder_make(std::vector< int,std::allocator< int > > row_poly, std::vector< int,std::allocator< int > > col_poly, int krow, int kcol, int bval, int qval) -> generic_encoder_sptr"""
    return _fec_swig.tpc_encoder_make(row_poly, col_poly, krow, kcol, bval, qval)

MAXLOG = _fec_swig.MAXLOG
class tpc_decoder(generic_decoder):
    """Proxy of C++ gr::fec::tpc_decoder 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(row_poly, col_poly, krow, kcol, bval, qval, max_iter, decoder_type):
        """make(std::vector< int,std::allocator< int > > row_poly, std::vector< int,std::allocator< int > > col_poly, int krow, int kcol, int bval, int qval, int max_iter, int decoder_type) -> generic_decoder_sptr"""
        return _fec_swig.tpc_decoder_make(row_poly, col_poly, krow, kcol, bval, qval, max_iter, decoder_type)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_tpc_decoder
    __del__ = lambda self: None
tpc_decoder_swigregister = _fec_swig.tpc_decoder_swigregister
tpc_decoder_swigregister(tpc_decoder)

def tpc_decoder_make(row_poly, col_poly, krow, kcol, bval, qval, max_iter, decoder_type):
    """tpc_decoder_make(std::vector< int,std::allocator< int > > row_poly, std::vector< int,std::allocator< int > > col_poly, int krow, int kcol, int bval, int qval, int max_iter, int decoder_type) -> generic_decoder_sptr"""
    return _fec_swig.tpc_decoder_make(row_poly, col_poly, krow, kcol, bval, qval, max_iter, decoder_type)

class polar_encoder(generic_encoder):
    """Proxy of C++ gr::fec::code::polar_encoder 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(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values, is_packed=False):
        """make(int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions, std::vector< char,std::allocator< char > > frozen_bit_values, bool is_packed=False) -> generic_encoder_sptr"""
        return _fec_swig.polar_encoder_make(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values, is_packed)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_polar_encoder
    __del__ = lambda self: None
polar_encoder_swigregister = _fec_swig.polar_encoder_swigregister
polar_encoder_swigregister(polar_encoder)

def polar_encoder_make(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values, is_packed=False):
    """polar_encoder_make(int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions, std::vector< char,std::allocator< char > > frozen_bit_values, bool is_packed=False) -> generic_encoder_sptr"""
    return _fec_swig.polar_encoder_make(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values, is_packed)

class polar_decoder_sc(object):
    """Proxy of C++ gr::fec::code::polar_decoder_sc 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(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values):
        """make(int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions, std::vector< char,std::allocator< char > > frozen_bit_values) -> generic_decoder_sptr"""
        return _fec_swig.polar_decoder_sc_make(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_polar_decoder_sc
    __del__ = lambda self: None

    def generic_work(self, in_buffer, out_buffer):
        """generic_work(polar_decoder_sc self, void * in_buffer, void * out_buffer)"""
        return _fec_swig.polar_decoder_sc_generic_work(self, in_buffer, out_buffer)

polar_decoder_sc_swigregister = _fec_swig.polar_decoder_sc_swigregister
polar_decoder_sc_swigregister(polar_decoder_sc)

def polar_decoder_sc_make(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values):
    """polar_decoder_sc_make(int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions, std::vector< char,std::allocator< char > > frozen_bit_values) -> generic_decoder_sptr"""
    return _fec_swig.polar_decoder_sc_make(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)

class polar_common(object):
    """Proxy of C++ gr::fec::code::polar_common 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, block_size, num_info_bits, frozen_bit_positions, frozen_bit_values):
        """__init__(gr::fec::code::polar_common self, int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions, std::vector< char,std::allocator< char > > frozen_bit_values) -> polar_common"""
        this = _fec_swig.new_polar_common(block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fec_swig.delete_polar_common
    __del__ = lambda self: None
polar_common_swigregister = _fec_swig.polar_common_swigregister
polar_common_swigregister(polar_common)

class polar_decoder_sc_list(object):
    """Proxy of C++ gr::fec::code::polar_decoder_sc_list 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(max_list_size, block_size, num_info_bits, frozen_bit_positions, frozen_bit_values):
        """make(int max_list_size, int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions, std::vector< char,std::allocator< char > > frozen_bit_values) -> generic_decoder_sptr"""
        return _fec_swig.polar_decoder_sc_list_make(max_list_size, block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_polar_decoder_sc_list
    __del__ = lambda self: None

    def generic_work(self, in_buffer, out_buffer):
        """generic_work(polar_decoder_sc_list self, void * in_buffer, void * out_buffer)"""
        return _fec_swig.polar_decoder_sc_list_generic_work(self, in_buffer, out_buffer)

polar_decoder_sc_list_swigregister = _fec_swig.polar_decoder_sc_list_swigregister
polar_decoder_sc_list_swigregister(polar_decoder_sc_list)

def polar_decoder_sc_list_make(max_list_size, block_size, num_info_bits, frozen_bit_positions, frozen_bit_values):
    """polar_decoder_sc_list_make(int max_list_size, int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions, std::vector< char,std::allocator< char > > frozen_bit_values) -> generic_decoder_sptr"""
    return _fec_swig.polar_decoder_sc_list_make(max_list_size, block_size, num_info_bits, frozen_bit_positions, frozen_bit_values)

class polar_decoder_common(generic_decoder, polar_common):
    """Proxy of C++ gr::fec::code::polar_decoder_common 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
    __swig_destroy__ = _fec_swig.delete_polar_decoder_common
    __del__ = lambda self: None
polar_decoder_common_swigregister = _fec_swig.polar_decoder_common_swigregister
polar_decoder_common_swigregister(polar_decoder_common)

class polar_encoder_systematic(generic_encoder, polar_common):
    """Proxy of C++ gr::fec::code::polar_encoder_systematic 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(block_size, num_info_bits, frozen_bit_positions):
        """make(int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions) -> generic_encoder_sptr"""
        return _fec_swig.polar_encoder_systematic_make(block_size, num_info_bits, frozen_bit_positions)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_polar_encoder_systematic
    __del__ = lambda self: None
polar_encoder_systematic_swigregister = _fec_swig.polar_encoder_systematic_swigregister
polar_encoder_systematic_swigregister(polar_encoder_systematic)

def polar_encoder_systematic_make(block_size, num_info_bits, frozen_bit_positions):
    """polar_encoder_systematic_make(int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions) -> generic_encoder_sptr"""
    return _fec_swig.polar_encoder_systematic_make(block_size, num_info_bits, frozen_bit_positions)

class polar_decoder_sc_systematic(polar_decoder_common):
    """Proxy of C++ gr::fec::code::polar_decoder_sc_systematic 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(block_size, num_info_bits, frozen_bit_positions):
        """make(int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions) -> generic_decoder_sptr"""
        return _fec_swig.polar_decoder_sc_systematic_make(block_size, num_info_bits, frozen_bit_positions)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_polar_decoder_sc_systematic
    __del__ = lambda self: None
polar_decoder_sc_systematic_swigregister = _fec_swig.polar_decoder_sc_systematic_swigregister
polar_decoder_sc_systematic_swigregister(polar_decoder_sc_systematic)

def polar_decoder_sc_systematic_make(block_size, num_info_bits, frozen_bit_positions):
    """polar_decoder_sc_systematic_make(int block_size, int num_info_bits, std::vector< int,std::allocator< int > > frozen_bit_positions) -> generic_decoder_sptr"""
    return _fec_swig.polar_decoder_sc_systematic_make(block_size, num_info_bits, frozen_bit_positions)

class ldpc_encoder(generic_encoder):
    """Proxy of C++ gr::fec::ldpc_encoder 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(alist_file):
        """make(std::string alist_file) -> generic_encoder_sptr"""
        return _fec_swig.ldpc_encoder_make(alist_file)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_ldpc_encoder
    __del__ = lambda self: None
ldpc_encoder_swigregister = _fec_swig.ldpc_encoder_swigregister
ldpc_encoder_swigregister(ldpc_encoder)

def ldpc_encoder_make(alist_file):
    """ldpc_encoder_make(std::string alist_file) -> generic_encoder_sptr"""
    return _fec_swig.ldpc_encoder_make(alist_file)

class block_data(object):
    """Proxy of C++ gr::fec::code::block_data class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    size = _swig_property(_fec_swig.block_data_size_get, _fec_swig.block_data_size_set)
    data = _swig_property(_fec_swig.block_data_data_get, _fec_swig.block_data_data_set)

    def __init__(self):
        """__init__(gr::fec::code::block_data self) -> block_data"""
        this = _fec_swig.new_block_data()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fec_swig.delete_block_data
    __del__ = lambda self: None
block_data_swigregister = _fec_swig.block_data_swigregister
block_data_swigregister(block_data)

class matrix(object):
    """Proxy of C++ gr::fec::code::matrix class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    size1 = _swig_property(_fec_swig.matrix_size1_get, _fec_swig.matrix_size1_set)
    size2 = _swig_property(_fec_swig.matrix_size2_get, _fec_swig.matrix_size2_set)
    tda = _swig_property(_fec_swig.matrix_tda_get, _fec_swig.matrix_tda_set)
    data = _swig_property(_fec_swig.matrix_data_get, _fec_swig.matrix_data_set)
    block = _swig_property(_fec_swig.matrix_block_get, _fec_swig.matrix_block_set)
    owner = _swig_property(_fec_swig.matrix_owner_get, _fec_swig.matrix_owner_set)

    def __init__(self):
        """__init__(gr::fec::code::matrix self) -> matrix"""
        this = _fec_swig.new_matrix()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fec_swig.delete_matrix
    __del__ = lambda self: None
matrix_swigregister = _fec_swig.matrix_swigregister
matrix_swigregister(matrix)


def matrix_free(x):
    """matrix_free(matrix x)"""
    return _fec_swig.matrix_free(x)

def read_matrix_from_file(filename):
    """read_matrix_from_file(std::string const filename) -> matrix_sptr"""
    return _fec_swig.read_matrix_from_file(filename)

def write_matrix_to_file(filename, M):
    """write_matrix_to_file(std::string const filename, matrix_sptr M)"""
    return _fec_swig.write_matrix_to_file(filename, M)

def generate_G_transpose(H_obj):
    """generate_G_transpose(matrix_sptr H_obj) -> matrix_sptr"""
    return _fec_swig.generate_G_transpose(H_obj)

def generate_G(H_obj):
    """generate_G(matrix_sptr H_obj) -> matrix_sptr"""
    return _fec_swig.generate_G(H_obj)

def generate_H(G_obj):
    """generate_H(matrix_sptr G_obj) -> matrix_sptr"""
    return _fec_swig.generate_H(G_obj)

def print_matrix(M, numpy=False):
    """print_matrix(matrix_sptr M, bool numpy=False)"""
    return _fec_swig.print_matrix(M, numpy)
class fec_mtrx(object):
    """Proxy of C++ gr::fec::code::fec_mtrx 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
    __swig_destroy__ = _fec_swig.delete_fec_mtrx
    __del__ = lambda self: None

    def encode(self, outbuffer, inbuffer):
        """encode(fec_mtrx self, unsigned char * outbuffer, unsigned char const * inbuffer)"""
        return _fec_swig.fec_mtrx_encode(self, outbuffer, inbuffer)


    def decode(self, outbuffer, inbuffer, frame_size, max_iterations):
        """decode(fec_mtrx self, unsigned char * outbuffer, float const * inbuffer, unsigned int frame_size, unsigned int max_iterations)"""
        return _fec_swig.fec_mtrx_decode(self, outbuffer, inbuffer, frame_size, max_iterations)


    def n(self):
        """n(fec_mtrx self) -> unsigned int"""
        return _fec_swig.fec_mtrx_n(self)


    def k(self):
        """k(fec_mtrx self) -> unsigned int"""
        return _fec_swig.fec_mtrx_k(self)

fec_mtrx_swigregister = _fec_swig.fec_mtrx_swigregister
fec_mtrx_swigregister(fec_mtrx)

class ldpc_H_matrix(fec_mtrx):
    """Proxy of C++ gr::fec::code::ldpc_H_matrix class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

    def make(filename, gap):
        """make(std::string const filename, unsigned int gap) -> ldpc_H_matrix_sptr"""
        return _fec_swig.ldpc_H_matrix_make(filename, gap)

    make = staticmethod(make)

    def get_base_sptr(self):
        """get_base_sptr(ldpc_H_matrix self) -> fec_mtrx_sptr"""
        return _fec_swig.ldpc_H_matrix_get_base_sptr(self)

    __swig_destroy__ = _fec_swig.delete_ldpc_H_matrix
    __del__ = lambda self: None
ldpc_H_matrix_swigregister = _fec_swig.ldpc_H_matrix_swigregister
ldpc_H_matrix_swigregister(ldpc_H_matrix)

def ldpc_H_matrix_make(filename, gap):
    """ldpc_H_matrix_make(std::string const filename, unsigned int gap) -> ldpc_H_matrix_sptr"""
    return _fec_swig.ldpc_H_matrix_make(filename, gap)

class ldpc_G_matrix(fec_mtrx):
    """Proxy of C++ gr::fec::code::ldpc_G_matrix class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

    def make(filename):
        """make(std::string const filename) -> ldpc_G_matrix_sptr"""
        return _fec_swig.ldpc_G_matrix_make(filename)

    make = staticmethod(make)

    def get_base_sptr(self):
        """get_base_sptr(ldpc_G_matrix self) -> fec_mtrx_sptr"""
        return _fec_swig.ldpc_G_matrix_get_base_sptr(self)

    __swig_destroy__ = _fec_swig.delete_ldpc_G_matrix
    __del__ = lambda self: None
ldpc_G_matrix_swigregister = _fec_swig.ldpc_G_matrix_swigregister
ldpc_G_matrix_swigregister(ldpc_G_matrix)

def ldpc_G_matrix_make(filename):
    """ldpc_G_matrix_make(std::string const filename) -> ldpc_G_matrix_sptr"""
    return _fec_swig.ldpc_G_matrix_make(filename)

class ldpc_gen_mtrx_encoder(generic_encoder):
    """Proxy of C++ gr::fec::code::ldpc_gen_mtrx_encoder 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(G_obj):
        """make(ldpc_G_matrix_sptr G_obj) -> generic_encoder_sptr"""
        return _fec_swig.ldpc_gen_mtrx_encoder_make(G_obj)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_ldpc_gen_mtrx_encoder
    __del__ = lambda self: None
ldpc_gen_mtrx_encoder_swigregister = _fec_swig.ldpc_gen_mtrx_encoder_swigregister
ldpc_gen_mtrx_encoder_swigregister(ldpc_gen_mtrx_encoder)

def ldpc_gen_mtrx_encoder_make(G_obj):
    """ldpc_gen_mtrx_encoder_make(ldpc_G_matrix_sptr G_obj) -> generic_encoder_sptr"""
    return _fec_swig.ldpc_gen_mtrx_encoder_make(G_obj)

class ldpc_par_mtrx_encoder(generic_encoder):
    """Proxy of C++ gr::fec::code::ldpc_par_mtrx_encoder 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(alist_file, gap=0):
        """make(std::string alist_file, unsigned int gap=0) -> generic_encoder_sptr"""
        return _fec_swig.ldpc_par_mtrx_encoder_make(alist_file, gap)

    make = staticmethod(make)

    def make_H(H_obj):
        """make_H(ldpc_H_matrix_sptr H_obj) -> generic_encoder_sptr"""
        return _fec_swig.ldpc_par_mtrx_encoder_make_H(H_obj)

    make_H = staticmethod(make_H)
    __swig_destroy__ = _fec_swig.delete_ldpc_par_mtrx_encoder
    __del__ = lambda self: None
ldpc_par_mtrx_encoder_swigregister = _fec_swig.ldpc_par_mtrx_encoder_swigregister
ldpc_par_mtrx_encoder_swigregister(ldpc_par_mtrx_encoder)

def ldpc_par_mtrx_encoder_make(alist_file, gap=0):
    """ldpc_par_mtrx_encoder_make(std::string alist_file, unsigned int gap=0) -> generic_encoder_sptr"""
    return _fec_swig.ldpc_par_mtrx_encoder_make(alist_file, gap)

def ldpc_par_mtrx_encoder_make_H(H_obj):
    """ldpc_par_mtrx_encoder_make_H(ldpc_H_matrix_sptr H_obj) -> generic_encoder_sptr"""
    return _fec_swig.ldpc_par_mtrx_encoder_make_H(H_obj)

class ldpc_bit_flip_decoder(generic_decoder):
    """Proxy of C++ gr::fec::code::ldpc_bit_flip_decoder 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(mtrx_obj, max_iter=100):
        """make(fec_mtrx_sptr mtrx_obj, unsigned int max_iter=100) -> generic_decoder_sptr"""
        return _fec_swig.ldpc_bit_flip_decoder_make(mtrx_obj, max_iter)

    make = staticmethod(make)
    __swig_destroy__ = _fec_swig.delete_ldpc_bit_flip_decoder
    __del__ = lambda self: None
ldpc_bit_flip_decoder_swigregister = _fec_swig.ldpc_bit_flip_decoder_swigregister
ldpc_bit_flip_decoder_swigregister(ldpc_bit_flip_decoder)

def ldpc_bit_flip_decoder_make(mtrx_obj, max_iter=100):
    """ldpc_bit_flip_decoder_make(fec_mtrx_sptr mtrx_obj, unsigned int max_iter=100) -> generic_decoder_sptr"""
    return _fec_swig.ldpc_bit_flip_decoder_make(mtrx_obj, max_iter)

class ldpc_decoder(generic_decoder):
    """Proxy of C++ gr::fec::ldpc_decoder 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
    __swig_destroy__ = _fec_swig.delete_ldpc_decoder
    __del__ = lambda self: None

    def make(alist_file, sigma=0.5, max_iterations=50):
        """make(std::string alist_file, float sigma=0.5, int max_iterations=50) -> generic_decoder_sptr"""
        return _fec_swig.ldpc_decoder_make(alist_file, sigma, max_iterations)

    make = staticmethod(make)
ldpc_decoder_swigregister = _fec_swig.ldpc_decoder_swigregister
ldpc_decoder_swigregister(ldpc_decoder)

def ldpc_decoder_make(alist_file, sigma=0.5, max_iterations=50):
    """ldpc_decoder_make(std::string alist_file, float sigma=0.5, int max_iterations=50) -> generic_decoder_sptr"""
    return _fec_swig.ldpc_decoder_make(alist_file, sigma, max_iterations)

class matrix_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::code::matrix)> 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::fec::code::matrix)> self) -> matrix_sptr
        __init__(boost::shared_ptr<(gr::fec::code::matrix)> self, matrix p) -> matrix_sptr
        """
        this = _fec_swig.new_matrix_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(matrix_sptr self) -> matrix"""
        return _fec_swig.matrix_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_matrix_sptr
    __del__ = lambda self: None
    size1 = _swig_property(_fec_swig.matrix_sptr_size1_get, _fec_swig.matrix_sptr_size1_set)
    size2 = _swig_property(_fec_swig.matrix_sptr_size2_get, _fec_swig.matrix_sptr_size2_set)
    tda = _swig_property(_fec_swig.matrix_sptr_tda_get, _fec_swig.matrix_sptr_tda_set)
    data = _swig_property(_fec_swig.matrix_sptr_data_get, _fec_swig.matrix_sptr_data_set)
    block = _swig_property(_fec_swig.matrix_sptr_block_get, _fec_swig.matrix_sptr_block_set)
    owner = _swig_property(_fec_swig.matrix_sptr_owner_get, _fec_swig.matrix_sptr_owner_set)
matrix_sptr_swigregister = _fec_swig.matrix_sptr_swigregister
matrix_sptr_swigregister(matrix_sptr)

class fec_mtrx_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::code::fec_mtrx)> 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::fec::code::fec_mtrx)> self) -> fec_mtrx_sptr
        __init__(boost::shared_ptr<(gr::fec::code::fec_mtrx)> self, fec_mtrx p) -> fec_mtrx_sptr
        """
        this = _fec_swig.new_fec_mtrx_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(fec_mtrx_sptr self) -> fec_mtrx"""
        return _fec_swig.fec_mtrx_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_fec_mtrx_sptr
    __del__ = lambda self: None

    def encode(self, outbuffer, inbuffer):
        """encode(fec_mtrx_sptr self, unsigned char * outbuffer, unsigned char const * inbuffer)"""
        return _fec_swig.fec_mtrx_sptr_encode(self, outbuffer, inbuffer)


    def decode(self, outbuffer, inbuffer, frame_size, max_iterations):
        """decode(fec_mtrx_sptr self, unsigned char * outbuffer, float const * inbuffer, unsigned int frame_size, unsigned int max_iterations)"""
        return _fec_swig.fec_mtrx_sptr_decode(self, outbuffer, inbuffer, frame_size, max_iterations)


    def n(self):
        """n(fec_mtrx_sptr self) -> unsigned int"""
        return _fec_swig.fec_mtrx_sptr_n(self)


    def k(self):
        """k(fec_mtrx_sptr self) -> unsigned int"""
        return _fec_swig.fec_mtrx_sptr_k(self)

fec_mtrx_sptr_swigregister = _fec_swig.fec_mtrx_sptr_swigregister
fec_mtrx_sptr_swigregister(fec_mtrx_sptr)

class ldpc_H_matrix_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::code::ldpc_H_matrix)> 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::fec::code::ldpc_H_matrix)> self) -> ldpc_H_matrix_sptr
        __init__(boost::shared_ptr<(gr::fec::code::ldpc_H_matrix)> self, ldpc_H_matrix p) -> ldpc_H_matrix_sptr
        """
        this = _fec_swig.new_ldpc_H_matrix_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(ldpc_H_matrix_sptr self) -> ldpc_H_matrix"""
        return _fec_swig.ldpc_H_matrix_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_ldpc_H_matrix_sptr
    __del__ = lambda self: None

    def make(self, filename, gap):
        """make(ldpc_H_matrix_sptr self, std::string const filename, unsigned int gap) -> ldpc_H_matrix_sptr"""
        return _fec_swig.ldpc_H_matrix_sptr_make(self, filename, gap)


    def get_base_sptr(self):
        """get_base_sptr(ldpc_H_matrix_sptr self) -> fec_mtrx_sptr"""
        return _fec_swig.ldpc_H_matrix_sptr_get_base_sptr(self)


    def encode(self, outbuffer, inbuffer):
        """encode(ldpc_H_matrix_sptr self, unsigned char * outbuffer, unsigned char const * inbuffer)"""
        return _fec_swig.ldpc_H_matrix_sptr_encode(self, outbuffer, inbuffer)


    def decode(self, outbuffer, inbuffer, frame_size, max_iterations):
        """decode(ldpc_H_matrix_sptr self, unsigned char * outbuffer, float const * inbuffer, unsigned int frame_size, unsigned int max_iterations)"""
        return _fec_swig.ldpc_H_matrix_sptr_decode(self, outbuffer, inbuffer, frame_size, max_iterations)


    def n(self):
        """n(ldpc_H_matrix_sptr self) -> unsigned int"""
        return _fec_swig.ldpc_H_matrix_sptr_n(self)


    def k(self):
        """k(ldpc_H_matrix_sptr self) -> unsigned int"""
        return _fec_swig.ldpc_H_matrix_sptr_k(self)

ldpc_H_matrix_sptr_swigregister = _fec_swig.ldpc_H_matrix_sptr_swigregister
ldpc_H_matrix_sptr_swigregister(ldpc_H_matrix_sptr)


ldpc_H_matrix = ldpc_H_matrix.make;

class ldpc_G_matrix_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::code::ldpc_G_matrix)> 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::fec::code::ldpc_G_matrix)> self) -> ldpc_G_matrix_sptr
        __init__(boost::shared_ptr<(gr::fec::code::ldpc_G_matrix)> self, ldpc_G_matrix p) -> ldpc_G_matrix_sptr
        """
        this = _fec_swig.new_ldpc_G_matrix_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(ldpc_G_matrix_sptr self) -> ldpc_G_matrix"""
        return _fec_swig.ldpc_G_matrix_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_ldpc_G_matrix_sptr
    __del__ = lambda self: None

    def make(self, filename):
        """make(ldpc_G_matrix_sptr self, std::string const filename) -> ldpc_G_matrix_sptr"""
        return _fec_swig.ldpc_G_matrix_sptr_make(self, filename)


    def get_base_sptr(self):
        """get_base_sptr(ldpc_G_matrix_sptr self) -> fec_mtrx_sptr"""
        return _fec_swig.ldpc_G_matrix_sptr_get_base_sptr(self)


    def encode(self, outbuffer, inbuffer):
        """encode(ldpc_G_matrix_sptr self, unsigned char * outbuffer, unsigned char const * inbuffer)"""
        return _fec_swig.ldpc_G_matrix_sptr_encode(self, outbuffer, inbuffer)


    def decode(self, outbuffer, inbuffer, frame_size, max_iterations):
        """decode(ldpc_G_matrix_sptr self, unsigned char * outbuffer, float const * inbuffer, unsigned int frame_size, unsigned int max_iterations)"""
        return _fec_swig.ldpc_G_matrix_sptr_decode(self, outbuffer, inbuffer, frame_size, max_iterations)


    def n(self):
        """n(ldpc_G_matrix_sptr self) -> unsigned int"""
        return _fec_swig.ldpc_G_matrix_sptr_n(self)


    def k(self):
        """k(ldpc_G_matrix_sptr self) -> unsigned int"""
        return _fec_swig.ldpc_G_matrix_sptr_k(self)

ldpc_G_matrix_sptr_swigregister = _fec_swig.ldpc_G_matrix_sptr_swigregister
ldpc_G_matrix_sptr_swigregister(ldpc_G_matrix_sptr)


ldpc_G_matrix = ldpc_G_matrix.make;

class decoder_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::decoder)> 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::fec::decoder)> self) -> decoder_sptr
        __init__(boost::shared_ptr<(gr::fec::decoder)> self, decoder p) -> decoder_sptr
        """
        this = _fec_swig.new_decoder_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(decoder_sptr self) -> decoder"""
        return _fec_swig.decoder_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_decoder_sptr
    __del__ = lambda self: None

    def make(self, my_decoder, input_item_size, output_item_size):
        """make(decoder_sptr self, generic_decoder_sptr my_decoder, size_t input_item_size, size_t output_item_size) -> decoder_sptr"""
        return _fec_swig.decoder_sptr_make(self, my_decoder, input_item_size, output_item_size)


    def general_work(self, noutput_items, ninput_items, input_items, output_items):
        """general_work(decoder_sptr self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.decoder_sptr_general_work(self, noutput_items, ninput_items, input_items, output_items)


    def fixed_rate_ninput_to_noutput(self, ninput):
        """fixed_rate_ninput_to_noutput(decoder_sptr self, int ninput) -> int"""
        return _fec_swig.decoder_sptr_fixed_rate_ninput_to_noutput(self, ninput)


    def fixed_rate_noutput_to_ninput(self, noutput):
        """fixed_rate_noutput_to_ninput(decoder_sptr self, int noutput) -> int"""
        return _fec_swig.decoder_sptr_fixed_rate_noutput_to_ninput(self, noutput)


    def forecast(self, noutput_items, ninput_items_required):
        """forecast(decoder_sptr self, int noutput_items, gr_vector_int & ninput_items_required)"""
        return _fec_swig.decoder_sptr_forecast(self, noutput_items, ninput_items_required)


    def history(self):
        """history(decoder_sptr self) -> unsigned int"""
        return _fec_swig.decoder_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(decoder_sptr self, int which, int delay)
        declare_sample_delay(decoder_sptr self, unsigned int delay)
        """
        return _fec_swig.decoder_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(decoder_sptr self, int which) -> unsigned int"""
        return _fec_swig.decoder_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(decoder_sptr self) -> int"""
        return _fec_swig.decoder_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(decoder_sptr self) -> double"""
        return _fec_swig.decoder_sptr_relative_rate(self)


    def start(self):
        """start(decoder_sptr self) -> bool"""
        return _fec_swig.decoder_sptr_start(self)


    def stop(self):
        """stop(decoder_sptr self) -> bool"""
        return _fec_swig.decoder_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(decoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.decoder_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(decoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.decoder_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(decoder_sptr self) -> int"""
        return _fec_swig.decoder_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(decoder_sptr self, int m)"""
        return _fec_swig.decoder_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(decoder_sptr self)"""
        return _fec_swig.decoder_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(decoder_sptr self) -> bool"""
        return _fec_swig.decoder_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(decoder_sptr self, int m)"""
        return _fec_swig.decoder_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(decoder_sptr self) -> int"""
        return _fec_swig.decoder_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(decoder_sptr self, int i) -> long"""
        return _fec_swig.decoder_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(decoder_sptr self, long max_output_buffer)
        set_max_output_buffer(decoder_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.decoder_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(decoder_sptr self, int i) -> long"""
        return _fec_swig.decoder_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(decoder_sptr self, long min_output_buffer)
        set_min_output_buffer(decoder_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.decoder_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(decoder_sptr self, int which) -> float
        pc_input_buffers_full(decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.decoder_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(decoder_sptr self, int which) -> float
        pc_input_buffers_full_avg(decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.decoder_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(decoder_sptr self, int which) -> float
        pc_input_buffers_full_var(decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.decoder_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(decoder_sptr self, int which) -> float
        pc_output_buffers_full(decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.decoder_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(decoder_sptr self, int which) -> float
        pc_output_buffers_full_avg(decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.decoder_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(decoder_sptr self, int which) -> float
        pc_output_buffers_full_var(decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.decoder_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(decoder_sptr self) -> float"""
        return _fec_swig.decoder_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(decoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.decoder_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(decoder_sptr self)"""
        return _fec_swig.decoder_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(decoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.decoder_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(decoder_sptr self) -> int"""
        return _fec_swig.decoder_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(decoder_sptr self) -> int"""
        return _fec_swig.decoder_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(decoder_sptr self, int priority) -> int"""
        return _fec_swig.decoder_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(decoder_sptr self) -> std::string"""
        return _fec_swig.decoder_sptr_name(self)


    def symbol_name(self):
        """symbol_name(decoder_sptr self) -> std::string"""
        return _fec_swig.decoder_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(decoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.decoder_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(decoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.decoder_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(decoder_sptr self) -> long"""
        return _fec_swig.decoder_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(decoder_sptr self) -> basic_block_sptr"""
        return _fec_swig.decoder_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(decoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.decoder_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(decoder_sptr self) -> std::string"""
        return _fec_swig.decoder_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(decoder_sptr self, std::string name)"""
        return _fec_swig.decoder_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(decoder_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _fec_swig.decoder_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(decoder_sptr self) -> swig_int_ptr"""
        return _fec_swig.decoder_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(decoder_sptr self) -> swig_int_ptr"""
        return _fec_swig.decoder_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(decoder_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _fec_swig.decoder_sptr_message_subscribers(self, which_port)

decoder_sptr_swigregister = _fec_swig.decoder_sptr_swigregister
decoder_sptr_swigregister(decoder_sptr)


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

class encoder_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::encoder)> 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::fec::encoder)> self) -> encoder_sptr
        __init__(boost::shared_ptr<(gr::fec::encoder)> self, encoder p) -> encoder_sptr
        """
        this = _fec_swig.new_encoder_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(encoder_sptr self) -> encoder"""
        return _fec_swig.encoder_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_encoder_sptr
    __del__ = lambda self: None

    def make(self, my_encoder, input_item_size, output_item_size):
        """make(encoder_sptr self, generic_encoder_sptr my_encoder, size_t input_item_size, size_t output_item_size) -> encoder_sptr"""
        return _fec_swig.encoder_sptr_make(self, my_encoder, input_item_size, output_item_size)


    def general_work(self, noutput_items, ninput_items, input_items, output_items):
        """general_work(encoder_sptr self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.encoder_sptr_general_work(self, noutput_items, ninput_items, input_items, output_items)


    def fixed_rate_ninput_to_noutput(self, ninput):
        """fixed_rate_ninput_to_noutput(encoder_sptr self, int ninput) -> int"""
        return _fec_swig.encoder_sptr_fixed_rate_ninput_to_noutput(self, ninput)


    def fixed_rate_noutput_to_ninput(self, noutput):
        """fixed_rate_noutput_to_ninput(encoder_sptr self, int noutput) -> int"""
        return _fec_swig.encoder_sptr_fixed_rate_noutput_to_ninput(self, noutput)


    def forecast(self, noutput_items, ninput_items_required):
        """forecast(encoder_sptr self, int noutput_items, gr_vector_int & ninput_items_required)"""
        return _fec_swig.encoder_sptr_forecast(self, noutput_items, ninput_items_required)


    def history(self):
        """history(encoder_sptr self) -> unsigned int"""
        return _fec_swig.encoder_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(encoder_sptr self, int which, int delay)
        declare_sample_delay(encoder_sptr self, unsigned int delay)
        """
        return _fec_swig.encoder_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(encoder_sptr self, int which) -> unsigned int"""
        return _fec_swig.encoder_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(encoder_sptr self) -> int"""
        return _fec_swig.encoder_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(encoder_sptr self) -> double"""
        return _fec_swig.encoder_sptr_relative_rate(self)


    def start(self):
        """start(encoder_sptr self) -> bool"""
        return _fec_swig.encoder_sptr_start(self)


    def stop(self):
        """stop(encoder_sptr self) -> bool"""
        return _fec_swig.encoder_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(encoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.encoder_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(encoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.encoder_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(encoder_sptr self) -> int"""
        return _fec_swig.encoder_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(encoder_sptr self, int m)"""
        return _fec_swig.encoder_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(encoder_sptr self)"""
        return _fec_swig.encoder_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(encoder_sptr self) -> bool"""
        return _fec_swig.encoder_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(encoder_sptr self, int m)"""
        return _fec_swig.encoder_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(encoder_sptr self) -> int"""
        return _fec_swig.encoder_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(encoder_sptr self, int i) -> long"""
        return _fec_swig.encoder_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(encoder_sptr self, long max_output_buffer)
        set_max_output_buffer(encoder_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.encoder_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(encoder_sptr self, int i) -> long"""
        return _fec_swig.encoder_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(encoder_sptr self, long min_output_buffer)
        set_min_output_buffer(encoder_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.encoder_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(encoder_sptr self, int which) -> float
        pc_input_buffers_full(encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.encoder_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(encoder_sptr self, int which) -> float
        pc_input_buffers_full_avg(encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.encoder_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(encoder_sptr self, int which) -> float
        pc_input_buffers_full_var(encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.encoder_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(encoder_sptr self, int which) -> float
        pc_output_buffers_full(encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.encoder_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(encoder_sptr self, int which) -> float
        pc_output_buffers_full_avg(encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.encoder_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(encoder_sptr self, int which) -> float
        pc_output_buffers_full_var(encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.encoder_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(encoder_sptr self) -> float"""
        return _fec_swig.encoder_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(encoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.encoder_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(encoder_sptr self)"""
        return _fec_swig.encoder_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(encoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.encoder_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(encoder_sptr self) -> int"""
        return _fec_swig.encoder_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(encoder_sptr self) -> int"""
        return _fec_swig.encoder_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(encoder_sptr self, int priority) -> int"""
        return _fec_swig.encoder_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(encoder_sptr self) -> std::string"""
        return _fec_swig.encoder_sptr_name(self)


    def symbol_name(self):
        """symbol_name(encoder_sptr self) -> std::string"""
        return _fec_swig.encoder_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(encoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.encoder_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(encoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.encoder_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(encoder_sptr self) -> long"""
        return _fec_swig.encoder_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(encoder_sptr self) -> basic_block_sptr"""
        return _fec_swig.encoder_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(encoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.encoder_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(encoder_sptr self) -> std::string"""
        return _fec_swig.encoder_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(encoder_sptr self, std::string name)"""
        return _fec_swig.encoder_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(encoder_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _fec_swig.encoder_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(encoder_sptr self) -> swig_int_ptr"""
        return _fec_swig.encoder_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(encoder_sptr self) -> swig_int_ptr"""
        return _fec_swig.encoder_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(encoder_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _fec_swig.encoder_sptr_message_subscribers(self, which_port)

encoder_sptr_swigregister = _fec_swig.encoder_sptr_swigregister
encoder_sptr_swigregister(encoder_sptr)


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

class tagged_decoder_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::tagged_decoder)> 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::fec::tagged_decoder)> self) -> tagged_decoder_sptr
        __init__(boost::shared_ptr<(gr::fec::tagged_decoder)> self, tagged_decoder p) -> tagged_decoder_sptr
        """
        this = _fec_swig.new_tagged_decoder_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(tagged_decoder_sptr self) -> tagged_decoder"""
        return _fec_swig.tagged_decoder_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_tagged_decoder_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(tagged_decoder_sptr self, generic_decoder_sptr my_decoder, size_t input_item_size, size_t output_item_size, std::string const & lengthtagname, int mtu=1500) -> tagged_decoder_sptr"""
        return _fec_swig.tagged_decoder_sptr_make(self, *args, **kwargs)


    def work(self, noutput_items, ninput_items, input_items, output_items):
        """work(tagged_decoder_sptr self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.tagged_decoder_sptr_work(self, noutput_items, ninput_items, input_items, output_items)


    def calculate_output_stream_length(self, ninput_items):
        """calculate_output_stream_length(tagged_decoder_sptr self, gr_vector_int const & ninput_items) -> int"""
        return _fec_swig.tagged_decoder_sptr_calculate_output_stream_length(self, ninput_items)


    def history(self):
        """history(tagged_decoder_sptr self) -> unsigned int"""
        return _fec_swig.tagged_decoder_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tagged_decoder_sptr self, int which, int delay)
        declare_sample_delay(tagged_decoder_sptr self, unsigned int delay)
        """
        return _fec_swig.tagged_decoder_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tagged_decoder_sptr self, int which) -> unsigned int"""
        return _fec_swig.tagged_decoder_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tagged_decoder_sptr self) -> int"""
        return _fec_swig.tagged_decoder_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tagged_decoder_sptr self) -> double"""
        return _fec_swig.tagged_decoder_sptr_relative_rate(self)


    def start(self):
        """start(tagged_decoder_sptr self) -> bool"""
        return _fec_swig.tagged_decoder_sptr_start(self)


    def stop(self):
        """stop(tagged_decoder_sptr self) -> bool"""
        return _fec_swig.tagged_decoder_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tagged_decoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.tagged_decoder_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tagged_decoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.tagged_decoder_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tagged_decoder_sptr self) -> int"""
        return _fec_swig.tagged_decoder_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tagged_decoder_sptr self, int m)"""
        return _fec_swig.tagged_decoder_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tagged_decoder_sptr self)"""
        return _fec_swig.tagged_decoder_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tagged_decoder_sptr self) -> bool"""
        return _fec_swig.tagged_decoder_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tagged_decoder_sptr self, int m)"""
        return _fec_swig.tagged_decoder_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tagged_decoder_sptr self) -> int"""
        return _fec_swig.tagged_decoder_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tagged_decoder_sptr self, int i) -> long"""
        return _fec_swig.tagged_decoder_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tagged_decoder_sptr self, long max_output_buffer)
        set_max_output_buffer(tagged_decoder_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.tagged_decoder_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tagged_decoder_sptr self, int i) -> long"""
        return _fec_swig.tagged_decoder_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tagged_decoder_sptr self, long min_output_buffer)
        set_min_output_buffer(tagged_decoder_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.tagged_decoder_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tagged_decoder_sptr self, int which) -> float
        pc_input_buffers_full(tagged_decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_decoder_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tagged_decoder_sptr self, int which) -> float
        pc_input_buffers_full_avg(tagged_decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_decoder_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tagged_decoder_sptr self, int which) -> float
        pc_input_buffers_full_var(tagged_decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_decoder_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tagged_decoder_sptr self, int which) -> float
        pc_output_buffers_full(tagged_decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_decoder_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tagged_decoder_sptr self, int which) -> float
        pc_output_buffers_full_avg(tagged_decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_decoder_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tagged_decoder_sptr self, int which) -> float
        pc_output_buffers_full_var(tagged_decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_decoder_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tagged_decoder_sptr self) -> float"""
        return _fec_swig.tagged_decoder_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tagged_decoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.tagged_decoder_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tagged_decoder_sptr self)"""
        return _fec_swig.tagged_decoder_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tagged_decoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.tagged_decoder_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tagged_decoder_sptr self) -> int"""
        return _fec_swig.tagged_decoder_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tagged_decoder_sptr self) -> int"""
        return _fec_swig.tagged_decoder_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tagged_decoder_sptr self, int priority) -> int"""
        return _fec_swig.tagged_decoder_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tagged_decoder_sptr self) -> std::string"""
        return _fec_swig.tagged_decoder_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tagged_decoder_sptr self) -> std::string"""
        return _fec_swig.tagged_decoder_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tagged_decoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.tagged_decoder_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tagged_decoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.tagged_decoder_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tagged_decoder_sptr self) -> long"""
        return _fec_swig.tagged_decoder_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tagged_decoder_sptr self) -> basic_block_sptr"""
        return _fec_swig.tagged_decoder_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tagged_decoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.tagged_decoder_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tagged_decoder_sptr self) -> std::string"""
        return _fec_swig.tagged_decoder_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tagged_decoder_sptr self, std::string name)"""
        return _fec_swig.tagged_decoder_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tagged_decoder_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _fec_swig.tagged_decoder_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tagged_decoder_sptr self) -> swig_int_ptr"""
        return _fec_swig.tagged_decoder_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tagged_decoder_sptr self) -> swig_int_ptr"""
        return _fec_swig.tagged_decoder_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tagged_decoder_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _fec_swig.tagged_decoder_sptr_message_subscribers(self, which_port)

tagged_decoder_sptr_swigregister = _fec_swig.tagged_decoder_sptr_swigregister
tagged_decoder_sptr_swigregister(tagged_decoder_sptr)


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

class tagged_encoder_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::tagged_encoder)> 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::fec::tagged_encoder)> self) -> tagged_encoder_sptr
        __init__(boost::shared_ptr<(gr::fec::tagged_encoder)> self, tagged_encoder p) -> tagged_encoder_sptr
        """
        this = _fec_swig.new_tagged_encoder_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(tagged_encoder_sptr self) -> tagged_encoder"""
        return _fec_swig.tagged_encoder_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_tagged_encoder_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(tagged_encoder_sptr self, generic_encoder_sptr my_encoder, size_t input_item_size, size_t output_item_size, std::string const & lengthtagname, int mtu=1500) -> tagged_encoder_sptr"""
        return _fec_swig.tagged_encoder_sptr_make(self, *args, **kwargs)


    def work(self, noutput_items, ninput_items, input_items, output_items):
        """work(tagged_encoder_sptr self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.tagged_encoder_sptr_work(self, noutput_items, ninput_items, input_items, output_items)


    def calculate_output_stream_length(self, ninput_items):
        """calculate_output_stream_length(tagged_encoder_sptr self, gr_vector_int const & ninput_items) -> int"""
        return _fec_swig.tagged_encoder_sptr_calculate_output_stream_length(self, ninput_items)


    def history(self):
        """history(tagged_encoder_sptr self) -> unsigned int"""
        return _fec_swig.tagged_encoder_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(tagged_encoder_sptr self, int which, int delay)
        declare_sample_delay(tagged_encoder_sptr self, unsigned int delay)
        """
        return _fec_swig.tagged_encoder_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(tagged_encoder_sptr self, int which) -> unsigned int"""
        return _fec_swig.tagged_encoder_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(tagged_encoder_sptr self) -> int"""
        return _fec_swig.tagged_encoder_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(tagged_encoder_sptr self) -> double"""
        return _fec_swig.tagged_encoder_sptr_relative_rate(self)


    def start(self):
        """start(tagged_encoder_sptr self) -> bool"""
        return _fec_swig.tagged_encoder_sptr_start(self)


    def stop(self):
        """stop(tagged_encoder_sptr self) -> bool"""
        return _fec_swig.tagged_encoder_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(tagged_encoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.tagged_encoder_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(tagged_encoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.tagged_encoder_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(tagged_encoder_sptr self) -> int"""
        return _fec_swig.tagged_encoder_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(tagged_encoder_sptr self, int m)"""
        return _fec_swig.tagged_encoder_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(tagged_encoder_sptr self)"""
        return _fec_swig.tagged_encoder_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(tagged_encoder_sptr self) -> bool"""
        return _fec_swig.tagged_encoder_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(tagged_encoder_sptr self, int m)"""
        return _fec_swig.tagged_encoder_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(tagged_encoder_sptr self) -> int"""
        return _fec_swig.tagged_encoder_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(tagged_encoder_sptr self, int i) -> long"""
        return _fec_swig.tagged_encoder_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(tagged_encoder_sptr self, long max_output_buffer)
        set_max_output_buffer(tagged_encoder_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.tagged_encoder_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(tagged_encoder_sptr self, int i) -> long"""
        return _fec_swig.tagged_encoder_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(tagged_encoder_sptr self, long min_output_buffer)
        set_min_output_buffer(tagged_encoder_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.tagged_encoder_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(tagged_encoder_sptr self, int which) -> float
        pc_input_buffers_full(tagged_encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_encoder_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(tagged_encoder_sptr self, int which) -> float
        pc_input_buffers_full_avg(tagged_encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_encoder_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(tagged_encoder_sptr self, int which) -> float
        pc_input_buffers_full_var(tagged_encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_encoder_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(tagged_encoder_sptr self, int which) -> float
        pc_output_buffers_full(tagged_encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_encoder_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(tagged_encoder_sptr self, int which) -> float
        pc_output_buffers_full_avg(tagged_encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_encoder_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(tagged_encoder_sptr self, int which) -> float
        pc_output_buffers_full_var(tagged_encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.tagged_encoder_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(tagged_encoder_sptr self) -> float"""
        return _fec_swig.tagged_encoder_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(tagged_encoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.tagged_encoder_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(tagged_encoder_sptr self)"""
        return _fec_swig.tagged_encoder_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(tagged_encoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.tagged_encoder_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(tagged_encoder_sptr self) -> int"""
        return _fec_swig.tagged_encoder_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(tagged_encoder_sptr self) -> int"""
        return _fec_swig.tagged_encoder_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(tagged_encoder_sptr self, int priority) -> int"""
        return _fec_swig.tagged_encoder_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(tagged_encoder_sptr self) -> std::string"""
        return _fec_swig.tagged_encoder_sptr_name(self)


    def symbol_name(self):
        """symbol_name(tagged_encoder_sptr self) -> std::string"""
        return _fec_swig.tagged_encoder_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(tagged_encoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.tagged_encoder_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(tagged_encoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.tagged_encoder_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(tagged_encoder_sptr self) -> long"""
        return _fec_swig.tagged_encoder_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(tagged_encoder_sptr self) -> basic_block_sptr"""
        return _fec_swig.tagged_encoder_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(tagged_encoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.tagged_encoder_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(tagged_encoder_sptr self) -> std::string"""
        return _fec_swig.tagged_encoder_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(tagged_encoder_sptr self, std::string name)"""
        return _fec_swig.tagged_encoder_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(tagged_encoder_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _fec_swig.tagged_encoder_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(tagged_encoder_sptr self) -> swig_int_ptr"""
        return _fec_swig.tagged_encoder_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(tagged_encoder_sptr self) -> swig_int_ptr"""
        return _fec_swig.tagged_encoder_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(tagged_encoder_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _fec_swig.tagged_encoder_sptr_message_subscribers(self, which_port)

tagged_encoder_sptr_swigregister = _fec_swig.tagged_encoder_sptr_swigregister
tagged_encoder_sptr_swigregister(tagged_encoder_sptr)


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

class async_decoder_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::async_decoder)> 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::fec::async_decoder)> self) -> async_decoder_sptr
        __init__(boost::shared_ptr<(gr::fec::async_decoder)> self, async_decoder p) -> async_decoder_sptr
        """
        this = _fec_swig.new_async_decoder_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(async_decoder_sptr self) -> async_decoder"""
        return _fec_swig.async_decoder_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_async_decoder_sptr
    __del__ = lambda self: None

    def make(self, my_decoder, packed=False, rev_pack=True, mtu=1500):
        """make(async_decoder_sptr self, generic_decoder_sptr my_decoder, bool packed=False, bool rev_pack=True, int mtu=1500) -> async_decoder_sptr"""
        return _fec_swig.async_decoder_sptr_make(self, my_decoder, packed, rev_pack, mtu)


    def general_work(self, noutput_items, ninput_items, input_items, output_items):
        """general_work(async_decoder_sptr self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.async_decoder_sptr_general_work(self, noutput_items, ninput_items, input_items, output_items)


    def history(self):
        """history(async_decoder_sptr self) -> unsigned int"""
        return _fec_swig.async_decoder_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(async_decoder_sptr self, int which, int delay)
        declare_sample_delay(async_decoder_sptr self, unsigned int delay)
        """
        return _fec_swig.async_decoder_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(async_decoder_sptr self, int which) -> unsigned int"""
        return _fec_swig.async_decoder_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(async_decoder_sptr self) -> int"""
        return _fec_swig.async_decoder_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(async_decoder_sptr self) -> double"""
        return _fec_swig.async_decoder_sptr_relative_rate(self)


    def start(self):
        """start(async_decoder_sptr self) -> bool"""
        return _fec_swig.async_decoder_sptr_start(self)


    def stop(self):
        """stop(async_decoder_sptr self) -> bool"""
        return _fec_swig.async_decoder_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(async_decoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.async_decoder_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(async_decoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.async_decoder_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(async_decoder_sptr self) -> int"""
        return _fec_swig.async_decoder_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(async_decoder_sptr self, int m)"""
        return _fec_swig.async_decoder_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(async_decoder_sptr self)"""
        return _fec_swig.async_decoder_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(async_decoder_sptr self) -> bool"""
        return _fec_swig.async_decoder_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(async_decoder_sptr self, int m)"""
        return _fec_swig.async_decoder_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(async_decoder_sptr self) -> int"""
        return _fec_swig.async_decoder_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(async_decoder_sptr self, int i) -> long"""
        return _fec_swig.async_decoder_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(async_decoder_sptr self, long max_output_buffer)
        set_max_output_buffer(async_decoder_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.async_decoder_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(async_decoder_sptr self, int i) -> long"""
        return _fec_swig.async_decoder_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(async_decoder_sptr self, long min_output_buffer)
        set_min_output_buffer(async_decoder_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.async_decoder_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(async_decoder_sptr self, int which) -> float
        pc_input_buffers_full(async_decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.async_decoder_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(async_decoder_sptr self, int which) -> float
        pc_input_buffers_full_avg(async_decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.async_decoder_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(async_decoder_sptr self, int which) -> float
        pc_input_buffers_full_var(async_decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.async_decoder_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(async_decoder_sptr self, int which) -> float
        pc_output_buffers_full(async_decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.async_decoder_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(async_decoder_sptr self, int which) -> float
        pc_output_buffers_full_avg(async_decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.async_decoder_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(async_decoder_sptr self, int which) -> float
        pc_output_buffers_full_var(async_decoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.async_decoder_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(async_decoder_sptr self) -> float"""
        return _fec_swig.async_decoder_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(async_decoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.async_decoder_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(async_decoder_sptr self)"""
        return _fec_swig.async_decoder_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(async_decoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.async_decoder_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(async_decoder_sptr self) -> int"""
        return _fec_swig.async_decoder_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(async_decoder_sptr self) -> int"""
        return _fec_swig.async_decoder_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(async_decoder_sptr self, int priority) -> int"""
        return _fec_swig.async_decoder_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(async_decoder_sptr self) -> std::string"""
        return _fec_swig.async_decoder_sptr_name(self)


    def symbol_name(self):
        """symbol_name(async_decoder_sptr self) -> std::string"""
        return _fec_swig.async_decoder_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(async_decoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.async_decoder_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(async_decoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.async_decoder_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(async_decoder_sptr self) -> long"""
        return _fec_swig.async_decoder_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(async_decoder_sptr self) -> basic_block_sptr"""
        return _fec_swig.async_decoder_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(async_decoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.async_decoder_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(async_decoder_sptr self) -> std::string"""
        return _fec_swig.async_decoder_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(async_decoder_sptr self, std::string name)"""
        return _fec_swig.async_decoder_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(async_decoder_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _fec_swig.async_decoder_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(async_decoder_sptr self) -> swig_int_ptr"""
        return _fec_swig.async_decoder_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(async_decoder_sptr self) -> swig_int_ptr"""
        return _fec_swig.async_decoder_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(async_decoder_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _fec_swig.async_decoder_sptr_message_subscribers(self, which_port)

async_decoder_sptr_swigregister = _fec_swig.async_decoder_sptr_swigregister
async_decoder_sptr_swigregister(async_decoder_sptr)


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

class async_encoder_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::async_encoder)> 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::fec::async_encoder)> self) -> async_encoder_sptr
        __init__(boost::shared_ptr<(gr::fec::async_encoder)> self, async_encoder p) -> async_encoder_sptr
        """
        this = _fec_swig.new_async_encoder_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(async_encoder_sptr self) -> async_encoder"""
        return _fec_swig.async_encoder_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_async_encoder_sptr
    __del__ = lambda self: None

    def make(self, my_encoder, packed=False, rev_unpack=True, rev_pack=True, mtu=1500):
        """make(async_encoder_sptr self, generic_encoder_sptr my_encoder, bool packed=False, bool rev_unpack=True, bool rev_pack=True, int mtu=1500) -> async_encoder_sptr"""
        return _fec_swig.async_encoder_sptr_make(self, my_encoder, packed, rev_unpack, rev_pack, mtu)


    def general_work(self, noutput_items, ninput_items, input_items, output_items):
        """general_work(async_encoder_sptr self, int noutput_items, gr_vector_int & ninput_items, gr_vector_const_void_star & input_items, gr_vector_void_star & output_items) -> int"""
        return _fec_swig.async_encoder_sptr_general_work(self, noutput_items, ninput_items, input_items, output_items)


    def history(self):
        """history(async_encoder_sptr self) -> unsigned int"""
        return _fec_swig.async_encoder_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(async_encoder_sptr self, int which, int delay)
        declare_sample_delay(async_encoder_sptr self, unsigned int delay)
        """
        return _fec_swig.async_encoder_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(async_encoder_sptr self, int which) -> unsigned int"""
        return _fec_swig.async_encoder_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(async_encoder_sptr self) -> int"""
        return _fec_swig.async_encoder_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(async_encoder_sptr self) -> double"""
        return _fec_swig.async_encoder_sptr_relative_rate(self)


    def start(self):
        """start(async_encoder_sptr self) -> bool"""
        return _fec_swig.async_encoder_sptr_start(self)


    def stop(self):
        """stop(async_encoder_sptr self) -> bool"""
        return _fec_swig.async_encoder_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(async_encoder_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.async_encoder_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(async_encoder_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.async_encoder_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(async_encoder_sptr self) -> int"""
        return _fec_swig.async_encoder_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(async_encoder_sptr self, int m)"""
        return _fec_swig.async_encoder_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(async_encoder_sptr self)"""
        return _fec_swig.async_encoder_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(async_encoder_sptr self) -> bool"""
        return _fec_swig.async_encoder_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(async_encoder_sptr self, int m)"""
        return _fec_swig.async_encoder_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(async_encoder_sptr self) -> int"""
        return _fec_swig.async_encoder_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(async_encoder_sptr self, int i) -> long"""
        return _fec_swig.async_encoder_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(async_encoder_sptr self, long max_output_buffer)
        set_max_output_buffer(async_encoder_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.async_encoder_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(async_encoder_sptr self, int i) -> long"""
        return _fec_swig.async_encoder_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(async_encoder_sptr self, long min_output_buffer)
        set_min_output_buffer(async_encoder_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.async_encoder_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(async_encoder_sptr self, int which) -> float
        pc_input_buffers_full(async_encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.async_encoder_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(async_encoder_sptr self, int which) -> float
        pc_input_buffers_full_avg(async_encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.async_encoder_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(async_encoder_sptr self, int which) -> float
        pc_input_buffers_full_var(async_encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.async_encoder_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(async_encoder_sptr self, int which) -> float
        pc_output_buffers_full(async_encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.async_encoder_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(async_encoder_sptr self, int which) -> float
        pc_output_buffers_full_avg(async_encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.async_encoder_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(async_encoder_sptr self, int which) -> float
        pc_output_buffers_full_var(async_encoder_sptr self) -> pmt_vector_float
        """
        return _fec_swig.async_encoder_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(async_encoder_sptr self) -> float"""
        return _fec_swig.async_encoder_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(async_encoder_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.async_encoder_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(async_encoder_sptr self)"""
        return _fec_swig.async_encoder_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(async_encoder_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.async_encoder_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(async_encoder_sptr self) -> int"""
        return _fec_swig.async_encoder_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(async_encoder_sptr self) -> int"""
        return _fec_swig.async_encoder_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(async_encoder_sptr self, int priority) -> int"""
        return _fec_swig.async_encoder_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(async_encoder_sptr self) -> std::string"""
        return _fec_swig.async_encoder_sptr_name(self)


    def symbol_name(self):
        """symbol_name(async_encoder_sptr self) -> std::string"""
        return _fec_swig.async_encoder_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(async_encoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.async_encoder_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(async_encoder_sptr self) -> io_signature_sptr"""
        return _fec_swig.async_encoder_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(async_encoder_sptr self) -> long"""
        return _fec_swig.async_encoder_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(async_encoder_sptr self) -> basic_block_sptr"""
        return _fec_swig.async_encoder_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(async_encoder_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.async_encoder_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(async_encoder_sptr self) -> std::string"""
        return _fec_swig.async_encoder_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(async_encoder_sptr self, std::string name)"""
        return _fec_swig.async_encoder_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(async_encoder_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _fec_swig.async_encoder_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(async_encoder_sptr self) -> swig_int_ptr"""
        return _fec_swig.async_encoder_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(async_encoder_sptr self) -> swig_int_ptr"""
        return _fec_swig.async_encoder_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(async_encoder_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _fec_swig.async_encoder_sptr_message_subscribers(self, which_port)

async_encoder_sptr_swigregister = _fec_swig.async_encoder_sptr_swigregister
async_encoder_sptr_swigregister(async_encoder_sptr)


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

class decode_ccsds_27_fb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::decode_ccsds_27_fb)> 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::fec::decode_ccsds_27_fb)> self) -> decode_ccsds_27_fb_sptr
        __init__(boost::shared_ptr<(gr::fec::decode_ccsds_27_fb)> self, decode_ccsds_27_fb p) -> decode_ccsds_27_fb_sptr
        """
        this = _fec_swig.new_decode_ccsds_27_fb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(decode_ccsds_27_fb_sptr self) -> decode_ccsds_27_fb"""
        return _fec_swig.decode_ccsds_27_fb_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_decode_ccsds_27_fb_sptr
    __del__ = lambda self: None

    def make(self):
        """make(decode_ccsds_27_fb_sptr self) -> decode_ccsds_27_fb_sptr"""
        return _fec_swig.decode_ccsds_27_fb_sptr_make(self)


    def history(self):
        """history(decode_ccsds_27_fb_sptr self) -> unsigned int"""
        return _fec_swig.decode_ccsds_27_fb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(decode_ccsds_27_fb_sptr self, int which, int delay)
        declare_sample_delay(decode_ccsds_27_fb_sptr self, unsigned int delay)
        """
        return _fec_swig.decode_ccsds_27_fb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(decode_ccsds_27_fb_sptr self, int which) -> unsigned int"""
        return _fec_swig.decode_ccsds_27_fb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(decode_ccsds_27_fb_sptr self) -> int"""
        return _fec_swig.decode_ccsds_27_fb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(decode_ccsds_27_fb_sptr self) -> double"""
        return _fec_swig.decode_ccsds_27_fb_sptr_relative_rate(self)


    def start(self):
        """start(decode_ccsds_27_fb_sptr self) -> bool"""
        return _fec_swig.decode_ccsds_27_fb_sptr_start(self)


    def stop(self):
        """stop(decode_ccsds_27_fb_sptr self) -> bool"""
        return _fec_swig.decode_ccsds_27_fb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(decode_ccsds_27_fb_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.decode_ccsds_27_fb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(decode_ccsds_27_fb_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.decode_ccsds_27_fb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(decode_ccsds_27_fb_sptr self) -> int"""
        return _fec_swig.decode_ccsds_27_fb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(decode_ccsds_27_fb_sptr self, int m)"""
        return _fec_swig.decode_ccsds_27_fb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(decode_ccsds_27_fb_sptr self)"""
        return _fec_swig.decode_ccsds_27_fb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(decode_ccsds_27_fb_sptr self) -> bool"""
        return _fec_swig.decode_ccsds_27_fb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(decode_ccsds_27_fb_sptr self, int m)"""
        return _fec_swig.decode_ccsds_27_fb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(decode_ccsds_27_fb_sptr self) -> int"""
        return _fec_swig.decode_ccsds_27_fb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(decode_ccsds_27_fb_sptr self, int i) -> long"""
        return _fec_swig.decode_ccsds_27_fb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(decode_ccsds_27_fb_sptr self, long max_output_buffer)
        set_max_output_buffer(decode_ccsds_27_fb_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.decode_ccsds_27_fb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(decode_ccsds_27_fb_sptr self, int i) -> long"""
        return _fec_swig.decode_ccsds_27_fb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(decode_ccsds_27_fb_sptr self, long min_output_buffer)
        set_min_output_buffer(decode_ccsds_27_fb_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.decode_ccsds_27_fb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(decode_ccsds_27_fb_sptr self, int which) -> float
        pc_input_buffers_full(decode_ccsds_27_fb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(decode_ccsds_27_fb_sptr self, int which) -> float
        pc_input_buffers_full_avg(decode_ccsds_27_fb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(decode_ccsds_27_fb_sptr self, int which) -> float
        pc_input_buffers_full_var(decode_ccsds_27_fb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(decode_ccsds_27_fb_sptr self, int which) -> float
        pc_output_buffers_full(decode_ccsds_27_fb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(decode_ccsds_27_fb_sptr self, int which) -> float
        pc_output_buffers_full_avg(decode_ccsds_27_fb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(decode_ccsds_27_fb_sptr self, int which) -> float
        pc_output_buffers_full_var(decode_ccsds_27_fb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(decode_ccsds_27_fb_sptr self) -> float"""
        return _fec_swig.decode_ccsds_27_fb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(decode_ccsds_27_fb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.decode_ccsds_27_fb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(decode_ccsds_27_fb_sptr self)"""
        return _fec_swig.decode_ccsds_27_fb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(decode_ccsds_27_fb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.decode_ccsds_27_fb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(decode_ccsds_27_fb_sptr self) -> int"""
        return _fec_swig.decode_ccsds_27_fb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(decode_ccsds_27_fb_sptr self) -> int"""
        return _fec_swig.decode_ccsds_27_fb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(decode_ccsds_27_fb_sptr self, int priority) -> int"""
        return _fec_swig.decode_ccsds_27_fb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(decode_ccsds_27_fb_sptr self) -> std::string"""
        return _fec_swig.decode_ccsds_27_fb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(decode_ccsds_27_fb_sptr self) -> std::string"""
        return _fec_swig.decode_ccsds_27_fb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(decode_ccsds_27_fb_sptr self) -> io_signature_sptr"""
        return _fec_swig.decode_ccsds_27_fb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(decode_ccsds_27_fb_sptr self) -> io_signature_sptr"""
        return _fec_swig.decode_ccsds_27_fb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(decode_ccsds_27_fb_sptr self) -> long"""
        return _fec_swig.decode_ccsds_27_fb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(decode_ccsds_27_fb_sptr self) -> basic_block_sptr"""
        return _fec_swig.decode_ccsds_27_fb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(decode_ccsds_27_fb_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.decode_ccsds_27_fb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(decode_ccsds_27_fb_sptr self) -> std::string"""
        return _fec_swig.decode_ccsds_27_fb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(decode_ccsds_27_fb_sptr self, std::string name)"""
        return _fec_swig.decode_ccsds_27_fb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(decode_ccsds_27_fb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _fec_swig.decode_ccsds_27_fb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(decode_ccsds_27_fb_sptr self) -> swig_int_ptr"""
        return _fec_swig.decode_ccsds_27_fb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(decode_ccsds_27_fb_sptr self) -> swig_int_ptr"""
        return _fec_swig.decode_ccsds_27_fb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(decode_ccsds_27_fb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _fec_swig.decode_ccsds_27_fb_sptr_message_subscribers(self, which_port)

decode_ccsds_27_fb_sptr_swigregister = _fec_swig.decode_ccsds_27_fb_sptr_swigregister
decode_ccsds_27_fb_sptr_swigregister(decode_ccsds_27_fb_sptr)


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

class encode_ccsds_27_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::encode_ccsds_27_bb)> 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::fec::encode_ccsds_27_bb)> self) -> encode_ccsds_27_bb_sptr
        __init__(boost::shared_ptr<(gr::fec::encode_ccsds_27_bb)> self, encode_ccsds_27_bb p) -> encode_ccsds_27_bb_sptr
        """
        this = _fec_swig.new_encode_ccsds_27_bb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(encode_ccsds_27_bb_sptr self) -> encode_ccsds_27_bb"""
        return _fec_swig.encode_ccsds_27_bb_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_encode_ccsds_27_bb_sptr
    __del__ = lambda self: None

    def make(self):
        """make(encode_ccsds_27_bb_sptr self) -> encode_ccsds_27_bb_sptr"""
        return _fec_swig.encode_ccsds_27_bb_sptr_make(self)


    def history(self):
        """history(encode_ccsds_27_bb_sptr self) -> unsigned int"""
        return _fec_swig.encode_ccsds_27_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(encode_ccsds_27_bb_sptr self, int which, int delay)
        declare_sample_delay(encode_ccsds_27_bb_sptr self, unsigned int delay)
        """
        return _fec_swig.encode_ccsds_27_bb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(encode_ccsds_27_bb_sptr self, int which) -> unsigned int"""
        return _fec_swig.encode_ccsds_27_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(encode_ccsds_27_bb_sptr self) -> int"""
        return _fec_swig.encode_ccsds_27_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(encode_ccsds_27_bb_sptr self) -> double"""
        return _fec_swig.encode_ccsds_27_bb_sptr_relative_rate(self)


    def start(self):
        """start(encode_ccsds_27_bb_sptr self) -> bool"""
        return _fec_swig.encode_ccsds_27_bb_sptr_start(self)


    def stop(self):
        """stop(encode_ccsds_27_bb_sptr self) -> bool"""
        return _fec_swig.encode_ccsds_27_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(encode_ccsds_27_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.encode_ccsds_27_bb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(encode_ccsds_27_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.encode_ccsds_27_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(encode_ccsds_27_bb_sptr self) -> int"""
        return _fec_swig.encode_ccsds_27_bb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(encode_ccsds_27_bb_sptr self, int m)"""
        return _fec_swig.encode_ccsds_27_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(encode_ccsds_27_bb_sptr self)"""
        return _fec_swig.encode_ccsds_27_bb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(encode_ccsds_27_bb_sptr self) -> bool"""
        return _fec_swig.encode_ccsds_27_bb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(encode_ccsds_27_bb_sptr self, int m)"""
        return _fec_swig.encode_ccsds_27_bb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(encode_ccsds_27_bb_sptr self) -> int"""
        return _fec_swig.encode_ccsds_27_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(encode_ccsds_27_bb_sptr self, int i) -> long"""
        return _fec_swig.encode_ccsds_27_bb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(encode_ccsds_27_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(encode_ccsds_27_bb_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.encode_ccsds_27_bb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(encode_ccsds_27_bb_sptr self, int i) -> long"""
        return _fec_swig.encode_ccsds_27_bb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(encode_ccsds_27_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(encode_ccsds_27_bb_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.encode_ccsds_27_bb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(encode_ccsds_27_bb_sptr self, int which) -> float
        pc_input_buffers_full(encode_ccsds_27_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(encode_ccsds_27_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(encode_ccsds_27_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(encode_ccsds_27_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(encode_ccsds_27_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(encode_ccsds_27_bb_sptr self, int which) -> float
        pc_output_buffers_full(encode_ccsds_27_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(encode_ccsds_27_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(encode_ccsds_27_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(encode_ccsds_27_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(encode_ccsds_27_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(encode_ccsds_27_bb_sptr self) -> float"""
        return _fec_swig.encode_ccsds_27_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(encode_ccsds_27_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.encode_ccsds_27_bb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(encode_ccsds_27_bb_sptr self)"""
        return _fec_swig.encode_ccsds_27_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(encode_ccsds_27_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.encode_ccsds_27_bb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(encode_ccsds_27_bb_sptr self) -> int"""
        return _fec_swig.encode_ccsds_27_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(encode_ccsds_27_bb_sptr self) -> int"""
        return _fec_swig.encode_ccsds_27_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(encode_ccsds_27_bb_sptr self, int priority) -> int"""
        return _fec_swig.encode_ccsds_27_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(encode_ccsds_27_bb_sptr self) -> std::string"""
        return _fec_swig.encode_ccsds_27_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(encode_ccsds_27_bb_sptr self) -> std::string"""
        return _fec_swig.encode_ccsds_27_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(encode_ccsds_27_bb_sptr self) -> io_signature_sptr"""
        return _fec_swig.encode_ccsds_27_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(encode_ccsds_27_bb_sptr self) -> io_signature_sptr"""
        return _fec_swig.encode_ccsds_27_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(encode_ccsds_27_bb_sptr self) -> long"""
        return _fec_swig.encode_ccsds_27_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(encode_ccsds_27_bb_sptr self) -> basic_block_sptr"""
        return _fec_swig.encode_ccsds_27_bb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(encode_ccsds_27_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.encode_ccsds_27_bb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(encode_ccsds_27_bb_sptr self) -> std::string"""
        return _fec_swig.encode_ccsds_27_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(encode_ccsds_27_bb_sptr self, std::string name)"""
        return _fec_swig.encode_ccsds_27_bb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(encode_ccsds_27_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _fec_swig.encode_ccsds_27_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(encode_ccsds_27_bb_sptr self) -> swig_int_ptr"""
        return _fec_swig.encode_ccsds_27_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(encode_ccsds_27_bb_sptr self) -> swig_int_ptr"""
        return _fec_swig.encode_ccsds_27_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(encode_ccsds_27_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _fec_swig.encode_ccsds_27_bb_sptr_message_subscribers(self, which_port)

encode_ccsds_27_bb_sptr_swigregister = _fec_swig.encode_ccsds_27_bb_sptr_swigregister
encode_ccsds_27_bb_sptr_swigregister(encode_ccsds_27_bb_sptr)


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

class ber_bf_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::ber_bf)> 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::fec::ber_bf)> self) -> ber_bf_sptr
        __init__(boost::shared_ptr<(gr::fec::ber_bf)> self, ber_bf p) -> ber_bf_sptr
        """
        this = _fec_swig.new_ber_bf_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(ber_bf_sptr self) -> ber_bf"""
        return _fec_swig.ber_bf_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_ber_bf_sptr
    __del__ = lambda self: None

    def total_errors(self):
        """total_errors(ber_bf_sptr self) -> long"""
        return _fec_swig.ber_bf_sptr_total_errors(self)


    def make(self, test_mode=False, berminerrors=100, ber_limit=-7.0):
        """make(ber_bf_sptr self, bool test_mode=False, int berminerrors=100, float ber_limit=-7.0) -> ber_bf_sptr"""
        return _fec_swig.ber_bf_sptr_make(self, test_mode, berminerrors, ber_limit)


    def history(self):
        """history(ber_bf_sptr self) -> unsigned int"""
        return _fec_swig.ber_bf_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(ber_bf_sptr self, int which, int delay)
        declare_sample_delay(ber_bf_sptr self, unsigned int delay)
        """
        return _fec_swig.ber_bf_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(ber_bf_sptr self, int which) -> unsigned int"""
        return _fec_swig.ber_bf_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(ber_bf_sptr self) -> int"""
        return _fec_swig.ber_bf_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(ber_bf_sptr self) -> double"""
        return _fec_swig.ber_bf_sptr_relative_rate(self)


    def start(self):
        """start(ber_bf_sptr self) -> bool"""
        return _fec_swig.ber_bf_sptr_start(self)


    def stop(self):
        """stop(ber_bf_sptr self) -> bool"""
        return _fec_swig.ber_bf_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(ber_bf_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.ber_bf_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(ber_bf_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.ber_bf_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(ber_bf_sptr self) -> int"""
        return _fec_swig.ber_bf_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(ber_bf_sptr self, int m)"""
        return _fec_swig.ber_bf_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(ber_bf_sptr self)"""
        return _fec_swig.ber_bf_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(ber_bf_sptr self) -> bool"""
        return _fec_swig.ber_bf_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(ber_bf_sptr self, int m)"""
        return _fec_swig.ber_bf_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(ber_bf_sptr self) -> int"""
        return _fec_swig.ber_bf_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(ber_bf_sptr self, int i) -> long"""
        return _fec_swig.ber_bf_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(ber_bf_sptr self, long max_output_buffer)
        set_max_output_buffer(ber_bf_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.ber_bf_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(ber_bf_sptr self, int i) -> long"""
        return _fec_swig.ber_bf_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(ber_bf_sptr self, long min_output_buffer)
        set_min_output_buffer(ber_bf_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.ber_bf_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(ber_bf_sptr self, int which) -> float
        pc_input_buffers_full(ber_bf_sptr self) -> pmt_vector_float
        """
        return _fec_swig.ber_bf_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(ber_bf_sptr self, int which) -> float
        pc_input_buffers_full_avg(ber_bf_sptr self) -> pmt_vector_float
        """
        return _fec_swig.ber_bf_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(ber_bf_sptr self, int which) -> float
        pc_input_buffers_full_var(ber_bf_sptr self) -> pmt_vector_float
        """
        return _fec_swig.ber_bf_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(ber_bf_sptr self, int which) -> float
        pc_output_buffers_full(ber_bf_sptr self) -> pmt_vector_float
        """
        return _fec_swig.ber_bf_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(ber_bf_sptr self, int which) -> float
        pc_output_buffers_full_avg(ber_bf_sptr self) -> pmt_vector_float
        """
        return _fec_swig.ber_bf_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(ber_bf_sptr self, int which) -> float
        pc_output_buffers_full_var(ber_bf_sptr self) -> pmt_vector_float
        """
        return _fec_swig.ber_bf_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(ber_bf_sptr self) -> float"""
        return _fec_swig.ber_bf_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(ber_bf_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.ber_bf_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(ber_bf_sptr self)"""
        return _fec_swig.ber_bf_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(ber_bf_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.ber_bf_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(ber_bf_sptr self) -> int"""
        return _fec_swig.ber_bf_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(ber_bf_sptr self) -> int"""
        return _fec_swig.ber_bf_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(ber_bf_sptr self, int priority) -> int"""
        return _fec_swig.ber_bf_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(ber_bf_sptr self) -> std::string"""
        return _fec_swig.ber_bf_sptr_name(self)


    def symbol_name(self):
        """symbol_name(ber_bf_sptr self) -> std::string"""
        return _fec_swig.ber_bf_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(ber_bf_sptr self) -> io_signature_sptr"""
        return _fec_swig.ber_bf_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(ber_bf_sptr self) -> io_signature_sptr"""
        return _fec_swig.ber_bf_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(ber_bf_sptr self) -> long"""
        return _fec_swig.ber_bf_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(ber_bf_sptr self) -> basic_block_sptr"""
        return _fec_swig.ber_bf_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(ber_bf_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.ber_bf_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(ber_bf_sptr self) -> std::string"""
        return _fec_swig.ber_bf_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(ber_bf_sptr self, std::string name)"""
        return _fec_swig.ber_bf_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(ber_bf_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _fec_swig.ber_bf_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(ber_bf_sptr self) -> swig_int_ptr"""
        return _fec_swig.ber_bf_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(ber_bf_sptr self) -> swig_int_ptr"""
        return _fec_swig.ber_bf_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(ber_bf_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _fec_swig.ber_bf_sptr_message_subscribers(self, which_port)

ber_bf_sptr_swigregister = _fec_swig.ber_bf_sptr_swigregister
ber_bf_sptr_swigregister(ber_bf_sptr)


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

class conv_bit_corr_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::conv_bit_corr_bb)> 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::fec::conv_bit_corr_bb)> self) -> conv_bit_corr_bb_sptr
        __init__(boost::shared_ptr<(gr::fec::conv_bit_corr_bb)> self, conv_bit_corr_bb p) -> conv_bit_corr_bb_sptr
        """
        this = _fec_swig.new_conv_bit_corr_bb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(conv_bit_corr_bb_sptr self) -> conv_bit_corr_bb"""
        return _fec_swig.conv_bit_corr_bb_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_conv_bit_corr_bb_sptr
    __del__ = lambda self: None

    def make(self, correlator, corr_sym, corr_len, cut, flush, thresh):
        """make(conv_bit_corr_bb_sptr self, std::vector< unsigned long long,std::allocator< unsigned long long > > correlator, int corr_sym, int corr_len, int cut, int flush, float thresh) -> conv_bit_corr_bb_sptr"""
        return _fec_swig.conv_bit_corr_bb_sptr_make(self, correlator, corr_sym, corr_len, cut, flush, thresh)


    def data_garble_rate(self, taps, syn_density):
        """data_garble_rate(conv_bit_corr_bb_sptr self, int taps, float syn_density) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_data_garble_rate(self, taps, syn_density)


    def history(self):
        """history(conv_bit_corr_bb_sptr self) -> unsigned int"""
        return _fec_swig.conv_bit_corr_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(conv_bit_corr_bb_sptr self, int which, int delay)
        declare_sample_delay(conv_bit_corr_bb_sptr self, unsigned int delay)
        """
        return _fec_swig.conv_bit_corr_bb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(conv_bit_corr_bb_sptr self, int which) -> unsigned int"""
        return _fec_swig.conv_bit_corr_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(conv_bit_corr_bb_sptr self) -> int"""
        return _fec_swig.conv_bit_corr_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(conv_bit_corr_bb_sptr self) -> double"""
        return _fec_swig.conv_bit_corr_bb_sptr_relative_rate(self)


    def start(self):
        """start(conv_bit_corr_bb_sptr self) -> bool"""
        return _fec_swig.conv_bit_corr_bb_sptr_start(self)


    def stop(self):
        """stop(conv_bit_corr_bb_sptr self) -> bool"""
        return _fec_swig.conv_bit_corr_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(conv_bit_corr_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.conv_bit_corr_bb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(conv_bit_corr_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.conv_bit_corr_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(conv_bit_corr_bb_sptr self) -> int"""
        return _fec_swig.conv_bit_corr_bb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(conv_bit_corr_bb_sptr self, int m)"""
        return _fec_swig.conv_bit_corr_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(conv_bit_corr_bb_sptr self)"""
        return _fec_swig.conv_bit_corr_bb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(conv_bit_corr_bb_sptr self) -> bool"""
        return _fec_swig.conv_bit_corr_bb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(conv_bit_corr_bb_sptr self, int m)"""
        return _fec_swig.conv_bit_corr_bb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(conv_bit_corr_bb_sptr self) -> int"""
        return _fec_swig.conv_bit_corr_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(conv_bit_corr_bb_sptr self, int i) -> long"""
        return _fec_swig.conv_bit_corr_bb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(conv_bit_corr_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(conv_bit_corr_bb_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.conv_bit_corr_bb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(conv_bit_corr_bb_sptr self, int i) -> long"""
        return _fec_swig.conv_bit_corr_bb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(conv_bit_corr_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(conv_bit_corr_bb_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.conv_bit_corr_bb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(conv_bit_corr_bb_sptr self, int which) -> float
        pc_input_buffers_full(conv_bit_corr_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.conv_bit_corr_bb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(conv_bit_corr_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(conv_bit_corr_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.conv_bit_corr_bb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(conv_bit_corr_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(conv_bit_corr_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.conv_bit_corr_bb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(conv_bit_corr_bb_sptr self, int which) -> float
        pc_output_buffers_full(conv_bit_corr_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.conv_bit_corr_bb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(conv_bit_corr_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(conv_bit_corr_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.conv_bit_corr_bb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(conv_bit_corr_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(conv_bit_corr_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.conv_bit_corr_bb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(conv_bit_corr_bb_sptr self) -> float"""
        return _fec_swig.conv_bit_corr_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(conv_bit_corr_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.conv_bit_corr_bb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(conv_bit_corr_bb_sptr self)"""
        return _fec_swig.conv_bit_corr_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(conv_bit_corr_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.conv_bit_corr_bb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(conv_bit_corr_bb_sptr self) -> int"""
        return _fec_swig.conv_bit_corr_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(conv_bit_corr_bb_sptr self) -> int"""
        return _fec_swig.conv_bit_corr_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(conv_bit_corr_bb_sptr self, int priority) -> int"""
        return _fec_swig.conv_bit_corr_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(conv_bit_corr_bb_sptr self) -> std::string"""
        return _fec_swig.conv_bit_corr_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(conv_bit_corr_bb_sptr self) -> std::string"""
        return _fec_swig.conv_bit_corr_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(conv_bit_corr_bb_sptr self) -> io_signature_sptr"""
        return _fec_swig.conv_bit_corr_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(conv_bit_corr_bb_sptr self) -> io_signature_sptr"""
        return _fec_swig.conv_bit_corr_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(conv_bit_corr_bb_sptr self) -> long"""
        return _fec_swig.conv_bit_corr_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(conv_bit_corr_bb_sptr self) -> basic_block_sptr"""
        return _fec_swig.conv_bit_corr_bb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(conv_bit_corr_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.conv_bit_corr_bb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(conv_bit_corr_bb_sptr self) -> std::string"""
        return _fec_swig.conv_bit_corr_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(conv_bit_corr_bb_sptr self, std::string name)"""
        return _fec_swig.conv_bit_corr_bb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(conv_bit_corr_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _fec_swig.conv_bit_corr_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(conv_bit_corr_bb_sptr self) -> swig_int_ptr"""
        return _fec_swig.conv_bit_corr_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(conv_bit_corr_bb_sptr self) -> swig_int_ptr"""
        return _fec_swig.conv_bit_corr_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(conv_bit_corr_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _fec_swig.conv_bit_corr_bb_sptr_message_subscribers(self, which_port)

conv_bit_corr_bb_sptr_swigregister = _fec_swig.conv_bit_corr_bb_sptr_swigregister
conv_bit_corr_bb_sptr_swigregister(conv_bit_corr_bb_sptr)


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

class puncture_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::puncture_bb)> 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::fec::puncture_bb)> self) -> puncture_bb_sptr
        __init__(boost::shared_ptr<(gr::fec::puncture_bb)> self, puncture_bb p) -> puncture_bb_sptr
        """
        this = _fec_swig.new_puncture_bb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(puncture_bb_sptr self) -> puncture_bb"""
        return _fec_swig.puncture_bb_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_puncture_bb_sptr
    __del__ = lambda self: None

    def make(self, puncsize, puncpat, delay=0):
        """make(puncture_bb_sptr self, int puncsize, int puncpat, int delay=0) -> puncture_bb_sptr"""
        return _fec_swig.puncture_bb_sptr_make(self, puncsize, puncpat, delay)


    def history(self):
        """history(puncture_bb_sptr self) -> unsigned int"""
        return _fec_swig.puncture_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(puncture_bb_sptr self, int which, int delay)
        declare_sample_delay(puncture_bb_sptr self, unsigned int delay)
        """
        return _fec_swig.puncture_bb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(puncture_bb_sptr self, int which) -> unsigned int"""
        return _fec_swig.puncture_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(puncture_bb_sptr self) -> int"""
        return _fec_swig.puncture_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(puncture_bb_sptr self) -> double"""
        return _fec_swig.puncture_bb_sptr_relative_rate(self)


    def start(self):
        """start(puncture_bb_sptr self) -> bool"""
        return _fec_swig.puncture_bb_sptr_start(self)


    def stop(self):
        """stop(puncture_bb_sptr self) -> bool"""
        return _fec_swig.puncture_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(puncture_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.puncture_bb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(puncture_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.puncture_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(puncture_bb_sptr self) -> int"""
        return _fec_swig.puncture_bb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(puncture_bb_sptr self, int m)"""
        return _fec_swig.puncture_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(puncture_bb_sptr self)"""
        return _fec_swig.puncture_bb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(puncture_bb_sptr self) -> bool"""
        return _fec_swig.puncture_bb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(puncture_bb_sptr self, int m)"""
        return _fec_swig.puncture_bb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(puncture_bb_sptr self) -> int"""
        return _fec_swig.puncture_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(puncture_bb_sptr self, int i) -> long"""
        return _fec_swig.puncture_bb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(puncture_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(puncture_bb_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.puncture_bb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(puncture_bb_sptr self, int i) -> long"""
        return _fec_swig.puncture_bb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(puncture_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(puncture_bb_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.puncture_bb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(puncture_bb_sptr self, int which) -> float
        pc_input_buffers_full(puncture_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.puncture_bb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(puncture_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(puncture_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.puncture_bb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(puncture_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(puncture_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.puncture_bb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(puncture_bb_sptr self, int which) -> float
        pc_output_buffers_full(puncture_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.puncture_bb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(puncture_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(puncture_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.puncture_bb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(puncture_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(puncture_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.puncture_bb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(puncture_bb_sptr self) -> float"""
        return _fec_swig.puncture_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(puncture_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.puncture_bb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(puncture_bb_sptr self)"""
        return _fec_swig.puncture_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(puncture_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.puncture_bb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(puncture_bb_sptr self) -> int"""
        return _fec_swig.puncture_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(puncture_bb_sptr self) -> int"""
        return _fec_swig.puncture_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(puncture_bb_sptr self, int priority) -> int"""
        return _fec_swig.puncture_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(puncture_bb_sptr self) -> std::string"""
        return _fec_swig.puncture_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(puncture_bb_sptr self) -> std::string"""
        return _fec_swig.puncture_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(puncture_bb_sptr self) -> io_signature_sptr"""
        return _fec_swig.puncture_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(puncture_bb_sptr self) -> io_signature_sptr"""
        return _fec_swig.puncture_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(puncture_bb_sptr self) -> long"""
        return _fec_swig.puncture_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(puncture_bb_sptr self) -> basic_block_sptr"""
        return _fec_swig.puncture_bb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(puncture_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.puncture_bb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(puncture_bb_sptr self) -> std::string"""
        return _fec_swig.puncture_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(puncture_bb_sptr self, std::string name)"""
        return _fec_swig.puncture_bb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(puncture_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _fec_swig.puncture_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(puncture_bb_sptr self) -> swig_int_ptr"""
        return _fec_swig.puncture_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(puncture_bb_sptr self) -> swig_int_ptr"""
        return _fec_swig.puncture_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(puncture_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _fec_swig.puncture_bb_sptr_message_subscribers(self, which_port)

puncture_bb_sptr_swigregister = _fec_swig.puncture_bb_sptr_swigregister
puncture_bb_sptr_swigregister(puncture_bb_sptr)


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

class puncture_ff_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::puncture_ff)> 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::fec::puncture_ff)> self) -> puncture_ff_sptr
        __init__(boost::shared_ptr<(gr::fec::puncture_ff)> self, puncture_ff p) -> puncture_ff_sptr
        """
        this = _fec_swig.new_puncture_ff_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(puncture_ff_sptr self) -> puncture_ff"""
        return _fec_swig.puncture_ff_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_puncture_ff_sptr
    __del__ = lambda self: None

    def make(self, puncsize, puncpat, delay):
        """make(puncture_ff_sptr self, int puncsize, int puncpat, int delay) -> puncture_ff_sptr"""
        return _fec_swig.puncture_ff_sptr_make(self, puncsize, puncpat, delay)


    def history(self):
        """history(puncture_ff_sptr self) -> unsigned int"""
        return _fec_swig.puncture_ff_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(puncture_ff_sptr self, int which, int delay)
        declare_sample_delay(puncture_ff_sptr self, unsigned int delay)
        """
        return _fec_swig.puncture_ff_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(puncture_ff_sptr self, int which) -> unsigned int"""
        return _fec_swig.puncture_ff_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(puncture_ff_sptr self) -> int"""
        return _fec_swig.puncture_ff_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(puncture_ff_sptr self) -> double"""
        return _fec_swig.puncture_ff_sptr_relative_rate(self)


    def start(self):
        """start(puncture_ff_sptr self) -> bool"""
        return _fec_swig.puncture_ff_sptr_start(self)


    def stop(self):
        """stop(puncture_ff_sptr self) -> bool"""
        return _fec_swig.puncture_ff_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(puncture_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.puncture_ff_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(puncture_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.puncture_ff_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(puncture_ff_sptr self) -> int"""
        return _fec_swig.puncture_ff_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(puncture_ff_sptr self, int m)"""
        return _fec_swig.puncture_ff_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(puncture_ff_sptr self)"""
        return _fec_swig.puncture_ff_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(puncture_ff_sptr self) -> bool"""
        return _fec_swig.puncture_ff_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(puncture_ff_sptr self, int m)"""
        return _fec_swig.puncture_ff_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(puncture_ff_sptr self) -> int"""
        return _fec_swig.puncture_ff_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(puncture_ff_sptr self, int i) -> long"""
        return _fec_swig.puncture_ff_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(puncture_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(puncture_ff_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.puncture_ff_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(puncture_ff_sptr self, int i) -> long"""
        return _fec_swig.puncture_ff_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(puncture_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(puncture_ff_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.puncture_ff_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(puncture_ff_sptr self, int which) -> float
        pc_input_buffers_full(puncture_ff_sptr self) -> pmt_vector_float
        """
        return _fec_swig.puncture_ff_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(puncture_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(puncture_ff_sptr self) -> pmt_vector_float
        """
        return _fec_swig.puncture_ff_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(puncture_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(puncture_ff_sptr self) -> pmt_vector_float
        """
        return _fec_swig.puncture_ff_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(puncture_ff_sptr self, int which) -> float
        pc_output_buffers_full(puncture_ff_sptr self) -> pmt_vector_float
        """
        return _fec_swig.puncture_ff_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(puncture_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(puncture_ff_sptr self) -> pmt_vector_float
        """
        return _fec_swig.puncture_ff_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(puncture_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(puncture_ff_sptr self) -> pmt_vector_float
        """
        return _fec_swig.puncture_ff_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(puncture_ff_sptr self) -> float"""
        return _fec_swig.puncture_ff_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(puncture_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.puncture_ff_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(puncture_ff_sptr self)"""
        return _fec_swig.puncture_ff_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(puncture_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.puncture_ff_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(puncture_ff_sptr self) -> int"""
        return _fec_swig.puncture_ff_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(puncture_ff_sptr self) -> int"""
        return _fec_swig.puncture_ff_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(puncture_ff_sptr self, int priority) -> int"""
        return _fec_swig.puncture_ff_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(puncture_ff_sptr self) -> std::string"""
        return _fec_swig.puncture_ff_sptr_name(self)


    def symbol_name(self):
        """symbol_name(puncture_ff_sptr self) -> std::string"""
        return _fec_swig.puncture_ff_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(puncture_ff_sptr self) -> io_signature_sptr"""
        return _fec_swig.puncture_ff_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(puncture_ff_sptr self) -> io_signature_sptr"""
        return _fec_swig.puncture_ff_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(puncture_ff_sptr self) -> long"""
        return _fec_swig.puncture_ff_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(puncture_ff_sptr self) -> basic_block_sptr"""
        return _fec_swig.puncture_ff_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(puncture_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.puncture_ff_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(puncture_ff_sptr self) -> std::string"""
        return _fec_swig.puncture_ff_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(puncture_ff_sptr self, std::string name)"""
        return _fec_swig.puncture_ff_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(puncture_ff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _fec_swig.puncture_ff_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(puncture_ff_sptr self) -> swig_int_ptr"""
        return _fec_swig.puncture_ff_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(puncture_ff_sptr self) -> swig_int_ptr"""
        return _fec_swig.puncture_ff_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(puncture_ff_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _fec_swig.puncture_ff_sptr_message_subscribers(self, which_port)

puncture_ff_sptr_swigregister = _fec_swig.puncture_ff_sptr_swigregister
puncture_ff_sptr_swigregister(puncture_ff_sptr)


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

class depuncture_bb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::fec::depuncture_bb)> 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::fec::depuncture_bb)> self) -> depuncture_bb_sptr
        __init__(boost::shared_ptr<(gr::fec::depuncture_bb)> self, depuncture_bb p) -> depuncture_bb_sptr
        """
        this = _fec_swig.new_depuncture_bb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(depuncture_bb_sptr self) -> depuncture_bb"""
        return _fec_swig.depuncture_bb_sptr___deref__(self)

    __swig_destroy__ = _fec_swig.delete_depuncture_bb_sptr
    __del__ = lambda self: None

    def make(self, puncsize, puncpat, delay=0, symbol=127):
        """make(depuncture_bb_sptr self, int puncsize, int puncpat, int delay=0, char symbol=127) -> depuncture_bb_sptr"""
        return _fec_swig.depuncture_bb_sptr_make(self, puncsize, puncpat, delay, symbol)


    def history(self):
        """history(depuncture_bb_sptr self) -> unsigned int"""
        return _fec_swig.depuncture_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(depuncture_bb_sptr self, int which, int delay)
        declare_sample_delay(depuncture_bb_sptr self, unsigned int delay)
        """
        return _fec_swig.depuncture_bb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(depuncture_bb_sptr self, int which) -> unsigned int"""
        return _fec_swig.depuncture_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(depuncture_bb_sptr self) -> int"""
        return _fec_swig.depuncture_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(depuncture_bb_sptr self) -> double"""
        return _fec_swig.depuncture_bb_sptr_relative_rate(self)


    def start(self):
        """start(depuncture_bb_sptr self) -> bool"""
        return _fec_swig.depuncture_bb_sptr_start(self)


    def stop(self):
        """stop(depuncture_bb_sptr self) -> bool"""
        return _fec_swig.depuncture_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(depuncture_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _fec_swig.depuncture_bb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(depuncture_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _fec_swig.depuncture_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(depuncture_bb_sptr self) -> int"""
        return _fec_swig.depuncture_bb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(depuncture_bb_sptr self, int m)"""
        return _fec_swig.depuncture_bb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(depuncture_bb_sptr self)"""
        return _fec_swig.depuncture_bb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(depuncture_bb_sptr self) -> bool"""
        return _fec_swig.depuncture_bb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(depuncture_bb_sptr self, int m)"""
        return _fec_swig.depuncture_bb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(depuncture_bb_sptr self) -> int"""
        return _fec_swig.depuncture_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(depuncture_bb_sptr self, int i) -> long"""
        return _fec_swig.depuncture_bb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(depuncture_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(depuncture_bb_sptr self, int port, long max_output_buffer)
        """
        return _fec_swig.depuncture_bb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(depuncture_bb_sptr self, int i) -> long"""
        return _fec_swig.depuncture_bb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(depuncture_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(depuncture_bb_sptr self, int port, long min_output_buffer)
        """
        return _fec_swig.depuncture_bb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(depuncture_bb_sptr self, int which) -> float
        pc_input_buffers_full(depuncture_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.depuncture_bb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(depuncture_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(depuncture_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.depuncture_bb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(depuncture_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(depuncture_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.depuncture_bb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(depuncture_bb_sptr self, int which) -> float
        pc_output_buffers_full(depuncture_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.depuncture_bb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(depuncture_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(depuncture_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.depuncture_bb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(depuncture_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(depuncture_bb_sptr self) -> pmt_vector_float
        """
        return _fec_swig.depuncture_bb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(depuncture_bb_sptr self) -> float"""
        return _fec_swig.depuncture_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(depuncture_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _fec_swig.depuncture_bb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(depuncture_bb_sptr self)"""
        return _fec_swig.depuncture_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(depuncture_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _fec_swig.depuncture_bb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(depuncture_bb_sptr self) -> int"""
        return _fec_swig.depuncture_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(depuncture_bb_sptr self) -> int"""
        return _fec_swig.depuncture_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(depuncture_bb_sptr self, int priority) -> int"""
        return _fec_swig.depuncture_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(depuncture_bb_sptr self) -> std::string"""
        return _fec_swig.depuncture_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(depuncture_bb_sptr self) -> std::string"""
        return _fec_swig.depuncture_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(depuncture_bb_sptr self) -> io_signature_sptr"""
        return _fec_swig.depuncture_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(depuncture_bb_sptr self) -> io_signature_sptr"""
        return _fec_swig.depuncture_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(depuncture_bb_sptr self) -> long"""
        return _fec_swig.depuncture_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(depuncture_bb_sptr self) -> basic_block_sptr"""
        return _fec_swig.depuncture_bb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(depuncture_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _fec_swig.depuncture_bb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(depuncture_bb_sptr self) -> std::string"""
        return _fec_swig.depuncture_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(depuncture_bb_sptr self, std::string name)"""
        return _fec_swig.depuncture_bb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(depuncture_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _fec_swig.depuncture_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(depuncture_bb_sptr self) -> swig_int_ptr"""
        return _fec_swig.depuncture_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(depuncture_bb_sptr self) -> swig_int_ptr"""
        return _fec_swig.depuncture_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(depuncture_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _fec_swig.depuncture_bb_sptr_message_subscribers(self, which_port)

depuncture_bb_sptr_swigregister = _fec_swig.depuncture_bb_sptr_swigregister
depuncture_bb_sptr_swigregister(depuncture_bb_sptr)


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



