# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.1
#
# 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):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _digital_swig2
else:
    import _digital_swig2

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)



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

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

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

def high_res_timer_epoch() -> "gr::high_res_timer_type":
    r"""high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _digital_swig2.high_res_timer_epoch()
class control_loop(object):
    r"""Proxy of C++ gr::blocks::control_loop class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(control_loop self) -> control_loop
        __init__(control_loop self, float loop_bw, float max_freq, float min_freq) -> control_loop
        """
        _digital_swig2.control_loop_swiginit(self, _digital_swig2.new_control_loop(*args))
    __swig_destroy__ = _digital_swig2.delete_control_loop

    def update_gains(self) -> "void":
        r"""update_gains(control_loop self)"""
        return _digital_swig2.control_loop_update_gains(self)

    def advance_loop(self, error: "float") -> "void":
        r"""advance_loop(control_loop self, float error)"""
        return _digital_swig2.control_loop_advance_loop(self, error)

    def phase_wrap(self) -> "void":
        r"""phase_wrap(control_loop self)"""
        return _digital_swig2.control_loop_phase_wrap(self)

    def frequency_limit(self) -> "void":
        r"""frequency_limit(control_loop self)"""
        return _digital_swig2.control_loop_frequency_limit(self)

    def set_loop_bandwidth(self, bw: "float") -> "void":
        r"""set_loop_bandwidth(control_loop self, float bw)"""
        return _digital_swig2.control_loop_set_loop_bandwidth(self, bw)

    def set_damping_factor(self, df: "float") -> "void":
        r"""set_damping_factor(control_loop self, float df)"""
        return _digital_swig2.control_loop_set_damping_factor(self, df)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(control_loop self, float alpha)"""
        return _digital_swig2.control_loop_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(control_loop self, float beta)"""
        return _digital_swig2.control_loop_set_beta(self, beta)

    def set_frequency(self, freq: "float") -> "void":
        r"""set_frequency(control_loop self, float freq)"""
        return _digital_swig2.control_loop_set_frequency(self, freq)

    def set_phase(self, phase: "float") -> "void":
        r"""set_phase(control_loop self, float phase)"""
        return _digital_swig2.control_loop_set_phase(self, phase)

    def set_max_freq(self, freq: "float") -> "void":
        r"""set_max_freq(control_loop self, float freq)"""
        return _digital_swig2.control_loop_set_max_freq(self, freq)

    def set_min_freq(self, freq: "float") -> "void":
        r"""set_min_freq(control_loop self, float freq)"""
        return _digital_swig2.control_loop_set_min_freq(self, freq)

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

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

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

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

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

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

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

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

# Register control_loop in _digital_swig2:
_digital_swig2.control_loop_swigregister(control_loop)


def tanhf_lut(x: "float") -> "float":
    r"""tanhf_lut(float x) -> float"""
    return _digital_swig2.tanhf_lut(x)
class constellation(object):
    r"""Proxy of C++ gr::digital::constellation class."""

    thisown = 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__ = _digital_swig2.delete_constellation

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation self, unsigned int value, gr_complex * points)"""
        return _digital_swig2.constellation_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig2.constellation_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig2.constellation_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig2.constellation_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig2.constellation_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation self) -> gr_vector_vector_complexf"""
        return _digital_swig2.constellation_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation self) -> bool"""
        return _digital_swig2.constellation_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation self, bool a)"""
        return _digital_swig2.constellation_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.constellation_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation self) -> unsigned int"""
        return _digital_swig2.constellation_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation self) -> unsigned int"""
        return _digital_swig2.constellation_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation self) -> unsigned int"""
        return _digital_swig2.constellation_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation self) -> unsigned int"""
        return _digital_swig2.constellation_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation self) -> constellation_sptr"""
        return _digital_swig2.constellation_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation self) -> swig_pmt_ptr"""
        return _digital_swig2.constellation_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation self, int precision, float npwr=1.0)"""
        return _digital_swig2.constellation_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig2.constellation_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig2.constellation_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation self) -> bool"""
        return _digital_swig2.constellation_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.constellation_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig2.constellation_soft_decision_maker(self, sample)

# Register constellation in _digital_swig2:
_digital_swig2.constellation_swigregister(constellation)
cvar = _digital_swig2.cvar

class constellation_calcdist(constellation):
    r"""Proxy of C++ gr::digital::constellation_calcdist class."""

    thisown = 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

    @staticmethod
    def make(constell: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", rotational_symmetry: "unsigned int", dimensionality: "unsigned int", normalize_points: "bool"=True) -> "gr::digital::constellation_calcdist::sptr":
        r"""make(pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int dimensionality, bool normalize_points=True) -> constellation_calcdist_sptr"""
        return _digital_swig2.constellation_calcdist_make(constell, pre_diff_code, rotational_symmetry, dimensionality, normalize_points)
    __swig_destroy__ = _digital_swig2.delete_constellation_calcdist

# Register constellation_calcdist in _digital_swig2:
_digital_swig2.constellation_calcdist_swigregister(constellation_calcdist)

def constellation_calcdist_make(constell: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", rotational_symmetry: "unsigned int", dimensionality: "unsigned int", normalize_points: "bool"=True) -> "gr::digital::constellation_calcdist::sptr":
    r"""constellation_calcdist_make(pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int dimensionality, bool normalize_points=True) -> constellation_calcdist_sptr"""
    return _digital_swig2.constellation_calcdist_make(constell, pre_diff_code, rotational_symmetry, dimensionality, normalize_points)

class constellation_sector(constellation):
    r"""Proxy of C++ gr::digital::constellation_sector class."""

    thisown = 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__ = _digital_swig2.delete_constellation_sector

# Register constellation_sector in _digital_swig2:
_digital_swig2.constellation_sector_swigregister(constellation_sector)

class constellation_rect(constellation_sector):
    r"""Proxy of C++ gr::digital::constellation_rect class."""

    thisown = 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

    @staticmethod
    def make(constell: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", rotational_symmetry: "unsigned int", real_sectors: "unsigned int", imag_sectors: "unsigned int", width_real_sectors: "float", width_imag_sectors: "float") -> "gr::digital::constellation_rect::sptr":
        r"""make(pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int real_sectors, unsigned int imag_sectors, float width_real_sectors, float width_imag_sectors) -> constellation_rect_sptr"""
        return _digital_swig2.constellation_rect_make(constell, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors)
    __swig_destroy__ = _digital_swig2.delete_constellation_rect

# Register constellation_rect in _digital_swig2:
_digital_swig2.constellation_rect_swigregister(constellation_rect)

def constellation_rect_make(constell: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", rotational_symmetry: "unsigned int", real_sectors: "unsigned int", imag_sectors: "unsigned int", width_real_sectors: "float", width_imag_sectors: "float") -> "gr::digital::constellation_rect::sptr":
    r"""constellation_rect_make(pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int real_sectors, unsigned int imag_sectors, float width_real_sectors, float width_imag_sectors) -> constellation_rect_sptr"""
    return _digital_swig2.constellation_rect_make(constell, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors)

class constellation_expl_rect(constellation_rect):
    r"""Proxy of C++ gr::digital::constellation_expl_rect class."""

    thisown = 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

    @staticmethod
    def make(constellation: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", rotational_symmetry: "unsigned int", real_sectors: "unsigned int", imag_sectors: "unsigned int", width_real_sectors: "float", width_imag_sectors: "float", sector_values: "std::vector< unsigned int,std::allocator< unsigned int > >") -> "gr::digital::constellation_expl_rect::sptr":
        r"""make(pmt_vector_cfloat constellation, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int real_sectors, unsigned int imag_sectors, float width_real_sectors, float width_imag_sectors, std::vector< unsigned int,std::allocator< unsigned int > > sector_values) -> constellation_expl_rect_sptr"""
        return _digital_swig2.constellation_expl_rect_make(constellation, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors, sector_values)
    __swig_destroy__ = _digital_swig2.delete_constellation_expl_rect

# Register constellation_expl_rect in _digital_swig2:
_digital_swig2.constellation_expl_rect_swigregister(constellation_expl_rect)

def constellation_expl_rect_make(constellation: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", rotational_symmetry: "unsigned int", real_sectors: "unsigned int", imag_sectors: "unsigned int", width_real_sectors: "float", width_imag_sectors: "float", sector_values: "std::vector< unsigned int,std::allocator< unsigned int > >") -> "gr::digital::constellation_expl_rect::sptr":
    r"""constellation_expl_rect_make(pmt_vector_cfloat constellation, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int real_sectors, unsigned int imag_sectors, float width_real_sectors, float width_imag_sectors, std::vector< unsigned int,std::allocator< unsigned int > > sector_values) -> constellation_expl_rect_sptr"""
    return _digital_swig2.constellation_expl_rect_make(constellation, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors, sector_values)

class constellation_psk(constellation_sector):
    r"""Proxy of C++ gr::digital::constellation_psk class."""

    thisown = 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

    @staticmethod
    def make(constell: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", n_sectors: "unsigned int") -> "gr::digital::constellation_psk::sptr":
        r"""make(pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int n_sectors) -> constellation_psk_sptr"""
        return _digital_swig2.constellation_psk_make(constell, pre_diff_code, n_sectors)
    __swig_destroy__ = _digital_swig2.delete_constellation_psk

# Register constellation_psk in _digital_swig2:
_digital_swig2.constellation_psk_swigregister(constellation_psk)

def constellation_psk_make(constell: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", n_sectors: "unsigned int") -> "gr::digital::constellation_psk::sptr":
    r"""constellation_psk_make(pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int n_sectors) -> constellation_psk_sptr"""
    return _digital_swig2.constellation_psk_make(constell, pre_diff_code, n_sectors)

class constellation_bpsk(constellation):
    r"""Proxy of C++ gr::digital::constellation_bpsk class."""

    thisown = 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

    @staticmethod
    def make() -> "gr::digital::constellation_bpsk::sptr":
        r"""make() -> constellation_bpsk_sptr"""
        return _digital_swig2.constellation_bpsk_make()
    __swig_destroy__ = _digital_swig2.delete_constellation_bpsk

# Register constellation_bpsk in _digital_swig2:
_digital_swig2.constellation_bpsk_swigregister(constellation_bpsk)

def constellation_bpsk_make() -> "gr::digital::constellation_bpsk::sptr":
    r"""constellation_bpsk_make() -> constellation_bpsk_sptr"""
    return _digital_swig2.constellation_bpsk_make()

class constellation_qpsk(constellation):
    r"""Proxy of C++ gr::digital::constellation_qpsk class."""

    thisown = 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

    @staticmethod
    def make() -> "gr::digital::constellation_qpsk::sptr":
        r"""make() -> constellation_qpsk_sptr"""
        return _digital_swig2.constellation_qpsk_make()
    __swig_destroy__ = _digital_swig2.delete_constellation_qpsk

# Register constellation_qpsk in _digital_swig2:
_digital_swig2.constellation_qpsk_swigregister(constellation_qpsk)

def constellation_qpsk_make() -> "gr::digital::constellation_qpsk::sptr":
    r"""constellation_qpsk_make() -> constellation_qpsk_sptr"""
    return _digital_swig2.constellation_qpsk_make()

class constellation_dqpsk(constellation):
    r"""Proxy of C++ gr::digital::constellation_dqpsk class."""

    thisown = 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

    @staticmethod
    def make() -> "gr::digital::constellation_dqpsk::sptr":
        r"""make() -> constellation_dqpsk_sptr"""
        return _digital_swig2.constellation_dqpsk_make()
    __swig_destroy__ = _digital_swig2.delete_constellation_dqpsk

# Register constellation_dqpsk in _digital_swig2:
_digital_swig2.constellation_dqpsk_swigregister(constellation_dqpsk)

def constellation_dqpsk_make() -> "gr::digital::constellation_dqpsk::sptr":
    r"""constellation_dqpsk_make() -> constellation_dqpsk_sptr"""
    return _digital_swig2.constellation_dqpsk_make()

class constellation_8psk(constellation):
    r"""Proxy of C++ gr::digital::constellation_8psk class."""

    thisown = 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

    @staticmethod
    def make() -> "gr::digital::constellation_8psk::sptr":
        r"""make() -> constellation_8psk_sptr"""
        return _digital_swig2.constellation_8psk_make()
    __swig_destroy__ = _digital_swig2.delete_constellation_8psk

# Register constellation_8psk in _digital_swig2:
_digital_swig2.constellation_8psk_swigregister(constellation_8psk)

def constellation_8psk_make() -> "gr::digital::constellation_8psk::sptr":
    r"""constellation_8psk_make() -> constellation_8psk_sptr"""
    return _digital_swig2.constellation_8psk_make()

class constellation_8psk_natural(constellation):
    r"""Proxy of C++ gr::digital::constellation_8psk_natural class."""

    thisown = 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

    @staticmethod
    def make() -> "gr::digital::constellation_8psk_natural::sptr":
        r"""make() -> constellation_8psk_natural_sptr"""
        return _digital_swig2.constellation_8psk_natural_make()
    __swig_destroy__ = _digital_swig2.delete_constellation_8psk_natural

# Register constellation_8psk_natural in _digital_swig2:
_digital_swig2.constellation_8psk_natural_swigregister(constellation_8psk_natural)

def constellation_8psk_natural_make() -> "gr::digital::constellation_8psk_natural::sptr":
    r"""constellation_8psk_natural_make() -> constellation_8psk_natural_sptr"""
    return _digital_swig2.constellation_8psk_natural_make()

class constellation_16qam(constellation):
    r"""Proxy of C++ gr::digital::constellation_16qam class."""

    thisown = 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

    @staticmethod
    def make() -> "gr::digital::constellation_16qam::sptr":
        r"""make() -> constellation_16qam_sptr"""
        return _digital_swig2.constellation_16qam_make()
    __swig_destroy__ = _digital_swig2.delete_constellation_16qam

# Register constellation_16qam in _digital_swig2:
_digital_swig2.constellation_16qam_swigregister(constellation_16qam)

def constellation_16qam_make() -> "gr::digital::constellation_16qam::sptr":
    r"""constellation_16qam_make() -> constellation_16qam_sptr"""
    return _digital_swig2.constellation_16qam_make()

TED_NONE = _digital_swig2.TED_NONE

TED_MUELLER_AND_MULLER = _digital_swig2.TED_MUELLER_AND_MULLER

TED_MOD_MUELLER_AND_MULLER = _digital_swig2.TED_MOD_MUELLER_AND_MULLER

TED_ZERO_CROSSING = _digital_swig2.TED_ZERO_CROSSING

TED_GARDNER = _digital_swig2.TED_GARDNER

TED_EARLY_LATE = _digital_swig2.TED_EARLY_LATE

TED_DANDREA_AND_MENGALI_GEN_MSK = _digital_swig2.TED_DANDREA_AND_MENGALI_GEN_MSK

TED_SIGNAL_TIMES_SLOPE_ML = _digital_swig2.TED_SIGNAL_TIMES_SLOPE_ML

TED_SIGNUM_TIMES_SLOPE_ML = _digital_swig2.TED_SIGNUM_TIMES_SLOPE_ML

TED_MENGALI_AND_DANDREA_GMSK = _digital_swig2.TED_MENGALI_AND_DANDREA_GMSK

IR_NONE = _digital_swig2.IR_NONE

IR_MMSE_8TAP = _digital_swig2.IR_MMSE_8TAP

IR_PFB_NO_MF = _digital_swig2.IR_PFB_NO_MF

IR_PFB_MF = _digital_swig2.IR_PFB_MF

SNR_EST_SIMPLE = _digital_swig2.SNR_EST_SIMPLE

SNR_EST_SKEW = _digital_swig2.SNR_EST_SKEW

SNR_EST_M2M4 = _digital_swig2.SNR_EST_M2M4

SNR_EST_SVR = _digital_swig2.SNR_EST_SVR

class mpsk_snr_est(object):
    r"""Proxy of C++ gr::digital::mpsk_snr_est class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, alpha: "double"):
        r"""__init__(mpsk_snr_est self, double alpha) -> mpsk_snr_est"""
        _digital_swig2.mpsk_snr_est_swiginit(self, _digital_swig2.new_mpsk_snr_est(alpha))
    __swig_destroy__ = _digital_swig2.delete_mpsk_snr_est

    def alpha(self) -> "double":
        r"""alpha(mpsk_snr_est self) -> double"""
        return _digital_swig2.mpsk_snr_est_alpha(self)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(mpsk_snr_est self, double alpha)"""
        return _digital_swig2.mpsk_snr_est_set_alpha(self, alpha)

    def update(self, noutput_items: "int", input: "gr_complex const *") -> "int":
        r"""update(mpsk_snr_est self, int noutput_items, gr_complex const * input) -> int"""
        return _digital_swig2.mpsk_snr_est_update(self, noutput_items, input)

    def snr(self) -> "double":
        r"""snr(mpsk_snr_est self) -> double"""
        return _digital_swig2.mpsk_snr_est_snr(self)

    def signal(self) -> "double":
        r"""signal(mpsk_snr_est self) -> double"""
        return _digital_swig2.mpsk_snr_est_signal(self)

    def noise(self) -> "double":
        r"""noise(mpsk_snr_est self) -> double"""
        return _digital_swig2.mpsk_snr_est_noise(self)

# Register mpsk_snr_est in _digital_swig2:
_digital_swig2.mpsk_snr_est_swigregister(mpsk_snr_est)

class mpsk_snr_est_simple(mpsk_snr_est):
    r"""Proxy of C++ gr::digital::mpsk_snr_est_simple class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, alpha: "double"):
        r"""__init__(mpsk_snr_est_simple self, double alpha) -> mpsk_snr_est_simple"""
        _digital_swig2.mpsk_snr_est_simple_swiginit(self, _digital_swig2.new_mpsk_snr_est_simple(alpha))
    __swig_destroy__ = _digital_swig2.delete_mpsk_snr_est_simple

# Register mpsk_snr_est_simple in _digital_swig2:
_digital_swig2.mpsk_snr_est_simple_swigregister(mpsk_snr_est_simple)

class mpsk_snr_est_skew(mpsk_snr_est):
    r"""Proxy of C++ gr::digital::mpsk_snr_est_skew class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, alpha: "double"):
        r"""__init__(mpsk_snr_est_skew self, double alpha) -> mpsk_snr_est_skew"""
        _digital_swig2.mpsk_snr_est_skew_swiginit(self, _digital_swig2.new_mpsk_snr_est_skew(alpha))
    __swig_destroy__ = _digital_swig2.delete_mpsk_snr_est_skew

# Register mpsk_snr_est_skew in _digital_swig2:
_digital_swig2.mpsk_snr_est_skew_swigregister(mpsk_snr_est_skew)

class mpsk_snr_est_m2m4(mpsk_snr_est):
    r"""Proxy of C++ gr::digital::mpsk_snr_est_m2m4 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, alpha: "double"):
        r"""__init__(mpsk_snr_est_m2m4 self, double alpha) -> mpsk_snr_est_m2m4"""
        _digital_swig2.mpsk_snr_est_m2m4_swiginit(self, _digital_swig2.new_mpsk_snr_est_m2m4(alpha))
    __swig_destroy__ = _digital_swig2.delete_mpsk_snr_est_m2m4

# Register mpsk_snr_est_m2m4 in _digital_swig2:
_digital_swig2.mpsk_snr_est_m2m4_swigregister(mpsk_snr_est_m2m4)

class snr_est_m2m4(mpsk_snr_est):
    r"""Proxy of C++ gr::digital::snr_est_m2m4 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, alpha: "double", ka: "double", kw: "double"):
        r"""__init__(snr_est_m2m4 self, double alpha, double ka, double kw) -> snr_est_m2m4"""
        _digital_swig2.snr_est_m2m4_swiginit(self, _digital_swig2.new_snr_est_m2m4(alpha, ka, kw))
    __swig_destroy__ = _digital_swig2.delete_snr_est_m2m4

# Register snr_est_m2m4 in _digital_swig2:
_digital_swig2.snr_est_m2m4_swigregister(snr_est_m2m4)

class mpsk_snr_est_svr(mpsk_snr_est):
    r"""Proxy of C++ gr::digital::mpsk_snr_est_svr class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, alpha: "double"):
        r"""__init__(mpsk_snr_est_svr self, double alpha) -> mpsk_snr_est_svr"""
        _digital_swig2.mpsk_snr_est_svr_swiginit(self, _digital_swig2.new_mpsk_snr_est_svr(alpha))
    __swig_destroy__ = _digital_swig2.delete_mpsk_snr_est_svr

# Register mpsk_snr_est_svr in _digital_swig2:
_digital_swig2.mpsk_snr_est_svr_swigregister(mpsk_snr_est_svr)

class mpsk_snr_est_cc(object):
    r"""Proxy of C++ gr::digital::mpsk_snr_est_cc class."""

    thisown = 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

    @staticmethod
    def make(type: "gr::digital::snr_est_type_t", tag_nsamples: "int"=10000, alpha: "double"=0.001) -> "gr::digital::mpsk_snr_est_cc::sptr":
        r"""make(gr::digital::snr_est_type_t type, int tag_nsamples=10000, double alpha=0.001) -> mpsk_snr_est_cc_sptr"""
        return _digital_swig2.mpsk_snr_est_cc_make(type, tag_nsamples, alpha)

    def snr(self) -> "double":
        r"""snr(mpsk_snr_est_cc self) -> double"""
        return _digital_swig2.mpsk_snr_est_cc_snr(self)

    def type(self) -> "gr::digital::snr_est_type_t":
        r"""type(mpsk_snr_est_cc self) -> gr::digital::snr_est_type_t"""
        return _digital_swig2.mpsk_snr_est_cc_type(self)

    def tag_nsample(self) -> "int":
        r"""tag_nsample(mpsk_snr_est_cc self) -> int"""
        return _digital_swig2.mpsk_snr_est_cc_tag_nsample(self)

    def alpha(self) -> "double":
        r"""alpha(mpsk_snr_est_cc self) -> double"""
        return _digital_swig2.mpsk_snr_est_cc_alpha(self)

    def set_type(self, t: "gr::digital::snr_est_type_t") -> "void":
        r"""set_type(mpsk_snr_est_cc self, gr::digital::snr_est_type_t t)"""
        return _digital_swig2.mpsk_snr_est_cc_set_type(self, t)

    def set_tag_nsample(self, n: "int") -> "void":
        r"""set_tag_nsample(mpsk_snr_est_cc self, int n)"""
        return _digital_swig2.mpsk_snr_est_cc_set_tag_nsample(self, n)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(mpsk_snr_est_cc self, double alpha)"""
        return _digital_swig2.mpsk_snr_est_cc_set_alpha(self, alpha)
    __swig_destroy__ = _digital_swig2.delete_mpsk_snr_est_cc

# Register mpsk_snr_est_cc in _digital_swig2:
_digital_swig2.mpsk_snr_est_cc_swigregister(mpsk_snr_est_cc)

def mpsk_snr_est_cc_make(type: "gr::digital::snr_est_type_t", tag_nsamples: "int"=10000, alpha: "double"=0.001) -> "gr::digital::mpsk_snr_est_cc::sptr":
    r"""mpsk_snr_est_cc_make(gr::digital::snr_est_type_t type, int tag_nsamples=10000, double alpha=0.001) -> mpsk_snr_est_cc_sptr"""
    return _digital_swig2.mpsk_snr_est_cc_make(type, tag_nsamples, alpha)

class header_format_base(object):
    r"""Proxy of C++ gr::digital::header_format_base class."""

    thisown = 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__ = _digital_swig2.delete_header_format_base

    def base(self) -> "gr::digital::header_format_base::sptr":
        r"""base(header_format_base self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_base_base(self)

    def formatter(self) -> "gr::digital::header_format_base::sptr":
        r"""formatter(header_format_base self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_base_formatter(self)

    def format(self, nbytes_in: "int", input: "unsigned char const *", output: "swig_pmt_ptr", info: "swig_pmt_ptr") -> "bool":
        r"""format(header_format_base self, int nbytes_in, unsigned char const * input, swig_pmt_ptr output, swig_pmt_ptr info) -> bool"""
        return _digital_swig2.header_format_base_format(self, nbytes_in, input, output, info)

    def parse(self, nbits_in: "int", input: "unsigned char const *", info: "std::vector< pmt::pmt_t,std::allocator< pmt::pmt_t > > &", nbits_processed: "int &") -> "bool":
        r"""parse(header_format_base self, int nbits_in, unsigned char const * input, std::vector< pmt::pmt_t,std::allocator< pmt::pmt_t > > & info, int & nbits_processed) -> bool"""
        return _digital_swig2.header_format_base_parse(self, nbits_in, input, info, nbits_processed)

    def header_nbits(self) -> "size_t":
        r"""header_nbits(header_format_base self) -> size_t"""
        return _digital_swig2.header_format_base_header_nbits(self)

    def header_nbytes(self) -> "size_t":
        r"""header_nbytes(header_format_base self) -> size_t"""
        return _digital_swig2.header_format_base_header_nbytes(self)

# Register header_format_base in _digital_swig2:
_digital_swig2.header_format_base_swigregister(header_format_base)

class header_format_default(header_format_base):
    r"""Proxy of C++ gr::digital::header_format_default class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, access_code: "std::string const &", threshold: "int", bps: "int"):
        r"""__init__(header_format_default self, std::string const & access_code, int threshold, int bps) -> header_format_default"""
        _digital_swig2.header_format_default_swiginit(self, _digital_swig2.new_header_format_default(access_code, threshold, bps))
    __swig_destroy__ = _digital_swig2.delete_header_format_default

    def set_access_code(self, access_code: "std::string const &") -> "bool":
        r"""set_access_code(header_format_default self, std::string const & access_code) -> bool"""
        return _digital_swig2.header_format_default_set_access_code(self, access_code)

    def access_code(self) -> "unsigned long long":
        r"""access_code(header_format_default self) -> unsigned long long"""
        return _digital_swig2.header_format_default_access_code(self)

    def set_threshold(self, thresh: "unsigned int"=0) -> "void":
        r"""set_threshold(header_format_default self, unsigned int thresh=0)"""
        return _digital_swig2.header_format_default_set_threshold(self, thresh)

    def threshold(self) -> "unsigned int":
        r"""threshold(header_format_default self) -> unsigned int"""
        return _digital_swig2.header_format_default_threshold(self)

    @staticmethod
    def make(access_code: "std::string const &", threshold: "int", bps: "int"=1) -> "gr::digital::header_format_base::sptr":
        r"""make(std::string const & access_code, int threshold, int bps=1) -> header_format_base_sptr"""
        return _digital_swig2.header_format_default_make(access_code, threshold, bps)

# Register header_format_default in _digital_swig2:
_digital_swig2.header_format_default_swigregister(header_format_default)

def header_format_default_make(access_code: "std::string const &", threshold: "int", bps: "int"=1) -> "gr::digital::header_format_base::sptr":
    r"""header_format_default_make(std::string const & access_code, int threshold, int bps=1) -> header_format_base_sptr"""
    return _digital_swig2.header_format_default_make(access_code, threshold, bps)

class header_format_counter(header_format_default):
    r"""Proxy of C++ gr::digital::header_format_counter class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, access_code: "std::string const &", threshold: "int", bps: "int"):
        r"""__init__(header_format_counter self, std::string const & access_code, int threshold, int bps) -> header_format_counter"""
        _digital_swig2.header_format_counter_swiginit(self, _digital_swig2.new_header_format_counter(access_code, threshold, bps))
    __swig_destroy__ = _digital_swig2.delete_header_format_counter

    @staticmethod
    def make(access_code: "std::string const &", threshold: "int", bps: "int") -> "gr::digital::header_format_base::sptr":
        r"""make(std::string const & access_code, int threshold, int bps) -> header_format_base_sptr"""
        return _digital_swig2.header_format_counter_make(access_code, threshold, bps)

# Register header_format_counter in _digital_swig2:
_digital_swig2.header_format_counter_swigregister(header_format_counter)

def header_format_counter_make(access_code: "std::string const &", threshold: "int", bps: "int") -> "gr::digital::header_format_base::sptr":
    r"""header_format_counter_make(std::string const & access_code, int threshold, int bps) -> header_format_base_sptr"""
    return _digital_swig2.header_format_counter_make(access_code, threshold, bps)

class header_format_crc(header_format_base):
    r"""Proxy of C++ gr::digital::header_format_crc class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        r"""__init__(header_format_crc self, std::string const & len_key_name="packet_len", std::string const & num_key_name="packet_num") -> header_format_crc"""
        _digital_swig2.header_format_crc_swiginit(self, _digital_swig2.new_header_format_crc(*args, **kwargs))
    __swig_destroy__ = _digital_swig2.delete_header_format_crc

    def set_header_num(self, header_num: "unsigned int") -> "void":
        r"""set_header_num(header_format_crc self, unsigned int header_num)"""
        return _digital_swig2.header_format_crc_set_header_num(self, header_num)

    @staticmethod
    def make(*args, **kwargs) -> "gr::digital::header_format_base::sptr":
        r"""make(std::string const & len_key_name="packet_len", std::string const & num_key_name="packet_num") -> header_format_base_sptr"""
        return _digital_swig2.header_format_crc_make(*args, **kwargs)

# Register header_format_crc in _digital_swig2:
_digital_swig2.header_format_crc_swigregister(header_format_crc)

def header_format_crc_make(*args, **kwargs) -> "gr::digital::header_format_base::sptr":
    r"""header_format_crc_make(std::string const & len_key_name="packet_len", std::string const & num_key_name="packet_num") -> header_format_base_sptr"""
    return _digital_swig2.header_format_crc_make(*args, **kwargs)

class header_format_ofdm(header_format_crc):
    r"""Proxy of C++ gr::digital::header_format_ofdm class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        r"""__init__(header_format_ofdm self, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers, int n_syms, std::string const & len_key_name="packet_len", std::string const & frame_key_name="frame_len", std::string const & num_key_name="packet_num", int bits_per_header_sym=1, int bits_per_payload_sym=1, bool scramble_header=False) -> header_format_ofdm"""
        _digital_swig2.header_format_ofdm_swiginit(self, _digital_swig2.new_header_format_ofdm(*args, **kwargs))
    __swig_destroy__ = _digital_swig2.delete_header_format_ofdm

    @staticmethod
    def make(*args, **kwargs) -> "gr::digital::header_format_base::sptr":
        r"""make(std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers, int n_syms, std::string const & len_key_name="packet_len", std::string const & frame_key_name="frame_len", std::string const & num_key_name="packet_num", int bits_per_header_sym=1, int bits_per_payload_sym=1, bool scramble_header=False) -> header_format_base_sptr"""
        return _digital_swig2.header_format_ofdm_make(*args, **kwargs)

# Register header_format_ofdm in _digital_swig2:
_digital_swig2.header_format_ofdm_swigregister(header_format_ofdm)

def header_format_ofdm_make(*args, **kwargs) -> "gr::digital::header_format_base::sptr":
    r"""header_format_ofdm_make(std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers, int n_syms, std::string const & len_key_name="packet_len", std::string const & frame_key_name="frame_len", std::string const & num_key_name="packet_num", int bits_per_header_sym=1, int bits_per_payload_sym=1, bool scramble_header=False) -> header_format_base_sptr"""
    return _digital_swig2.header_format_ofdm_make(*args, **kwargs)

class protocol_formatter_async(object):
    r"""Proxy of C++ gr::digital::protocol_formatter_async class."""

    thisown = 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

    @staticmethod
    def make(format: "header_format_base_sptr") -> "gr::digital::protocol_formatter_async::sptr":
        r"""make(header_format_base_sptr format) -> protocol_formatter_async_sptr"""
        return _digital_swig2.protocol_formatter_async_make(format)
    __swig_destroy__ = _digital_swig2.delete_protocol_formatter_async

# Register protocol_formatter_async in _digital_swig2:
_digital_swig2.protocol_formatter_async_swigregister(protocol_formatter_async)

def protocol_formatter_async_make(format: "header_format_base_sptr") -> "gr::digital::protocol_formatter_async::sptr":
    r"""protocol_formatter_async_make(header_format_base_sptr format) -> protocol_formatter_async_sptr"""
    return _digital_swig2.protocol_formatter_async_make(format)

class protocol_formatter_bb(object):
    r"""Proxy of C++ gr::digital::protocol_formatter_bb class."""

    thisown = 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

    @staticmethod
    def make(*args, **kwargs) -> "gr::digital::protocol_formatter_bb::sptr":
        r"""make(header_format_base_sptr format, std::string const & len_tag_key="packet_len") -> protocol_formatter_bb_sptr"""
        return _digital_swig2.protocol_formatter_bb_make(*args, **kwargs)

    def set_header_format(self, format: "header_format_base_sptr") -> "void":
        r"""set_header_format(protocol_formatter_bb self, header_format_base_sptr format)"""
        return _digital_swig2.protocol_formatter_bb_set_header_format(self, format)
    __swig_destroy__ = _digital_swig2.delete_protocol_formatter_bb

# Register protocol_formatter_bb in _digital_swig2:
_digital_swig2.protocol_formatter_bb_swigregister(protocol_formatter_bb)

def protocol_formatter_bb_make(*args, **kwargs) -> "gr::digital::protocol_formatter_bb::sptr":
    r"""protocol_formatter_bb_make(header_format_base_sptr format, std::string const & len_tag_key="packet_len") -> protocol_formatter_bb_sptr"""
    return _digital_swig2.protocol_formatter_bb_make(*args, **kwargs)

class protocol_parser_b(object):
    r"""Proxy of C++ gr::digital::protocol_parser_b class."""

    thisown = 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

    @staticmethod
    def make(format: "header_format_base_sptr") -> "gr::digital::protocol_parser_b::sptr":
        r"""make(header_format_base_sptr format) -> protocol_parser_b_sptr"""
        return _digital_swig2.protocol_parser_b_make(format)
    __swig_destroy__ = _digital_swig2.delete_protocol_parser_b

# Register protocol_parser_b in _digital_swig2:
_digital_swig2.protocol_parser_b_swigregister(protocol_parser_b)

def protocol_parser_b_make(format: "header_format_base_sptr") -> "gr::digital::protocol_parser_b::sptr":
    r"""protocol_parser_b_make(header_format_base_sptr format) -> protocol_parser_b_sptr"""
    return _digital_swig2.protocol_parser_b_make(format)

class packet_header_default(object):
    r"""Proxy of C++ gr::digital::packet_header_default class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        r"""__init__(packet_header_default self, long header_len, std::string const & len_tag_key="packet_len", std::string const & num_tag_key="packet_num", int bits_per_byte=1) -> packet_header_default"""
        _digital_swig2.packet_header_default_swiginit(self, _digital_swig2.new_packet_header_default(*args, **kwargs))
    __swig_destroy__ = _digital_swig2.delete_packet_header_default

    def base(self) -> "gr::digital::packet_header_default::sptr":
        r"""base(packet_header_default self) -> packet_header_default_sptr"""
        return _digital_swig2.packet_header_default_base(self)

    def formatter(self) -> "gr::digital::packet_header_default::sptr":
        r"""formatter(packet_header_default self) -> packet_header_default_sptr"""
        return _digital_swig2.packet_header_default_formatter(self)

    def set_header_num(self, header_num: "unsigned int") -> "void":
        r"""set_header_num(packet_header_default self, unsigned int header_num)"""
        return _digital_swig2.packet_header_default_set_header_num(self, header_num)

    def header_len(self) -> "long":
        r"""header_len(packet_header_default self) -> long"""
        return _digital_swig2.packet_header_default_header_len(self)

    def len_tag_key(self) -> "pmt::pmt_t":
        r"""len_tag_key(packet_header_default self) -> swig_pmt_ptr"""
        return _digital_swig2.packet_header_default_len_tag_key(self)

    def header_formatter(self, *args, **kwargs) -> "bool":
        r"""header_formatter(packet_header_default self, long packet_len, unsigned char * out, tags_vector_t tags=std::vector< gr::tag_t >()) -> bool"""
        return _digital_swig2.packet_header_default_header_formatter(self, *args, **kwargs)

    def header_parser(self, header: "unsigned char const *", tags: "tags_vector_t") -> "bool":
        r"""header_parser(packet_header_default self, unsigned char const * header, tags_vector_t tags) -> bool"""
        return _digital_swig2.packet_header_default_header_parser(self, header, tags)

    @staticmethod
    def make(*args, **kwargs) -> "gr::digital::packet_header_default::sptr":
        r"""make(long header_len, std::string const & len_tag_key="packet_len", std::string const & num_tag_key="packet_num", int bits_per_byte=1) -> packet_header_default_sptr"""
        return _digital_swig2.packet_header_default_make(*args, **kwargs)

# Register packet_header_default in _digital_swig2:
_digital_swig2.packet_header_default_swigregister(packet_header_default)

def packet_header_default_make(*args, **kwargs) -> "gr::digital::packet_header_default::sptr":
    r"""packet_header_default_make(long header_len, std::string const & len_tag_key="packet_len", std::string const & num_tag_key="packet_num", int bits_per_byte=1) -> packet_header_default_sptr"""
    return _digital_swig2.packet_header_default_make(*args, **kwargs)

class packet_header_ofdm(packet_header_default):
    r"""Proxy of C++ gr::digital::packet_header_ofdm class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, occupied_carriers: "std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &", n_syms: "int", len_tag_key: "std::string const &", frame_len_tag_key: "std::string const &", num_tag_key: "std::string const &", bits_per_header_sym: "int", bits_per_payload_sym: "int", scramble_header: "bool"):
        r"""__init__(packet_header_ofdm self, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers, int n_syms, std::string const & len_tag_key, std::string const & frame_len_tag_key, std::string const & num_tag_key, int bits_per_header_sym, int bits_per_payload_sym, bool scramble_header) -> packet_header_ofdm"""
        _digital_swig2.packet_header_ofdm_swiginit(self, _digital_swig2.new_packet_header_ofdm(occupied_carriers, n_syms, len_tag_key, frame_len_tag_key, num_tag_key, bits_per_header_sym, bits_per_payload_sym, scramble_header))
    __swig_destroy__ = _digital_swig2.delete_packet_header_ofdm

    @staticmethod
    def make(*args, **kwargs) -> "gr::digital::packet_header_ofdm::sptr":
        r"""make(std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers, int n_syms, std::string const & len_tag_key="packet_len", std::string const & frame_len_tag_key="frame_len", std::string const & num_tag_key="packet_num", int bits_per_header_sym=1, int bits_per_payload_sym=1, bool scramble_header=False) -> packet_header_ofdm_sptr"""
        return _digital_swig2.packet_header_ofdm_make(*args, **kwargs)

# Register packet_header_ofdm in _digital_swig2:
_digital_swig2.packet_header_ofdm_swigregister(packet_header_ofdm)

def packet_header_ofdm_make(*args, **kwargs) -> "gr::digital::packet_header_ofdm::sptr":
    r"""packet_header_ofdm_make(std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers, int n_syms, std::string const & len_tag_key="packet_len", std::string const & frame_len_tag_key="frame_len", std::string const & num_tag_key="packet_num", int bits_per_header_sym=1, int bits_per_payload_sym=1, bool scramble_header=False) -> packet_header_ofdm_sptr"""
    return _digital_swig2.packet_header_ofdm_make(*args, **kwargs)

class packet_headergenerator_bb(object):
    r"""Proxy of C++ gr::digital::packet_headergenerator_bb class."""

    thisown = 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

    @staticmethod
    def make(*args) -> "gr::digital::packet_headergenerator_bb::sptr":
        r"""
        make(packet_header_default_sptr header_formatter, std::string const & len_tag_key="packet_len") -> packet_headergenerator_bb_sptr
        make(long header_len, std::string const & len_tag_key="packet_len") -> packet_headergenerator_bb_sptr
        """
        return _digital_swig2.packet_headergenerator_bb_make(*args)

    def set_header_formatter(self, header_formatter: "packet_header_default_sptr") -> "void":
        r"""set_header_formatter(packet_headergenerator_bb self, packet_header_default_sptr header_formatter)"""
        return _digital_swig2.packet_headergenerator_bb_set_header_formatter(self, header_formatter)
    __swig_destroy__ = _digital_swig2.delete_packet_headergenerator_bb

# Register packet_headergenerator_bb in _digital_swig2:
_digital_swig2.packet_headergenerator_bb_swigregister(packet_headergenerator_bb)

def packet_headergenerator_bb_make(*args) -> "gr::digital::packet_headergenerator_bb::sptr":
    r"""
    packet_headergenerator_bb_make(packet_header_default_sptr header_formatter, std::string const & len_tag_key="packet_len") -> packet_headergenerator_bb_sptr
    packet_headergenerator_bb_make(long header_len, std::string const & len_tag_key="packet_len") -> packet_headergenerator_bb_sptr
    """
    return _digital_swig2.packet_headergenerator_bb_make(*args)

class packet_headerparser_b(object):
    r"""Proxy of C++ gr::digital::packet_headerparser_b class."""

    thisown = 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

    @staticmethod
    def make(*args) -> "gr::digital::packet_headerparser_b::sptr":
        r"""
        make(packet_header_default_sptr header_formatter) -> packet_headerparser_b_sptr
        make(long header_len, std::string const & len_tag_key) -> packet_headerparser_b_sptr
        """
        return _digital_swig2.packet_headerparser_b_make(*args)
    __swig_destroy__ = _digital_swig2.delete_packet_headerparser_b

# Register packet_headerparser_b in _digital_swig2:
_digital_swig2.packet_headerparser_b_swigregister(packet_headerparser_b)

def packet_headerparser_b_make(*args) -> "gr::digital::packet_headerparser_b::sptr":
    r"""
    packet_headerparser_b_make(packet_header_default_sptr header_formatter) -> packet_headerparser_b_sptr
    packet_headerparser_b_make(long header_len, std::string const & len_tag_key) -> packet_headerparser_b_sptr
    """
    return _digital_swig2.packet_headerparser_b_make(*args)

class packet_sink(object):
    r"""Proxy of C++ gr::digital::packet_sink class."""

    thisown = 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

    @staticmethod
    def make(sync_vector: "std::vector< unsigned char,std::allocator< unsigned char > > const &", target_queue: "msg_queue_sptr", threshold: "int"=-1) -> "gr::digital::packet_sink::sptr":
        r"""make(std::vector< unsigned char,std::allocator< unsigned char > > const & sync_vector, msg_queue_sptr target_queue, int threshold=-1) -> packet_sink_sptr"""
        return _digital_swig2.packet_sink_make(sync_vector, target_queue, threshold)

    def carrier_sensed(self) -> "bool":
        r"""carrier_sensed(packet_sink self) -> bool"""
        return _digital_swig2.packet_sink_carrier_sensed(self)
    __swig_destroy__ = _digital_swig2.delete_packet_sink

# Register packet_sink in _digital_swig2:
_digital_swig2.packet_sink_swigregister(packet_sink)

def packet_sink_make(sync_vector: "std::vector< unsigned char,std::allocator< unsigned char > > const &", target_queue: "msg_queue_sptr", threshold: "int"=-1) -> "gr::digital::packet_sink::sptr":
    r"""packet_sink_make(std::vector< unsigned char,std::allocator< unsigned char > > const & sync_vector, msg_queue_sptr target_queue, int threshold=-1) -> packet_sink_sptr"""
    return _digital_swig2.packet_sink_make(sync_vector, target_queue, threshold)

class pfb_clock_sync_ccf(object):
    r"""Proxy of C++ gr::digital::pfb_clock_sync_ccf class."""

    thisown = 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

    @staticmethod
    def make(sps: "double", loop_bw: "float", taps: "pmt_vector_float", filter_size: "unsigned int"=32, init_phase: "float"=0, max_rate_deviation: "float"=1.5, osps: "int"=1) -> "gr::digital::pfb_clock_sync_ccf::sptr":
        r"""make(double sps, float loop_bw, pmt_vector_float taps, unsigned int filter_size=32, float init_phase=0, float max_rate_deviation=1.5, int osps=1) -> pfb_clock_sync_ccf_sptr"""
        return _digital_swig2.pfb_clock_sync_ccf_make(sps, loop_bw, taps, filter_size, init_phase, max_rate_deviation, osps)

    def update_gains(self) -> "void":
        r"""update_gains(pfb_clock_sync_ccf self)"""
        return _digital_swig2.pfb_clock_sync_ccf_update_gains(self)

    def update_taps(self, taps: "pmt_vector_float") -> "void":
        r"""update_taps(pfb_clock_sync_ccf self, pmt_vector_float taps)"""
        return _digital_swig2.pfb_clock_sync_ccf_update_taps(self, taps)

    def set_taps(self, taps: "pmt_vector_float", ourtaps: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > &", ourfilter: "std::vector< gr::filter::kernel::fir_filter_ccf *,std::allocator< gr::filter::kernel::fir_filter_ccf * > > &") -> "void":
        r"""set_taps(pfb_clock_sync_ccf self, pmt_vector_float taps, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > & ourtaps, std::vector< gr::filter::kernel::fir_filter_ccf *,std::allocator< gr::filter::kernel::fir_filter_ccf * > > & ourfilter)"""
        return _digital_swig2.pfb_clock_sync_ccf_set_taps(self, taps, ourtaps, ourfilter)

    def taps(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""taps(pfb_clock_sync_ccf self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.pfb_clock_sync_ccf_taps(self)

    def diff_taps(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""diff_taps(pfb_clock_sync_ccf self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.pfb_clock_sync_ccf_diff_taps(self)

    def channel_taps(self, channel: "int") -> "std::vector< float,std::allocator< float > >":
        r"""channel_taps(pfb_clock_sync_ccf self, int channel) -> pmt_vector_float"""
        return _digital_swig2.pfb_clock_sync_ccf_channel_taps(self, channel)

    def diff_channel_taps(self, channel: "int") -> "std::vector< float,std::allocator< float > >":
        r"""diff_channel_taps(pfb_clock_sync_ccf self, int channel) -> pmt_vector_float"""
        return _digital_swig2.pfb_clock_sync_ccf_diff_channel_taps(self, channel)

    def taps_as_string(self) -> "std::string":
        r"""taps_as_string(pfb_clock_sync_ccf self) -> std::string"""
        return _digital_swig2.pfb_clock_sync_ccf_taps_as_string(self)

    def diff_taps_as_string(self) -> "std::string":
        r"""diff_taps_as_string(pfb_clock_sync_ccf self) -> std::string"""
        return _digital_swig2.pfb_clock_sync_ccf_diff_taps_as_string(self)

    def set_loop_bandwidth(self, bw: "float") -> "void":
        r"""set_loop_bandwidth(pfb_clock_sync_ccf self, float bw)"""
        return _digital_swig2.pfb_clock_sync_ccf_set_loop_bandwidth(self, bw)

    def set_damping_factor(self, df: "float") -> "void":
        r"""set_damping_factor(pfb_clock_sync_ccf self, float df)"""
        return _digital_swig2.pfb_clock_sync_ccf_set_damping_factor(self, df)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(pfb_clock_sync_ccf self, float alpha)"""
        return _digital_swig2.pfb_clock_sync_ccf_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(pfb_clock_sync_ccf self, float beta)"""
        return _digital_swig2.pfb_clock_sync_ccf_set_beta(self, beta)

    def set_max_rate_deviation(self, m: "float") -> "void":
        r"""set_max_rate_deviation(pfb_clock_sync_ccf self, float m)"""
        return _digital_swig2.pfb_clock_sync_ccf_set_max_rate_deviation(self, m)

    def loop_bandwidth(self) -> "float":
        r"""loop_bandwidth(pfb_clock_sync_ccf self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_loop_bandwidth(self)

    def damping_factor(self) -> "float":
        r"""damping_factor(pfb_clock_sync_ccf self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_damping_factor(self)

    def alpha(self) -> "float":
        r"""alpha(pfb_clock_sync_ccf self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_alpha(self)

    def beta(self) -> "float":
        r"""beta(pfb_clock_sync_ccf self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_beta(self)

    def clock_rate(self) -> "float":
        r"""clock_rate(pfb_clock_sync_ccf self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_clock_rate(self)

    def error(self) -> "float":
        r"""error(pfb_clock_sync_ccf self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_error(self)

    def rate(self) -> "float":
        r"""rate(pfb_clock_sync_ccf self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_rate(self)

    def phase(self) -> "float":
        r"""phase(pfb_clock_sync_ccf self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_phase(self)
    __swig_destroy__ = _digital_swig2.delete_pfb_clock_sync_ccf

# Register pfb_clock_sync_ccf in _digital_swig2:
_digital_swig2.pfb_clock_sync_ccf_swigregister(pfb_clock_sync_ccf)

def pfb_clock_sync_ccf_make(sps: "double", loop_bw: "float", taps: "pmt_vector_float", filter_size: "unsigned int"=32, init_phase: "float"=0, max_rate_deviation: "float"=1.5, osps: "int"=1) -> "gr::digital::pfb_clock_sync_ccf::sptr":
    r"""pfb_clock_sync_ccf_make(double sps, float loop_bw, pmt_vector_float taps, unsigned int filter_size=32, float init_phase=0, float max_rate_deviation=1.5, int osps=1) -> pfb_clock_sync_ccf_sptr"""
    return _digital_swig2.pfb_clock_sync_ccf_make(sps, loop_bw, taps, filter_size, init_phase, max_rate_deviation, osps)

class pfb_clock_sync_fff(object):
    r"""Proxy of C++ gr::digital::pfb_clock_sync_fff class."""

    thisown = 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

    @staticmethod
    def make(sps: "double", gain: "float", taps: "pmt_vector_float", filter_size: "unsigned int"=32, init_phase: "float"=0, max_rate_deviation: "float"=1.5, osps: "int"=1) -> "gr::digital::pfb_clock_sync_fff::sptr":
        r"""make(double sps, float gain, pmt_vector_float taps, unsigned int filter_size=32, float init_phase=0, float max_rate_deviation=1.5, int osps=1) -> pfb_clock_sync_fff_sptr"""
        return _digital_swig2.pfb_clock_sync_fff_make(sps, gain, taps, filter_size, init_phase, max_rate_deviation, osps)

    def update_gains(self) -> "void":
        r"""update_gains(pfb_clock_sync_fff self)"""
        return _digital_swig2.pfb_clock_sync_fff_update_gains(self)

    def update_taps(self, taps: "pmt_vector_float") -> "void":
        r"""update_taps(pfb_clock_sync_fff self, pmt_vector_float taps)"""
        return _digital_swig2.pfb_clock_sync_fff_update_taps(self, taps)

    def set_taps(self, taps: "pmt_vector_float", ourtaps: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > &", ourfilter: "std::vector< gr::filter::kernel::fir_filter_fff *,std::allocator< gr::filter::kernel::fir_filter_fff * > > &") -> "void":
        r"""set_taps(pfb_clock_sync_fff self, pmt_vector_float taps, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > & ourtaps, std::vector< gr::filter::kernel::fir_filter_fff *,std::allocator< gr::filter::kernel::fir_filter_fff * > > & ourfilter)"""
        return _digital_swig2.pfb_clock_sync_fff_set_taps(self, taps, ourtaps, ourfilter)

    def taps(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""taps(pfb_clock_sync_fff self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.pfb_clock_sync_fff_taps(self)

    def diff_taps(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""diff_taps(pfb_clock_sync_fff self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.pfb_clock_sync_fff_diff_taps(self)

    def channel_taps(self, channel: "int") -> "std::vector< float,std::allocator< float > >":
        r"""channel_taps(pfb_clock_sync_fff self, int channel) -> pmt_vector_float"""
        return _digital_swig2.pfb_clock_sync_fff_channel_taps(self, channel)

    def diff_channel_taps(self, channel: "int") -> "std::vector< float,std::allocator< float > >":
        r"""diff_channel_taps(pfb_clock_sync_fff self, int channel) -> pmt_vector_float"""
        return _digital_swig2.pfb_clock_sync_fff_diff_channel_taps(self, channel)

    def taps_as_string(self) -> "std::string":
        r"""taps_as_string(pfb_clock_sync_fff self) -> std::string"""
        return _digital_swig2.pfb_clock_sync_fff_taps_as_string(self)

    def diff_taps_as_string(self) -> "std::string":
        r"""diff_taps_as_string(pfb_clock_sync_fff self) -> std::string"""
        return _digital_swig2.pfb_clock_sync_fff_diff_taps_as_string(self)

    def set_loop_bandwidth(self, bw: "float") -> "void":
        r"""set_loop_bandwidth(pfb_clock_sync_fff self, float bw)"""
        return _digital_swig2.pfb_clock_sync_fff_set_loop_bandwidth(self, bw)

    def set_damping_factor(self, df: "float") -> "void":
        r"""set_damping_factor(pfb_clock_sync_fff self, float df)"""
        return _digital_swig2.pfb_clock_sync_fff_set_damping_factor(self, df)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(pfb_clock_sync_fff self, float alpha)"""
        return _digital_swig2.pfb_clock_sync_fff_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(pfb_clock_sync_fff self, float beta)"""
        return _digital_swig2.pfb_clock_sync_fff_set_beta(self, beta)

    def set_max_rate_deviation(self, m: "float") -> "void":
        r"""set_max_rate_deviation(pfb_clock_sync_fff self, float m)"""
        return _digital_swig2.pfb_clock_sync_fff_set_max_rate_deviation(self, m)

    def loop_bandwidth(self) -> "float":
        r"""loop_bandwidth(pfb_clock_sync_fff self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_loop_bandwidth(self)

    def damping_factor(self) -> "float":
        r"""damping_factor(pfb_clock_sync_fff self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_damping_factor(self)

    def alpha(self) -> "float":
        r"""alpha(pfb_clock_sync_fff self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_alpha(self)

    def beta(self) -> "float":
        r"""beta(pfb_clock_sync_fff self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_beta(self)

    def clock_rate(self) -> "float":
        r"""clock_rate(pfb_clock_sync_fff self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_clock_rate(self)
    __swig_destroy__ = _digital_swig2.delete_pfb_clock_sync_fff

# Register pfb_clock_sync_fff in _digital_swig2:
_digital_swig2.pfb_clock_sync_fff_swigregister(pfb_clock_sync_fff)

def pfb_clock_sync_fff_make(sps: "double", gain: "float", taps: "pmt_vector_float", filter_size: "unsigned int"=32, init_phase: "float"=0, max_rate_deviation: "float"=1.5, osps: "int"=1) -> "gr::digital::pfb_clock_sync_fff::sptr":
    r"""pfb_clock_sync_fff_make(double sps, float gain, pmt_vector_float taps, unsigned int filter_size=32, float init_phase=0, float max_rate_deviation=1.5, int osps=1) -> pfb_clock_sync_fff_sptr"""
    return _digital_swig2.pfb_clock_sync_fff_make(sps, gain, taps, filter_size, init_phase, max_rate_deviation, osps)

class pn_correlator_cc(object):
    r"""Proxy of C++ gr::digital::pn_correlator_cc class."""

    thisown = 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

    @staticmethod
    def make(degree: "int", mask: "int"=0, seed: "int"=1) -> "gr::digital::pn_correlator_cc::sptr":
        r"""make(int degree, int mask=0, int seed=1) -> pn_correlator_cc_sptr"""
        return _digital_swig2.pn_correlator_cc_make(degree, mask, seed)
    __swig_destroy__ = _digital_swig2.delete_pn_correlator_cc

# Register pn_correlator_cc in _digital_swig2:
_digital_swig2.pn_correlator_cc_swigregister(pn_correlator_cc)

def pn_correlator_cc_make(degree: "int", mask: "int"=0, seed: "int"=1) -> "gr::digital::pn_correlator_cc::sptr":
    r"""pn_correlator_cc_make(int degree, int mask=0, int seed=1) -> pn_correlator_cc_sptr"""
    return _digital_swig2.pn_correlator_cc_make(degree, mask, seed)

class probe_density_b(object):
    r"""Proxy of C++ gr::digital::probe_density_b class."""

    thisown = 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

    @staticmethod
    def make(alpha: "double") -> "gr::digital::probe_density_b::sptr":
        r"""make(double alpha) -> probe_density_b_sptr"""
        return _digital_swig2.probe_density_b_make(alpha)

    def density(self) -> "double":
        r"""density(probe_density_b self) -> double"""
        return _digital_swig2.probe_density_b_density(self)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(probe_density_b self, double alpha)"""
        return _digital_swig2.probe_density_b_set_alpha(self, alpha)
    __swig_destroy__ = _digital_swig2.delete_probe_density_b

# Register probe_density_b in _digital_swig2:
_digital_swig2.probe_density_b_swigregister(probe_density_b)

def probe_density_b_make(alpha: "double") -> "gr::digital::probe_density_b::sptr":
    r"""probe_density_b_make(double alpha) -> probe_density_b_sptr"""
    return _digital_swig2.probe_density_b_make(alpha)

class probe_mpsk_snr_est_c(object):
    r"""Proxy of C++ gr::digital::probe_mpsk_snr_est_c class."""

    thisown = 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

    @staticmethod
    def make(type: "gr::digital::snr_est_type_t", msg_nsamples: "int"=10000, alpha: "double"=0.001) -> "gr::digital::probe_mpsk_snr_est_c::sptr":
        r"""make(gr::digital::snr_est_type_t type, int msg_nsamples=10000, double alpha=0.001) -> probe_mpsk_snr_est_c_sptr"""
        return _digital_swig2.probe_mpsk_snr_est_c_make(type, msg_nsamples, alpha)

    def snr(self) -> "double":
        r"""snr(probe_mpsk_snr_est_c self) -> double"""
        return _digital_swig2.probe_mpsk_snr_est_c_snr(self)

    def signal(self) -> "double":
        r"""signal(probe_mpsk_snr_est_c self) -> double"""
        return _digital_swig2.probe_mpsk_snr_est_c_signal(self)

    def noise(self) -> "double":
        r"""noise(probe_mpsk_snr_est_c self) -> double"""
        return _digital_swig2.probe_mpsk_snr_est_c_noise(self)

    def type(self) -> "gr::digital::snr_est_type_t":
        r"""type(probe_mpsk_snr_est_c self) -> gr::digital::snr_est_type_t"""
        return _digital_swig2.probe_mpsk_snr_est_c_type(self)

    def msg_nsample(self) -> "int":
        r"""msg_nsample(probe_mpsk_snr_est_c self) -> int"""
        return _digital_swig2.probe_mpsk_snr_est_c_msg_nsample(self)

    def alpha(self) -> "double":
        r"""alpha(probe_mpsk_snr_est_c self) -> double"""
        return _digital_swig2.probe_mpsk_snr_est_c_alpha(self)

    def set_type(self, t: "gr::digital::snr_est_type_t") -> "void":
        r"""set_type(probe_mpsk_snr_est_c self, gr::digital::snr_est_type_t t)"""
        return _digital_swig2.probe_mpsk_snr_est_c_set_type(self, t)

    def set_msg_nsample(self, n: "int") -> "void":
        r"""set_msg_nsample(probe_mpsk_snr_est_c self, int n)"""
        return _digital_swig2.probe_mpsk_snr_est_c_set_msg_nsample(self, n)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(probe_mpsk_snr_est_c self, double alpha)"""
        return _digital_swig2.probe_mpsk_snr_est_c_set_alpha(self, alpha)
    __swig_destroy__ = _digital_swig2.delete_probe_mpsk_snr_est_c

# Register probe_mpsk_snr_est_c in _digital_swig2:
_digital_swig2.probe_mpsk_snr_est_c_swigregister(probe_mpsk_snr_est_c)

def probe_mpsk_snr_est_c_make(type: "gr::digital::snr_est_type_t", msg_nsamples: "int"=10000, alpha: "double"=0.001) -> "gr::digital::probe_mpsk_snr_est_c::sptr":
    r"""probe_mpsk_snr_est_c_make(gr::digital::snr_est_type_t type, int msg_nsamples=10000, double alpha=0.001) -> probe_mpsk_snr_est_c_sptr"""
    return _digital_swig2.probe_mpsk_snr_est_c_make(type, msg_nsamples, alpha)

class scrambler_bb(object):
    r"""Proxy of C++ gr::digital::scrambler_bb class."""

    thisown = 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

    @staticmethod
    def make(mask: "int", seed: "int", len: "int") -> "gr::digital::scrambler_bb::sptr":
        r"""make(int mask, int seed, int len) -> scrambler_bb_sptr"""
        return _digital_swig2.scrambler_bb_make(mask, seed, len)
    __swig_destroy__ = _digital_swig2.delete_scrambler_bb

# Register scrambler_bb in _digital_swig2:
_digital_swig2.scrambler_bb_swigregister(scrambler_bb)

def scrambler_bb_make(mask: "int", seed: "int", len: "int") -> "gr::digital::scrambler_bb::sptr":
    r"""scrambler_bb_make(int mask, int seed, int len) -> scrambler_bb_sptr"""
    return _digital_swig2.scrambler_bb_make(mask, seed, len)

class simple_correlator(object):
    r"""Proxy of C++ gr::digital::simple_correlator class."""

    thisown = 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

    @staticmethod
    def make(payload_bytesize: "int") -> "gr::digital::simple_correlator::sptr":
        r"""make(int payload_bytesize) -> simple_correlator_sptr"""
        return _digital_swig2.simple_correlator_make(payload_bytesize)
    __swig_destroy__ = _digital_swig2.delete_simple_correlator

# Register simple_correlator in _digital_swig2:
_digital_swig2.simple_correlator_swigregister(simple_correlator)

def simple_correlator_make(payload_bytesize: "int") -> "gr::digital::simple_correlator::sptr":
    r"""simple_correlator_make(int payload_bytesize) -> simple_correlator_sptr"""
    return _digital_swig2.simple_correlator_make(payload_bytesize)

class simple_framer(object):
    r"""Proxy of C++ gr::digital::simple_framer class."""

    thisown = 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

    @staticmethod
    def make(payload_bytesize: "int") -> "gr::digital::simple_framer::sptr":
        r"""make(int payload_bytesize) -> simple_framer_sptr"""
        return _digital_swig2.simple_framer_make(payload_bytesize)
    __swig_destroy__ = _digital_swig2.delete_simple_framer

# Register simple_framer in _digital_swig2:
_digital_swig2.simple_framer_swigregister(simple_framer)

def simple_framer_make(payload_bytesize: "int") -> "gr::digital::simple_framer::sptr":
    r"""simple_framer_make(int payload_bytesize) -> simple_framer_sptr"""
    return _digital_swig2.simple_framer_make(payload_bytesize)

class symbol_sync_cc(object):
    r"""Proxy of C++ gr::digital::symbol_sync_cc class."""

    thisown = 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

    @staticmethod
    def make(*args, **kwargs) -> "gr::digital::symbol_sync_cc::sptr":
        r"""make(enum gr::digital::ted_type detector_type, float sps, float loop_bw, float damping_factor=1.0, float ted_gain=1.0, float max_deviation=1.5, int osps=1, constellation_sptr slicer=gr::digital::constellation_sptr(), gr::digital::ir_type interp_type=IR_MMSE_8TAP, int n_filters=128, pmt_vector_float taps=std::vector< float >()) -> symbol_sync_cc_sptr"""
        return _digital_swig2.symbol_sync_cc_make(*args, **kwargs)

    def loop_bandwidth(self) -> "float":
        r"""loop_bandwidth(symbol_sync_cc self) -> float"""
        return _digital_swig2.symbol_sync_cc_loop_bandwidth(self)

    def damping_factor(self) -> "float":
        r"""damping_factor(symbol_sync_cc self) -> float"""
        return _digital_swig2.symbol_sync_cc_damping_factor(self)

    def ted_gain(self) -> "float":
        r"""ted_gain(symbol_sync_cc self) -> float"""
        return _digital_swig2.symbol_sync_cc_ted_gain(self)

    def alpha(self) -> "float":
        r"""alpha(symbol_sync_cc self) -> float"""
        return _digital_swig2.symbol_sync_cc_alpha(self)

    def beta(self) -> "float":
        r"""beta(symbol_sync_cc self) -> float"""
        return _digital_swig2.symbol_sync_cc_beta(self)

    def set_loop_bandwidth(self, omega_n_norm: "float") -> "void":
        r"""set_loop_bandwidth(symbol_sync_cc self, float omega_n_norm)"""
        return _digital_swig2.symbol_sync_cc_set_loop_bandwidth(self, omega_n_norm)

    def set_damping_factor(self, zeta: "float") -> "void":
        r"""set_damping_factor(symbol_sync_cc self, float zeta)"""
        return _digital_swig2.symbol_sync_cc_set_damping_factor(self, zeta)

    def set_ted_gain(self, ted_gain: "float") -> "void":
        r"""set_ted_gain(symbol_sync_cc self, float ted_gain)"""
        return _digital_swig2.symbol_sync_cc_set_ted_gain(self, ted_gain)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(symbol_sync_cc self, float alpha)"""
        return _digital_swig2.symbol_sync_cc_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(symbol_sync_cc self, float beta)"""
        return _digital_swig2.symbol_sync_cc_set_beta(self, beta)
    __swig_destroy__ = _digital_swig2.delete_symbol_sync_cc

# Register symbol_sync_cc in _digital_swig2:
_digital_swig2.symbol_sync_cc_swigregister(symbol_sync_cc)

def symbol_sync_cc_make(*args, **kwargs) -> "gr::digital::symbol_sync_cc::sptr":
    r"""symbol_sync_cc_make(enum gr::digital::ted_type detector_type, float sps, float loop_bw, float damping_factor=1.0, float ted_gain=1.0, float max_deviation=1.5, int osps=1, constellation_sptr slicer=gr::digital::constellation_sptr(), gr::digital::ir_type interp_type=IR_MMSE_8TAP, int n_filters=128, pmt_vector_float taps=std::vector< float >()) -> symbol_sync_cc_sptr"""
    return _digital_swig2.symbol_sync_cc_make(*args, **kwargs)

class symbol_sync_ff(object):
    r"""Proxy of C++ gr::digital::symbol_sync_ff class."""

    thisown = 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

    @staticmethod
    def make(*args, **kwargs) -> "gr::digital::symbol_sync_ff::sptr":
        r"""make(enum gr::digital::ted_type detector_type, float sps, float loop_bw, float damping_factor=1.0, float ted_gain=1.0, float max_deviation=1.5, int osps=1, constellation_sptr slicer=gr::digital::constellation_sptr(), gr::digital::ir_type interp_type=IR_MMSE_8TAP, int n_filters=128, pmt_vector_float taps=std::vector< float >()) -> symbol_sync_ff_sptr"""
        return _digital_swig2.symbol_sync_ff_make(*args, **kwargs)

    def loop_bandwidth(self) -> "float":
        r"""loop_bandwidth(symbol_sync_ff self) -> float"""
        return _digital_swig2.symbol_sync_ff_loop_bandwidth(self)

    def damping_factor(self) -> "float":
        r"""damping_factor(symbol_sync_ff self) -> float"""
        return _digital_swig2.symbol_sync_ff_damping_factor(self)

    def ted_gain(self) -> "float":
        r"""ted_gain(symbol_sync_ff self) -> float"""
        return _digital_swig2.symbol_sync_ff_ted_gain(self)

    def alpha(self) -> "float":
        r"""alpha(symbol_sync_ff self) -> float"""
        return _digital_swig2.symbol_sync_ff_alpha(self)

    def beta(self) -> "float":
        r"""beta(symbol_sync_ff self) -> float"""
        return _digital_swig2.symbol_sync_ff_beta(self)

    def set_loop_bandwidth(self, omega_n_norm: "float") -> "void":
        r"""set_loop_bandwidth(symbol_sync_ff self, float omega_n_norm)"""
        return _digital_swig2.symbol_sync_ff_set_loop_bandwidth(self, omega_n_norm)

    def set_damping_factor(self, zeta: "float") -> "void":
        r"""set_damping_factor(symbol_sync_ff self, float zeta)"""
        return _digital_swig2.symbol_sync_ff_set_damping_factor(self, zeta)

    def set_ted_gain(self, ted_gain: "float") -> "void":
        r"""set_ted_gain(symbol_sync_ff self, float ted_gain)"""
        return _digital_swig2.symbol_sync_ff_set_ted_gain(self, ted_gain)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(symbol_sync_ff self, float alpha)"""
        return _digital_swig2.symbol_sync_ff_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(symbol_sync_ff self, float beta)"""
        return _digital_swig2.symbol_sync_ff_set_beta(self, beta)
    __swig_destroy__ = _digital_swig2.delete_symbol_sync_ff

# Register symbol_sync_ff in _digital_swig2:
_digital_swig2.symbol_sync_ff_swigregister(symbol_sync_ff)

def symbol_sync_ff_make(*args, **kwargs) -> "gr::digital::symbol_sync_ff::sptr":
    r"""symbol_sync_ff_make(enum gr::digital::ted_type detector_type, float sps, float loop_bw, float damping_factor=1.0, float ted_gain=1.0, float max_deviation=1.5, int osps=1, constellation_sptr slicer=gr::digital::constellation_sptr(), gr::digital::ir_type interp_type=IR_MMSE_8TAP, int n_filters=128, pmt_vector_float taps=std::vector< float >()) -> symbol_sync_ff_sptr"""
    return _digital_swig2.symbol_sync_ff_make(*args, **kwargs)

class mpsk_snr_est_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::mpsk_snr_est_cc > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(mpsk_snr_est_cc_sptr self) -> mpsk_snr_est_cc_sptr
        __init__(mpsk_snr_est_cc_sptr self, mpsk_snr_est_cc p) -> mpsk_snr_est_cc_sptr
        """
        _digital_swig2.mpsk_snr_est_cc_sptr_swiginit(self, _digital_swig2.new_mpsk_snr_est_cc_sptr(*args))

    def __deref__(self) -> "gr::digital::mpsk_snr_est_cc *":
        r"""__deref__(mpsk_snr_est_cc_sptr self) -> mpsk_snr_est_cc"""
        return _digital_swig2.mpsk_snr_est_cc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_mpsk_snr_est_cc_sptr

    def make(self, type: "gr::digital::snr_est_type_t", tag_nsamples: "int"=10000, alpha: "double"=0.001) -> "gr::digital::mpsk_snr_est_cc::sptr":
        r"""make(mpsk_snr_est_cc_sptr self, gr::digital::snr_est_type_t type, int tag_nsamples=10000, double alpha=0.001) -> mpsk_snr_est_cc_sptr"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_make(self, type, tag_nsamples, alpha)

    def snr(self) -> "double":
        r"""snr(mpsk_snr_est_cc_sptr self) -> double"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_snr(self)

    def type(self) -> "gr::digital::snr_est_type_t":
        r"""type(mpsk_snr_est_cc_sptr self) -> gr::digital::snr_est_type_t"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_type(self)

    def tag_nsample(self) -> "int":
        r"""tag_nsample(mpsk_snr_est_cc_sptr self) -> int"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_tag_nsample(self)

    def alpha(self) -> "double":
        r"""alpha(mpsk_snr_est_cc_sptr self) -> double"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_alpha(self)

    def set_type(self, t: "gr::digital::snr_est_type_t") -> "void":
        r"""set_type(mpsk_snr_est_cc_sptr self, gr::digital::snr_est_type_t t)"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_set_type(self, t)

    def set_tag_nsample(self, n: "int") -> "void":
        r"""set_tag_nsample(mpsk_snr_est_cc_sptr self, int n)"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_set_tag_nsample(self, n)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(mpsk_snr_est_cc_sptr self, double alpha)"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_set_alpha(self, alpha)

    def history(self) -> "unsigned int":
        r"""history(mpsk_snr_est_cc_sptr self) -> unsigned int"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(mpsk_snr_est_cc_sptr self, int which, int delay)
        declare_sample_delay(mpsk_snr_est_cc_sptr self, unsigned int delay)
        """
        return _digital_swig2.mpsk_snr_est_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(mpsk_snr_est_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(mpsk_snr_est_cc_sptr self, int multiple)"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(mpsk_snr_est_cc_sptr self) -> int"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(mpsk_snr_est_cc_sptr self) -> double"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(mpsk_snr_est_cc_sptr self) -> uint64_t"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(mpsk_snr_est_cc_sptr self) -> uint64_t"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(mpsk_snr_est_cc_sptr self) -> bool"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(mpsk_snr_est_cc_sptr self) -> bool"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(mpsk_snr_est_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(mpsk_snr_est_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(mpsk_snr_est_cc_sptr self, std::string level)"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(mpsk_snr_est_cc_sptr self) -> std::string"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(mpsk_snr_est_cc_sptr self) -> int"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(mpsk_snr_est_cc_sptr self, int m)"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(mpsk_snr_est_cc_sptr self)"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(mpsk_snr_est_cc_sptr self) -> bool"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(mpsk_snr_est_cc_sptr self, int m)"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(mpsk_snr_est_cc_sptr self) -> int"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(mpsk_snr_est_cc_sptr self, int i) -> long"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(mpsk_snr_est_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(mpsk_snr_est_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig2.mpsk_snr_est_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(mpsk_snr_est_cc_sptr self, int i) -> long"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(mpsk_snr_est_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(mpsk_snr_est_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig2.mpsk_snr_est_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(mpsk_snr_est_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(mpsk_snr_est_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(mpsk_snr_est_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(mpsk_snr_est_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(mpsk_snr_est_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(mpsk_snr_est_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(mpsk_snr_est_cc_sptr self, int which) -> float
        pc_input_buffers_full(mpsk_snr_est_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.mpsk_snr_est_cc_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(mpsk_snr_est_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(mpsk_snr_est_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.mpsk_snr_est_cc_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(mpsk_snr_est_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(mpsk_snr_est_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.mpsk_snr_est_cc_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(mpsk_snr_est_cc_sptr self, int which) -> float
        pc_output_buffers_full(mpsk_snr_est_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.mpsk_snr_est_cc_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(mpsk_snr_est_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(mpsk_snr_est_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.mpsk_snr_est_cc_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(mpsk_snr_est_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(mpsk_snr_est_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.mpsk_snr_est_cc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(mpsk_snr_est_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(mpsk_snr_est_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(mpsk_snr_est_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(mpsk_snr_est_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(mpsk_snr_est_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(mpsk_snr_est_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(mpsk_snr_est_cc_sptr self)"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(mpsk_snr_est_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(mpsk_snr_est_cc_sptr self) -> int"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(mpsk_snr_est_cc_sptr self) -> int"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(mpsk_snr_est_cc_sptr self, int priority) -> int"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(mpsk_snr_est_cc_sptr self) -> std::string"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(mpsk_snr_est_cc_sptr self) -> std::string"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(mpsk_snr_est_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(mpsk_snr_est_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(mpsk_snr_est_cc_sptr self) -> long"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(mpsk_snr_est_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(mpsk_snr_est_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(mpsk_snr_est_cc_sptr self) -> std::string"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(mpsk_snr_est_cc_sptr self, std::string name)"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(mpsk_snr_est_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig2.mpsk_snr_est_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(mpsk_snr_est_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(mpsk_snr_est_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(mpsk_snr_est_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_message_subscribers(self, which_port)

# Register mpsk_snr_est_cc_sptr in _digital_swig2:
_digital_swig2.mpsk_snr_est_cc_sptr_swigregister(mpsk_snr_est_cc_sptr)


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

class protocol_formatter_async_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::protocol_formatter_async > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(protocol_formatter_async_sptr self) -> protocol_formatter_async_sptr
        __init__(protocol_formatter_async_sptr self, protocol_formatter_async p) -> protocol_formatter_async_sptr
        """
        _digital_swig2.protocol_formatter_async_sptr_swiginit(self, _digital_swig2.new_protocol_formatter_async_sptr(*args))

    def __deref__(self) -> "gr::digital::protocol_formatter_async *":
        r"""__deref__(protocol_formatter_async_sptr self) -> protocol_formatter_async"""
        return _digital_swig2.protocol_formatter_async_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_protocol_formatter_async_sptr

    def make(self, format: "header_format_base_sptr") -> "gr::digital::protocol_formatter_async::sptr":
        r"""make(protocol_formatter_async_sptr self, header_format_base_sptr format) -> protocol_formatter_async_sptr"""
        return _digital_swig2.protocol_formatter_async_sptr_make(self, format)

    def history(self) -> "unsigned int":
        r"""history(protocol_formatter_async_sptr self) -> unsigned int"""
        return _digital_swig2.protocol_formatter_async_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(protocol_formatter_async_sptr self, int which, int delay)
        declare_sample_delay(protocol_formatter_async_sptr self, unsigned int delay)
        """
        return _digital_swig2.protocol_formatter_async_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(protocol_formatter_async_sptr self, int which) -> unsigned int"""
        return _digital_swig2.protocol_formatter_async_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(protocol_formatter_async_sptr self, int multiple)"""
        return _digital_swig2.protocol_formatter_async_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(protocol_formatter_async_sptr self) -> int"""
        return _digital_swig2.protocol_formatter_async_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(protocol_formatter_async_sptr self) -> double"""
        return _digital_swig2.protocol_formatter_async_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(protocol_formatter_async_sptr self) -> uint64_t"""
        return _digital_swig2.protocol_formatter_async_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(protocol_formatter_async_sptr self) -> uint64_t"""
        return _digital_swig2.protocol_formatter_async_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(protocol_formatter_async_sptr self) -> bool"""
        return _digital_swig2.protocol_formatter_async_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(protocol_formatter_async_sptr self) -> bool"""
        return _digital_swig2.protocol_formatter_async_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(protocol_formatter_async_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig2.protocol_formatter_async_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(protocol_formatter_async_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.protocol_formatter_async_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(protocol_formatter_async_sptr self, std::string level)"""
        return _digital_swig2.protocol_formatter_async_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(protocol_formatter_async_sptr self) -> std::string"""
        return _digital_swig2.protocol_formatter_async_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(protocol_formatter_async_sptr self) -> int"""
        return _digital_swig2.protocol_formatter_async_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(protocol_formatter_async_sptr self, int m)"""
        return _digital_swig2.protocol_formatter_async_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(protocol_formatter_async_sptr self)"""
        return _digital_swig2.protocol_formatter_async_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(protocol_formatter_async_sptr self) -> bool"""
        return _digital_swig2.protocol_formatter_async_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(protocol_formatter_async_sptr self, int m)"""
        return _digital_swig2.protocol_formatter_async_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(protocol_formatter_async_sptr self) -> int"""
        return _digital_swig2.protocol_formatter_async_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(protocol_formatter_async_sptr self, int i) -> long"""
        return _digital_swig2.protocol_formatter_async_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(protocol_formatter_async_sptr self, long max_output_buffer)
        set_max_output_buffer(protocol_formatter_async_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig2.protocol_formatter_async_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(protocol_formatter_async_sptr self, int i) -> long"""
        return _digital_swig2.protocol_formatter_async_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(protocol_formatter_async_sptr self, long min_output_buffer)
        set_min_output_buffer(protocol_formatter_async_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig2.protocol_formatter_async_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(protocol_formatter_async_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_async_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(protocol_formatter_async_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_async_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(protocol_formatter_async_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_async_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(protocol_formatter_async_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_async_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(protocol_formatter_async_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_async_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(protocol_formatter_async_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_async_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(protocol_formatter_async_sptr self, int which) -> float
        pc_input_buffers_full(protocol_formatter_async_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.protocol_formatter_async_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(protocol_formatter_async_sptr self, int which) -> float
        pc_input_buffers_full_avg(protocol_formatter_async_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.protocol_formatter_async_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(protocol_formatter_async_sptr self, int which) -> float
        pc_input_buffers_full_var(protocol_formatter_async_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.protocol_formatter_async_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(protocol_formatter_async_sptr self, int which) -> float
        pc_output_buffers_full(protocol_formatter_async_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.protocol_formatter_async_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(protocol_formatter_async_sptr self, int which) -> float
        pc_output_buffers_full_avg(protocol_formatter_async_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.protocol_formatter_async_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(protocol_formatter_async_sptr self, int which) -> float
        pc_output_buffers_full_var(protocol_formatter_async_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.protocol_formatter_async_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(protocol_formatter_async_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_async_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(protocol_formatter_async_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_async_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(protocol_formatter_async_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_async_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(protocol_formatter_async_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_async_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(protocol_formatter_async_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_async_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(protocol_formatter_async_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig2.protocol_formatter_async_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(protocol_formatter_async_sptr self)"""
        return _digital_swig2.protocol_formatter_async_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(protocol_formatter_async_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.protocol_formatter_async_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(protocol_formatter_async_sptr self) -> int"""
        return _digital_swig2.protocol_formatter_async_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(protocol_formatter_async_sptr self) -> int"""
        return _digital_swig2.protocol_formatter_async_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(protocol_formatter_async_sptr self, int priority) -> int"""
        return _digital_swig2.protocol_formatter_async_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(protocol_formatter_async_sptr self) -> std::string"""
        return _digital_swig2.protocol_formatter_async_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(protocol_formatter_async_sptr self) -> std::string"""
        return _digital_swig2.protocol_formatter_async_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(protocol_formatter_async_sptr self) -> io_signature_sptr"""
        return _digital_swig2.protocol_formatter_async_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(protocol_formatter_async_sptr self) -> io_signature_sptr"""
        return _digital_swig2.protocol_formatter_async_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(protocol_formatter_async_sptr self) -> long"""
        return _digital_swig2.protocol_formatter_async_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(protocol_formatter_async_sptr self) -> basic_block_sptr"""
        return _digital_swig2.protocol_formatter_async_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(protocol_formatter_async_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig2.protocol_formatter_async_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(protocol_formatter_async_sptr self) -> std::string"""
        return _digital_swig2.protocol_formatter_async_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(protocol_formatter_async_sptr self, std::string name)"""
        return _digital_swig2.protocol_formatter_async_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(protocol_formatter_async_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig2.protocol_formatter_async_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(protocol_formatter_async_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.protocol_formatter_async_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(protocol_formatter_async_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.protocol_formatter_async_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(protocol_formatter_async_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig2.protocol_formatter_async_sptr_message_subscribers(self, which_port)

# Register protocol_formatter_async_sptr in _digital_swig2:
_digital_swig2.protocol_formatter_async_sptr_swigregister(protocol_formatter_async_sptr)


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

class protocol_formatter_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::protocol_formatter_bb > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(protocol_formatter_bb_sptr self) -> protocol_formatter_bb_sptr
        __init__(protocol_formatter_bb_sptr self, protocol_formatter_bb p) -> protocol_formatter_bb_sptr
        """
        _digital_swig2.protocol_formatter_bb_sptr_swiginit(self, _digital_swig2.new_protocol_formatter_bb_sptr(*args))

    def __deref__(self) -> "gr::digital::protocol_formatter_bb *":
        r"""__deref__(protocol_formatter_bb_sptr self) -> protocol_formatter_bb"""
        return _digital_swig2.protocol_formatter_bb_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_protocol_formatter_bb_sptr

    def make(self, *args, **kwargs) -> "gr::digital::protocol_formatter_bb::sptr":
        r"""make(protocol_formatter_bb_sptr self, header_format_base_sptr format, std::string const & len_tag_key="packet_len") -> protocol_formatter_bb_sptr"""
        return _digital_swig2.protocol_formatter_bb_sptr_make(self, *args, **kwargs)

    def set_header_format(self, format: "header_format_base_sptr") -> "void":
        r"""set_header_format(protocol_formatter_bb_sptr self, header_format_base_sptr format)"""
        return _digital_swig2.protocol_formatter_bb_sptr_set_header_format(self, format)

    def history(self) -> "unsigned int":
        r"""history(protocol_formatter_bb_sptr self) -> unsigned int"""
        return _digital_swig2.protocol_formatter_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(protocol_formatter_bb_sptr self, int which, int delay)
        declare_sample_delay(protocol_formatter_bb_sptr self, unsigned int delay)
        """
        return _digital_swig2.protocol_formatter_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(protocol_formatter_bb_sptr self, int which) -> unsigned int"""
        return _digital_swig2.protocol_formatter_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(protocol_formatter_bb_sptr self, int multiple)"""
        return _digital_swig2.protocol_formatter_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(protocol_formatter_bb_sptr self) -> int"""
        return _digital_swig2.protocol_formatter_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(protocol_formatter_bb_sptr self) -> double"""
        return _digital_swig2.protocol_formatter_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(protocol_formatter_bb_sptr self) -> uint64_t"""
        return _digital_swig2.protocol_formatter_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(protocol_formatter_bb_sptr self) -> uint64_t"""
        return _digital_swig2.protocol_formatter_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(protocol_formatter_bb_sptr self) -> bool"""
        return _digital_swig2.protocol_formatter_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(protocol_formatter_bb_sptr self) -> bool"""
        return _digital_swig2.protocol_formatter_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(protocol_formatter_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig2.protocol_formatter_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(protocol_formatter_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.protocol_formatter_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(protocol_formatter_bb_sptr self, std::string level)"""
        return _digital_swig2.protocol_formatter_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(protocol_formatter_bb_sptr self) -> std::string"""
        return _digital_swig2.protocol_formatter_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(protocol_formatter_bb_sptr self) -> int"""
        return _digital_swig2.protocol_formatter_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(protocol_formatter_bb_sptr self, int m)"""
        return _digital_swig2.protocol_formatter_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(protocol_formatter_bb_sptr self)"""
        return _digital_swig2.protocol_formatter_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(protocol_formatter_bb_sptr self) -> bool"""
        return _digital_swig2.protocol_formatter_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(protocol_formatter_bb_sptr self, int m)"""
        return _digital_swig2.protocol_formatter_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(protocol_formatter_bb_sptr self) -> int"""
        return _digital_swig2.protocol_formatter_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(protocol_formatter_bb_sptr self, int i) -> long"""
        return _digital_swig2.protocol_formatter_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(protocol_formatter_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(protocol_formatter_bb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig2.protocol_formatter_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(protocol_formatter_bb_sptr self, int i) -> long"""
        return _digital_swig2.protocol_formatter_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(protocol_formatter_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(protocol_formatter_bb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig2.protocol_formatter_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(protocol_formatter_bb_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(protocol_formatter_bb_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(protocol_formatter_bb_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(protocol_formatter_bb_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(protocol_formatter_bb_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(protocol_formatter_bb_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_bb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(protocol_formatter_bb_sptr self, int which) -> float
        pc_input_buffers_full(protocol_formatter_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.protocol_formatter_bb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(protocol_formatter_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(protocol_formatter_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.protocol_formatter_bb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(protocol_formatter_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(protocol_formatter_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.protocol_formatter_bb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(protocol_formatter_bb_sptr self, int which) -> float
        pc_output_buffers_full(protocol_formatter_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.protocol_formatter_bb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(protocol_formatter_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(protocol_formatter_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.protocol_formatter_bb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(protocol_formatter_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(protocol_formatter_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.protocol_formatter_bb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(protocol_formatter_bb_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(protocol_formatter_bb_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(protocol_formatter_bb_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(protocol_formatter_bb_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(protocol_formatter_bb_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(protocol_formatter_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig2.protocol_formatter_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(protocol_formatter_bb_sptr self)"""
        return _digital_swig2.protocol_formatter_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(protocol_formatter_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.protocol_formatter_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(protocol_formatter_bb_sptr self) -> int"""
        return _digital_swig2.protocol_formatter_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(protocol_formatter_bb_sptr self) -> int"""
        return _digital_swig2.protocol_formatter_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(protocol_formatter_bb_sptr self, int priority) -> int"""
        return _digital_swig2.protocol_formatter_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(protocol_formatter_bb_sptr self) -> std::string"""
        return _digital_swig2.protocol_formatter_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(protocol_formatter_bb_sptr self) -> std::string"""
        return _digital_swig2.protocol_formatter_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(protocol_formatter_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig2.protocol_formatter_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(protocol_formatter_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig2.protocol_formatter_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(protocol_formatter_bb_sptr self) -> long"""
        return _digital_swig2.protocol_formatter_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(protocol_formatter_bb_sptr self) -> basic_block_sptr"""
        return _digital_swig2.protocol_formatter_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(protocol_formatter_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig2.protocol_formatter_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(protocol_formatter_bb_sptr self) -> std::string"""
        return _digital_swig2.protocol_formatter_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(protocol_formatter_bb_sptr self, std::string name)"""
        return _digital_swig2.protocol_formatter_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(protocol_formatter_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig2.protocol_formatter_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(protocol_formatter_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.protocol_formatter_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(protocol_formatter_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.protocol_formatter_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(protocol_formatter_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig2.protocol_formatter_bb_sptr_message_subscribers(self, which_port)

# Register protocol_formatter_bb_sptr in _digital_swig2:
_digital_swig2.protocol_formatter_bb_sptr_swigregister(protocol_formatter_bb_sptr)


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

class protocol_parser_b_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::protocol_parser_b > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(protocol_parser_b_sptr self) -> protocol_parser_b_sptr
        __init__(protocol_parser_b_sptr self, protocol_parser_b p) -> protocol_parser_b_sptr
        """
        _digital_swig2.protocol_parser_b_sptr_swiginit(self, _digital_swig2.new_protocol_parser_b_sptr(*args))

    def __deref__(self) -> "gr::digital::protocol_parser_b *":
        r"""__deref__(protocol_parser_b_sptr self) -> protocol_parser_b"""
        return _digital_swig2.protocol_parser_b_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_protocol_parser_b_sptr

    def make(self, format: "header_format_base_sptr") -> "gr::digital::protocol_parser_b::sptr":
        r"""make(protocol_parser_b_sptr self, header_format_base_sptr format) -> protocol_parser_b_sptr"""
        return _digital_swig2.protocol_parser_b_sptr_make(self, format)

    def history(self) -> "unsigned int":
        r"""history(protocol_parser_b_sptr self) -> unsigned int"""
        return _digital_swig2.protocol_parser_b_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(protocol_parser_b_sptr self, int which, int delay)
        declare_sample_delay(protocol_parser_b_sptr self, unsigned int delay)
        """
        return _digital_swig2.protocol_parser_b_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(protocol_parser_b_sptr self, int which) -> unsigned int"""
        return _digital_swig2.protocol_parser_b_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(protocol_parser_b_sptr self, int multiple)"""
        return _digital_swig2.protocol_parser_b_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(protocol_parser_b_sptr self) -> int"""
        return _digital_swig2.protocol_parser_b_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(protocol_parser_b_sptr self) -> double"""
        return _digital_swig2.protocol_parser_b_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(protocol_parser_b_sptr self) -> uint64_t"""
        return _digital_swig2.protocol_parser_b_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(protocol_parser_b_sptr self) -> uint64_t"""
        return _digital_swig2.protocol_parser_b_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(protocol_parser_b_sptr self) -> bool"""
        return _digital_swig2.protocol_parser_b_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(protocol_parser_b_sptr self) -> bool"""
        return _digital_swig2.protocol_parser_b_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(protocol_parser_b_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig2.protocol_parser_b_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(protocol_parser_b_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.protocol_parser_b_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(protocol_parser_b_sptr self, std::string level)"""
        return _digital_swig2.protocol_parser_b_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(protocol_parser_b_sptr self) -> std::string"""
        return _digital_swig2.protocol_parser_b_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(protocol_parser_b_sptr self) -> int"""
        return _digital_swig2.protocol_parser_b_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(protocol_parser_b_sptr self, int m)"""
        return _digital_swig2.protocol_parser_b_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(protocol_parser_b_sptr self)"""
        return _digital_swig2.protocol_parser_b_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(protocol_parser_b_sptr self) -> bool"""
        return _digital_swig2.protocol_parser_b_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(protocol_parser_b_sptr self, int m)"""
        return _digital_swig2.protocol_parser_b_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(protocol_parser_b_sptr self) -> int"""
        return _digital_swig2.protocol_parser_b_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(protocol_parser_b_sptr self, int i) -> long"""
        return _digital_swig2.protocol_parser_b_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(protocol_parser_b_sptr self, long max_output_buffer)
        set_max_output_buffer(protocol_parser_b_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig2.protocol_parser_b_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(protocol_parser_b_sptr self, int i) -> long"""
        return _digital_swig2.protocol_parser_b_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(protocol_parser_b_sptr self, long min_output_buffer)
        set_min_output_buffer(protocol_parser_b_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig2.protocol_parser_b_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(protocol_parser_b_sptr self) -> float"""
        return _digital_swig2.protocol_parser_b_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(protocol_parser_b_sptr self) -> float"""
        return _digital_swig2.protocol_parser_b_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(protocol_parser_b_sptr self) -> float"""
        return _digital_swig2.protocol_parser_b_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(protocol_parser_b_sptr self) -> float"""
        return _digital_swig2.protocol_parser_b_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(protocol_parser_b_sptr self) -> float"""
        return _digital_swig2.protocol_parser_b_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(protocol_parser_b_sptr self) -> float"""
        return _digital_swig2.protocol_parser_b_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(protocol_parser_b_sptr self, int which) -> float
        pc_input_buffers_full(protocol_parser_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.protocol_parser_b_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(protocol_parser_b_sptr self, int which) -> float
        pc_input_buffers_full_avg(protocol_parser_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.protocol_parser_b_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(protocol_parser_b_sptr self, int which) -> float
        pc_input_buffers_full_var(protocol_parser_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.protocol_parser_b_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(protocol_parser_b_sptr self, int which) -> float
        pc_output_buffers_full(protocol_parser_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.protocol_parser_b_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(protocol_parser_b_sptr self, int which) -> float
        pc_output_buffers_full_avg(protocol_parser_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.protocol_parser_b_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(protocol_parser_b_sptr self, int which) -> float
        pc_output_buffers_full_var(protocol_parser_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.protocol_parser_b_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(protocol_parser_b_sptr self) -> float"""
        return _digital_swig2.protocol_parser_b_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(protocol_parser_b_sptr self) -> float"""
        return _digital_swig2.protocol_parser_b_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(protocol_parser_b_sptr self) -> float"""
        return _digital_swig2.protocol_parser_b_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(protocol_parser_b_sptr self) -> float"""
        return _digital_swig2.protocol_parser_b_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(protocol_parser_b_sptr self) -> float"""
        return _digital_swig2.protocol_parser_b_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(protocol_parser_b_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig2.protocol_parser_b_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(protocol_parser_b_sptr self)"""
        return _digital_swig2.protocol_parser_b_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(protocol_parser_b_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.protocol_parser_b_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(protocol_parser_b_sptr self) -> int"""
        return _digital_swig2.protocol_parser_b_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(protocol_parser_b_sptr self) -> int"""
        return _digital_swig2.protocol_parser_b_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(protocol_parser_b_sptr self, int priority) -> int"""
        return _digital_swig2.protocol_parser_b_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(protocol_parser_b_sptr self) -> std::string"""
        return _digital_swig2.protocol_parser_b_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(protocol_parser_b_sptr self) -> std::string"""
        return _digital_swig2.protocol_parser_b_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(protocol_parser_b_sptr self) -> io_signature_sptr"""
        return _digital_swig2.protocol_parser_b_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(protocol_parser_b_sptr self) -> io_signature_sptr"""
        return _digital_swig2.protocol_parser_b_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(protocol_parser_b_sptr self) -> long"""
        return _digital_swig2.protocol_parser_b_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(protocol_parser_b_sptr self) -> basic_block_sptr"""
        return _digital_swig2.protocol_parser_b_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(protocol_parser_b_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig2.protocol_parser_b_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(protocol_parser_b_sptr self) -> std::string"""
        return _digital_swig2.protocol_parser_b_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(protocol_parser_b_sptr self, std::string name)"""
        return _digital_swig2.protocol_parser_b_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(protocol_parser_b_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig2.protocol_parser_b_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(protocol_parser_b_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.protocol_parser_b_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(protocol_parser_b_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.protocol_parser_b_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(protocol_parser_b_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig2.protocol_parser_b_sptr_message_subscribers(self, which_port)

# Register protocol_parser_b_sptr in _digital_swig2:
_digital_swig2.protocol_parser_b_sptr_swigregister(protocol_parser_b_sptr)


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

class packet_headergenerator_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::packet_headergenerator_bb > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(packet_headergenerator_bb_sptr self) -> packet_headergenerator_bb_sptr
        __init__(packet_headergenerator_bb_sptr self, packet_headergenerator_bb p) -> packet_headergenerator_bb_sptr
        """
        _digital_swig2.packet_headergenerator_bb_sptr_swiginit(self, _digital_swig2.new_packet_headergenerator_bb_sptr(*args))

    def __deref__(self) -> "gr::digital::packet_headergenerator_bb *":
        r"""__deref__(packet_headergenerator_bb_sptr self) -> packet_headergenerator_bb"""
        return _digital_swig2.packet_headergenerator_bb_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_packet_headergenerator_bb_sptr

    def make(self, *args) -> "gr::digital::packet_headergenerator_bb::sptr":
        r"""
        make(packet_headergenerator_bb_sptr self, packet_header_default_sptr header_formatter, std::string const & len_tag_key="packet_len") -> packet_headergenerator_bb_sptr
        make(packet_headergenerator_bb_sptr self, long header_len, std::string const & len_tag_key="packet_len") -> packet_headergenerator_bb_sptr
        """
        return _digital_swig2.packet_headergenerator_bb_sptr_make(self, *args)

    def set_header_formatter(self, header_formatter: "packet_header_default_sptr") -> "void":
        r"""set_header_formatter(packet_headergenerator_bb_sptr self, packet_header_default_sptr header_formatter)"""
        return _digital_swig2.packet_headergenerator_bb_sptr_set_header_formatter(self, header_formatter)

    def history(self) -> "unsigned int":
        r"""history(packet_headergenerator_bb_sptr self) -> unsigned int"""
        return _digital_swig2.packet_headergenerator_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(packet_headergenerator_bb_sptr self, int which, int delay)
        declare_sample_delay(packet_headergenerator_bb_sptr self, unsigned int delay)
        """
        return _digital_swig2.packet_headergenerator_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(packet_headergenerator_bb_sptr self, int which) -> unsigned int"""
        return _digital_swig2.packet_headergenerator_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(packet_headergenerator_bb_sptr self, int multiple)"""
        return _digital_swig2.packet_headergenerator_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(packet_headergenerator_bb_sptr self) -> int"""
        return _digital_swig2.packet_headergenerator_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(packet_headergenerator_bb_sptr self) -> double"""
        return _digital_swig2.packet_headergenerator_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(packet_headergenerator_bb_sptr self) -> uint64_t"""
        return _digital_swig2.packet_headergenerator_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(packet_headergenerator_bb_sptr self) -> uint64_t"""
        return _digital_swig2.packet_headergenerator_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(packet_headergenerator_bb_sptr self) -> bool"""
        return _digital_swig2.packet_headergenerator_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(packet_headergenerator_bb_sptr self) -> bool"""
        return _digital_swig2.packet_headergenerator_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(packet_headergenerator_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig2.packet_headergenerator_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(packet_headergenerator_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.packet_headergenerator_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(packet_headergenerator_bb_sptr self, std::string level)"""
        return _digital_swig2.packet_headergenerator_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(packet_headergenerator_bb_sptr self) -> std::string"""
        return _digital_swig2.packet_headergenerator_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(packet_headergenerator_bb_sptr self) -> int"""
        return _digital_swig2.packet_headergenerator_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(packet_headergenerator_bb_sptr self, int m)"""
        return _digital_swig2.packet_headergenerator_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(packet_headergenerator_bb_sptr self)"""
        return _digital_swig2.packet_headergenerator_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(packet_headergenerator_bb_sptr self) -> bool"""
        return _digital_swig2.packet_headergenerator_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(packet_headergenerator_bb_sptr self, int m)"""
        return _digital_swig2.packet_headergenerator_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(packet_headergenerator_bb_sptr self) -> int"""
        return _digital_swig2.packet_headergenerator_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(packet_headergenerator_bb_sptr self, int i) -> long"""
        return _digital_swig2.packet_headergenerator_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(packet_headergenerator_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(packet_headergenerator_bb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig2.packet_headergenerator_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(packet_headergenerator_bb_sptr self, int i) -> long"""
        return _digital_swig2.packet_headergenerator_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(packet_headergenerator_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(packet_headergenerator_bb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig2.packet_headergenerator_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(packet_headergenerator_bb_sptr self) -> float"""
        return _digital_swig2.packet_headergenerator_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(packet_headergenerator_bb_sptr self) -> float"""
        return _digital_swig2.packet_headergenerator_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(packet_headergenerator_bb_sptr self) -> float"""
        return _digital_swig2.packet_headergenerator_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(packet_headergenerator_bb_sptr self) -> float"""
        return _digital_swig2.packet_headergenerator_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(packet_headergenerator_bb_sptr self) -> float"""
        return _digital_swig2.packet_headergenerator_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(packet_headergenerator_bb_sptr self) -> float"""
        return _digital_swig2.packet_headergenerator_bb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(packet_headergenerator_bb_sptr self, int which) -> float
        pc_input_buffers_full(packet_headergenerator_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.packet_headergenerator_bb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(packet_headergenerator_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(packet_headergenerator_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.packet_headergenerator_bb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(packet_headergenerator_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(packet_headergenerator_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.packet_headergenerator_bb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(packet_headergenerator_bb_sptr self, int which) -> float
        pc_output_buffers_full(packet_headergenerator_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.packet_headergenerator_bb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(packet_headergenerator_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(packet_headergenerator_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.packet_headergenerator_bb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(packet_headergenerator_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(packet_headergenerator_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.packet_headergenerator_bb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(packet_headergenerator_bb_sptr self) -> float"""
        return _digital_swig2.packet_headergenerator_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(packet_headergenerator_bb_sptr self) -> float"""
        return _digital_swig2.packet_headergenerator_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(packet_headergenerator_bb_sptr self) -> float"""
        return _digital_swig2.packet_headergenerator_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(packet_headergenerator_bb_sptr self) -> float"""
        return _digital_swig2.packet_headergenerator_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(packet_headergenerator_bb_sptr self) -> float"""
        return _digital_swig2.packet_headergenerator_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(packet_headergenerator_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig2.packet_headergenerator_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(packet_headergenerator_bb_sptr self)"""
        return _digital_swig2.packet_headergenerator_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(packet_headergenerator_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.packet_headergenerator_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(packet_headergenerator_bb_sptr self) -> int"""
        return _digital_swig2.packet_headergenerator_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(packet_headergenerator_bb_sptr self) -> int"""
        return _digital_swig2.packet_headergenerator_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(packet_headergenerator_bb_sptr self, int priority) -> int"""
        return _digital_swig2.packet_headergenerator_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(packet_headergenerator_bb_sptr self) -> std::string"""
        return _digital_swig2.packet_headergenerator_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(packet_headergenerator_bb_sptr self) -> std::string"""
        return _digital_swig2.packet_headergenerator_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(packet_headergenerator_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig2.packet_headergenerator_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(packet_headergenerator_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig2.packet_headergenerator_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(packet_headergenerator_bb_sptr self) -> long"""
        return _digital_swig2.packet_headergenerator_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(packet_headergenerator_bb_sptr self) -> basic_block_sptr"""
        return _digital_swig2.packet_headergenerator_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(packet_headergenerator_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig2.packet_headergenerator_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(packet_headergenerator_bb_sptr self) -> std::string"""
        return _digital_swig2.packet_headergenerator_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(packet_headergenerator_bb_sptr self, std::string name)"""
        return _digital_swig2.packet_headergenerator_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(packet_headergenerator_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig2.packet_headergenerator_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(packet_headergenerator_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.packet_headergenerator_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(packet_headergenerator_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.packet_headergenerator_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(packet_headergenerator_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig2.packet_headergenerator_bb_sptr_message_subscribers(self, which_port)

# Register packet_headergenerator_bb_sptr in _digital_swig2:
_digital_swig2.packet_headergenerator_bb_sptr_swigregister(packet_headergenerator_bb_sptr)


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

class packet_headerparser_b_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::packet_headerparser_b > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(packet_headerparser_b_sptr self) -> packet_headerparser_b_sptr
        __init__(packet_headerparser_b_sptr self, packet_headerparser_b p) -> packet_headerparser_b_sptr
        """
        _digital_swig2.packet_headerparser_b_sptr_swiginit(self, _digital_swig2.new_packet_headerparser_b_sptr(*args))

    def __deref__(self) -> "gr::digital::packet_headerparser_b *":
        r"""__deref__(packet_headerparser_b_sptr self) -> packet_headerparser_b"""
        return _digital_swig2.packet_headerparser_b_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_packet_headerparser_b_sptr

    def make(self, *args) -> "gr::digital::packet_headerparser_b::sptr":
        r"""
        make(packet_headerparser_b_sptr self, packet_header_default_sptr header_formatter) -> packet_headerparser_b_sptr
        make(packet_headerparser_b_sptr self, long header_len, std::string const & len_tag_key) -> packet_headerparser_b_sptr
        """
        return _digital_swig2.packet_headerparser_b_sptr_make(self, *args)

    def history(self) -> "unsigned int":
        r"""history(packet_headerparser_b_sptr self) -> unsigned int"""
        return _digital_swig2.packet_headerparser_b_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(packet_headerparser_b_sptr self, int which, int delay)
        declare_sample_delay(packet_headerparser_b_sptr self, unsigned int delay)
        """
        return _digital_swig2.packet_headerparser_b_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(packet_headerparser_b_sptr self, int which) -> unsigned int"""
        return _digital_swig2.packet_headerparser_b_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(packet_headerparser_b_sptr self, int multiple)"""
        return _digital_swig2.packet_headerparser_b_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(packet_headerparser_b_sptr self) -> int"""
        return _digital_swig2.packet_headerparser_b_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(packet_headerparser_b_sptr self) -> double"""
        return _digital_swig2.packet_headerparser_b_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(packet_headerparser_b_sptr self) -> uint64_t"""
        return _digital_swig2.packet_headerparser_b_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(packet_headerparser_b_sptr self) -> uint64_t"""
        return _digital_swig2.packet_headerparser_b_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(packet_headerparser_b_sptr self) -> bool"""
        return _digital_swig2.packet_headerparser_b_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(packet_headerparser_b_sptr self) -> bool"""
        return _digital_swig2.packet_headerparser_b_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(packet_headerparser_b_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig2.packet_headerparser_b_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(packet_headerparser_b_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.packet_headerparser_b_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(packet_headerparser_b_sptr self, std::string level)"""
        return _digital_swig2.packet_headerparser_b_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(packet_headerparser_b_sptr self) -> std::string"""
        return _digital_swig2.packet_headerparser_b_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(packet_headerparser_b_sptr self) -> int"""
        return _digital_swig2.packet_headerparser_b_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(packet_headerparser_b_sptr self, int m)"""
        return _digital_swig2.packet_headerparser_b_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(packet_headerparser_b_sptr self)"""
        return _digital_swig2.packet_headerparser_b_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(packet_headerparser_b_sptr self) -> bool"""
        return _digital_swig2.packet_headerparser_b_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(packet_headerparser_b_sptr self, int m)"""
        return _digital_swig2.packet_headerparser_b_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(packet_headerparser_b_sptr self) -> int"""
        return _digital_swig2.packet_headerparser_b_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(packet_headerparser_b_sptr self, int i) -> long"""
        return _digital_swig2.packet_headerparser_b_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(packet_headerparser_b_sptr self, long max_output_buffer)
        set_max_output_buffer(packet_headerparser_b_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig2.packet_headerparser_b_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(packet_headerparser_b_sptr self, int i) -> long"""
        return _digital_swig2.packet_headerparser_b_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(packet_headerparser_b_sptr self, long min_output_buffer)
        set_min_output_buffer(packet_headerparser_b_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig2.packet_headerparser_b_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(packet_headerparser_b_sptr self) -> float"""
        return _digital_swig2.packet_headerparser_b_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(packet_headerparser_b_sptr self) -> float"""
        return _digital_swig2.packet_headerparser_b_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(packet_headerparser_b_sptr self) -> float"""
        return _digital_swig2.packet_headerparser_b_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(packet_headerparser_b_sptr self) -> float"""
        return _digital_swig2.packet_headerparser_b_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(packet_headerparser_b_sptr self) -> float"""
        return _digital_swig2.packet_headerparser_b_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(packet_headerparser_b_sptr self) -> float"""
        return _digital_swig2.packet_headerparser_b_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(packet_headerparser_b_sptr self, int which) -> float
        pc_input_buffers_full(packet_headerparser_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.packet_headerparser_b_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(packet_headerparser_b_sptr self, int which) -> float
        pc_input_buffers_full_avg(packet_headerparser_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.packet_headerparser_b_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(packet_headerparser_b_sptr self, int which) -> float
        pc_input_buffers_full_var(packet_headerparser_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.packet_headerparser_b_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(packet_headerparser_b_sptr self, int which) -> float
        pc_output_buffers_full(packet_headerparser_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.packet_headerparser_b_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(packet_headerparser_b_sptr self, int which) -> float
        pc_output_buffers_full_avg(packet_headerparser_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.packet_headerparser_b_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(packet_headerparser_b_sptr self, int which) -> float
        pc_output_buffers_full_var(packet_headerparser_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.packet_headerparser_b_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(packet_headerparser_b_sptr self) -> float"""
        return _digital_swig2.packet_headerparser_b_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(packet_headerparser_b_sptr self) -> float"""
        return _digital_swig2.packet_headerparser_b_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(packet_headerparser_b_sptr self) -> float"""
        return _digital_swig2.packet_headerparser_b_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(packet_headerparser_b_sptr self) -> float"""
        return _digital_swig2.packet_headerparser_b_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(packet_headerparser_b_sptr self) -> float"""
        return _digital_swig2.packet_headerparser_b_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(packet_headerparser_b_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig2.packet_headerparser_b_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(packet_headerparser_b_sptr self)"""
        return _digital_swig2.packet_headerparser_b_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(packet_headerparser_b_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.packet_headerparser_b_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(packet_headerparser_b_sptr self) -> int"""
        return _digital_swig2.packet_headerparser_b_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(packet_headerparser_b_sptr self) -> int"""
        return _digital_swig2.packet_headerparser_b_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(packet_headerparser_b_sptr self, int priority) -> int"""
        return _digital_swig2.packet_headerparser_b_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(packet_headerparser_b_sptr self) -> std::string"""
        return _digital_swig2.packet_headerparser_b_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(packet_headerparser_b_sptr self) -> std::string"""
        return _digital_swig2.packet_headerparser_b_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(packet_headerparser_b_sptr self) -> io_signature_sptr"""
        return _digital_swig2.packet_headerparser_b_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(packet_headerparser_b_sptr self) -> io_signature_sptr"""
        return _digital_swig2.packet_headerparser_b_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(packet_headerparser_b_sptr self) -> long"""
        return _digital_swig2.packet_headerparser_b_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(packet_headerparser_b_sptr self) -> basic_block_sptr"""
        return _digital_swig2.packet_headerparser_b_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(packet_headerparser_b_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig2.packet_headerparser_b_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(packet_headerparser_b_sptr self) -> std::string"""
        return _digital_swig2.packet_headerparser_b_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(packet_headerparser_b_sptr self, std::string name)"""
        return _digital_swig2.packet_headerparser_b_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(packet_headerparser_b_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig2.packet_headerparser_b_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(packet_headerparser_b_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.packet_headerparser_b_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(packet_headerparser_b_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.packet_headerparser_b_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(packet_headerparser_b_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig2.packet_headerparser_b_sptr_message_subscribers(self, which_port)

# Register packet_headerparser_b_sptr in _digital_swig2:
_digital_swig2.packet_headerparser_b_sptr_swigregister(packet_headerparser_b_sptr)


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

class packet_sink_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::packet_sink > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(packet_sink_sptr self) -> packet_sink_sptr
        __init__(packet_sink_sptr self, packet_sink p) -> packet_sink_sptr
        """
        _digital_swig2.packet_sink_sptr_swiginit(self, _digital_swig2.new_packet_sink_sptr(*args))

    def __deref__(self) -> "gr::digital::packet_sink *":
        r"""__deref__(packet_sink_sptr self) -> packet_sink"""
        return _digital_swig2.packet_sink_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_packet_sink_sptr

    def make(self, sync_vector: "std::vector< unsigned char,std::allocator< unsigned char > > const &", target_queue: "msg_queue_sptr", threshold: "int"=-1) -> "gr::digital::packet_sink::sptr":
        r"""make(packet_sink_sptr self, std::vector< unsigned char,std::allocator< unsigned char > > const & sync_vector, msg_queue_sptr target_queue, int threshold=-1) -> packet_sink_sptr"""
        return _digital_swig2.packet_sink_sptr_make(self, sync_vector, target_queue, threshold)

    def carrier_sensed(self) -> "bool":
        r"""carrier_sensed(packet_sink_sptr self) -> bool"""
        return _digital_swig2.packet_sink_sptr_carrier_sensed(self)

    def history(self) -> "unsigned int":
        r"""history(packet_sink_sptr self) -> unsigned int"""
        return _digital_swig2.packet_sink_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(packet_sink_sptr self, int which, int delay)
        declare_sample_delay(packet_sink_sptr self, unsigned int delay)
        """
        return _digital_swig2.packet_sink_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(packet_sink_sptr self, int which) -> unsigned int"""
        return _digital_swig2.packet_sink_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(packet_sink_sptr self, int multiple)"""
        return _digital_swig2.packet_sink_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(packet_sink_sptr self) -> int"""
        return _digital_swig2.packet_sink_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(packet_sink_sptr self) -> double"""
        return _digital_swig2.packet_sink_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(packet_sink_sptr self) -> uint64_t"""
        return _digital_swig2.packet_sink_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(packet_sink_sptr self) -> uint64_t"""
        return _digital_swig2.packet_sink_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(packet_sink_sptr self) -> bool"""
        return _digital_swig2.packet_sink_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(packet_sink_sptr self) -> bool"""
        return _digital_swig2.packet_sink_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(packet_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig2.packet_sink_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(packet_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.packet_sink_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(packet_sink_sptr self, std::string level)"""
        return _digital_swig2.packet_sink_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(packet_sink_sptr self) -> std::string"""
        return _digital_swig2.packet_sink_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(packet_sink_sptr self) -> int"""
        return _digital_swig2.packet_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(packet_sink_sptr self, int m)"""
        return _digital_swig2.packet_sink_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(packet_sink_sptr self)"""
        return _digital_swig2.packet_sink_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(packet_sink_sptr self) -> bool"""
        return _digital_swig2.packet_sink_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(packet_sink_sptr self, int m)"""
        return _digital_swig2.packet_sink_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(packet_sink_sptr self) -> int"""
        return _digital_swig2.packet_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(packet_sink_sptr self, int i) -> long"""
        return _digital_swig2.packet_sink_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(packet_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(packet_sink_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig2.packet_sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(packet_sink_sptr self, int i) -> long"""
        return _digital_swig2.packet_sink_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(packet_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(packet_sink_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig2.packet_sink_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(packet_sink_sptr self) -> float"""
        return _digital_swig2.packet_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(packet_sink_sptr self) -> float"""
        return _digital_swig2.packet_sink_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(packet_sink_sptr self) -> float"""
        return _digital_swig2.packet_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(packet_sink_sptr self) -> float"""
        return _digital_swig2.packet_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(packet_sink_sptr self) -> float"""
        return _digital_swig2.packet_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(packet_sink_sptr self) -> float"""
        return _digital_swig2.packet_sink_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(packet_sink_sptr self, int which) -> float
        pc_input_buffers_full(packet_sink_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.packet_sink_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(packet_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(packet_sink_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.packet_sink_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(packet_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(packet_sink_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.packet_sink_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(packet_sink_sptr self, int which) -> float
        pc_output_buffers_full(packet_sink_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.packet_sink_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(packet_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(packet_sink_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.packet_sink_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(packet_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(packet_sink_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.packet_sink_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(packet_sink_sptr self) -> float"""
        return _digital_swig2.packet_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(packet_sink_sptr self) -> float"""
        return _digital_swig2.packet_sink_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(packet_sink_sptr self) -> float"""
        return _digital_swig2.packet_sink_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(packet_sink_sptr self) -> float"""
        return _digital_swig2.packet_sink_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(packet_sink_sptr self) -> float"""
        return _digital_swig2.packet_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(packet_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig2.packet_sink_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(packet_sink_sptr self)"""
        return _digital_swig2.packet_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(packet_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.packet_sink_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(packet_sink_sptr self) -> int"""
        return _digital_swig2.packet_sink_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(packet_sink_sptr self) -> int"""
        return _digital_swig2.packet_sink_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(packet_sink_sptr self, int priority) -> int"""
        return _digital_swig2.packet_sink_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(packet_sink_sptr self) -> std::string"""
        return _digital_swig2.packet_sink_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(packet_sink_sptr self) -> std::string"""
        return _digital_swig2.packet_sink_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(packet_sink_sptr self) -> io_signature_sptr"""
        return _digital_swig2.packet_sink_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(packet_sink_sptr self) -> io_signature_sptr"""
        return _digital_swig2.packet_sink_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(packet_sink_sptr self) -> long"""
        return _digital_swig2.packet_sink_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(packet_sink_sptr self) -> basic_block_sptr"""
        return _digital_swig2.packet_sink_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(packet_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig2.packet_sink_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(packet_sink_sptr self) -> std::string"""
        return _digital_swig2.packet_sink_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(packet_sink_sptr self, std::string name)"""
        return _digital_swig2.packet_sink_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(packet_sink_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig2.packet_sink_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(packet_sink_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.packet_sink_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(packet_sink_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.packet_sink_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(packet_sink_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig2.packet_sink_sptr_message_subscribers(self, which_port)

# Register packet_sink_sptr in _digital_swig2:
_digital_swig2.packet_sink_sptr_swigregister(packet_sink_sptr)


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

class pfb_clock_sync_ccf_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::pfb_clock_sync_ccf > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(pfb_clock_sync_ccf_sptr self) -> pfb_clock_sync_ccf_sptr
        __init__(pfb_clock_sync_ccf_sptr self, pfb_clock_sync_ccf p) -> pfb_clock_sync_ccf_sptr
        """
        _digital_swig2.pfb_clock_sync_ccf_sptr_swiginit(self, _digital_swig2.new_pfb_clock_sync_ccf_sptr(*args))

    def __deref__(self) -> "gr::digital::pfb_clock_sync_ccf *":
        r"""__deref__(pfb_clock_sync_ccf_sptr self) -> pfb_clock_sync_ccf"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_pfb_clock_sync_ccf_sptr

    def make(self, sps: "double", loop_bw: "float", taps: "pmt_vector_float", filter_size: "unsigned int"=32, init_phase: "float"=0, max_rate_deviation: "float"=1.5, osps: "int"=1) -> "gr::digital::pfb_clock_sync_ccf::sptr":
        r"""make(pfb_clock_sync_ccf_sptr self, double sps, float loop_bw, pmt_vector_float taps, unsigned int filter_size=32, float init_phase=0, float max_rate_deviation=1.5, int osps=1) -> pfb_clock_sync_ccf_sptr"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_make(self, sps, loop_bw, taps, filter_size, init_phase, max_rate_deviation, osps)

    def update_gains(self) -> "void":
        r"""update_gains(pfb_clock_sync_ccf_sptr self)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_update_gains(self)

    def update_taps(self, taps: "pmt_vector_float") -> "void":
        r"""update_taps(pfb_clock_sync_ccf_sptr self, pmt_vector_float taps)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_update_taps(self, taps)

    def set_taps(self, taps: "pmt_vector_float", ourtaps: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > &", ourfilter: "std::vector< gr::filter::kernel::fir_filter_ccf *,std::allocator< gr::filter::kernel::fir_filter_ccf * > > &") -> "void":
        r"""set_taps(pfb_clock_sync_ccf_sptr self, pmt_vector_float taps, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > & ourtaps, std::vector< gr::filter::kernel::fir_filter_ccf *,std::allocator< gr::filter::kernel::fir_filter_ccf * > > & ourfilter)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_set_taps(self, taps, ourtaps, ourfilter)

    def taps(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""taps(pfb_clock_sync_ccf_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_taps(self)

    def diff_taps(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""diff_taps(pfb_clock_sync_ccf_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_diff_taps(self)

    def channel_taps(self, channel: "int") -> "std::vector< float,std::allocator< float > >":
        r"""channel_taps(pfb_clock_sync_ccf_sptr self, int channel) -> pmt_vector_float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_channel_taps(self, channel)

    def diff_channel_taps(self, channel: "int") -> "std::vector< float,std::allocator< float > >":
        r"""diff_channel_taps(pfb_clock_sync_ccf_sptr self, int channel) -> pmt_vector_float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_diff_channel_taps(self, channel)

    def taps_as_string(self) -> "std::string":
        r"""taps_as_string(pfb_clock_sync_ccf_sptr self) -> std::string"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_taps_as_string(self)

    def diff_taps_as_string(self) -> "std::string":
        r"""diff_taps_as_string(pfb_clock_sync_ccf_sptr self) -> std::string"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_diff_taps_as_string(self)

    def set_loop_bandwidth(self, bw: "float") -> "void":
        r"""set_loop_bandwidth(pfb_clock_sync_ccf_sptr self, float bw)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_set_loop_bandwidth(self, bw)

    def set_damping_factor(self, df: "float") -> "void":
        r"""set_damping_factor(pfb_clock_sync_ccf_sptr self, float df)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_set_damping_factor(self, df)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(pfb_clock_sync_ccf_sptr self, float alpha)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(pfb_clock_sync_ccf_sptr self, float beta)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_set_beta(self, beta)

    def set_max_rate_deviation(self, m: "float") -> "void":
        r"""set_max_rate_deviation(pfb_clock_sync_ccf_sptr self, float m)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_set_max_rate_deviation(self, m)

    def loop_bandwidth(self) -> "float":
        r"""loop_bandwidth(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_loop_bandwidth(self)

    def damping_factor(self) -> "float":
        r"""damping_factor(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_damping_factor(self)

    def alpha(self) -> "float":
        r"""alpha(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_alpha(self)

    def beta(self) -> "float":
        r"""beta(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_beta(self)

    def clock_rate(self) -> "float":
        r"""clock_rate(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_clock_rate(self)

    def error(self) -> "float":
        r"""error(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_error(self)

    def rate(self) -> "float":
        r"""rate(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_rate(self)

    def phase(self) -> "float":
        r"""phase(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_phase(self)

    def history(self) -> "unsigned int":
        r"""history(pfb_clock_sync_ccf_sptr self) -> unsigned int"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(pfb_clock_sync_ccf_sptr self, int which, int delay)
        declare_sample_delay(pfb_clock_sync_ccf_sptr self, unsigned int delay)
        """
        return _digital_swig2.pfb_clock_sync_ccf_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(pfb_clock_sync_ccf_sptr self, int which) -> unsigned int"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(pfb_clock_sync_ccf_sptr self, int multiple)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(pfb_clock_sync_ccf_sptr self) -> int"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(pfb_clock_sync_ccf_sptr self) -> double"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(pfb_clock_sync_ccf_sptr self) -> uint64_t"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(pfb_clock_sync_ccf_sptr self) -> uint64_t"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(pfb_clock_sync_ccf_sptr self) -> bool"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(pfb_clock_sync_ccf_sptr self) -> bool"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(pfb_clock_sync_ccf_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(pfb_clock_sync_ccf_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(pfb_clock_sync_ccf_sptr self, std::string level)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(pfb_clock_sync_ccf_sptr self) -> std::string"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(pfb_clock_sync_ccf_sptr self) -> int"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(pfb_clock_sync_ccf_sptr self, int m)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(pfb_clock_sync_ccf_sptr self)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(pfb_clock_sync_ccf_sptr self) -> bool"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(pfb_clock_sync_ccf_sptr self, int m)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(pfb_clock_sync_ccf_sptr self) -> int"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(pfb_clock_sync_ccf_sptr self, int i) -> long"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(pfb_clock_sync_ccf_sptr self, long max_output_buffer)
        set_max_output_buffer(pfb_clock_sync_ccf_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig2.pfb_clock_sync_ccf_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(pfb_clock_sync_ccf_sptr self, int i) -> long"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(pfb_clock_sync_ccf_sptr self, long min_output_buffer)
        set_min_output_buffer(pfb_clock_sync_ccf_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig2.pfb_clock_sync_ccf_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(pfb_clock_sync_ccf_sptr self, int which) -> float
        pc_input_buffers_full(pfb_clock_sync_ccf_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.pfb_clock_sync_ccf_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(pfb_clock_sync_ccf_sptr self, int which) -> float
        pc_input_buffers_full_avg(pfb_clock_sync_ccf_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.pfb_clock_sync_ccf_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(pfb_clock_sync_ccf_sptr self, int which) -> float
        pc_input_buffers_full_var(pfb_clock_sync_ccf_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.pfb_clock_sync_ccf_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(pfb_clock_sync_ccf_sptr self, int which) -> float
        pc_output_buffers_full(pfb_clock_sync_ccf_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.pfb_clock_sync_ccf_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(pfb_clock_sync_ccf_sptr self, int which) -> float
        pc_output_buffers_full_avg(pfb_clock_sync_ccf_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.pfb_clock_sync_ccf_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(pfb_clock_sync_ccf_sptr self, int which) -> float
        pc_output_buffers_full_var(pfb_clock_sync_ccf_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.pfb_clock_sync_ccf_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(pfb_clock_sync_ccf_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(pfb_clock_sync_ccf_sptr self)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(pfb_clock_sync_ccf_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(pfb_clock_sync_ccf_sptr self) -> int"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(pfb_clock_sync_ccf_sptr self) -> int"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(pfb_clock_sync_ccf_sptr self, int priority) -> int"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(pfb_clock_sync_ccf_sptr self) -> std::string"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(pfb_clock_sync_ccf_sptr self) -> std::string"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(pfb_clock_sync_ccf_sptr self) -> io_signature_sptr"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(pfb_clock_sync_ccf_sptr self) -> io_signature_sptr"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(pfb_clock_sync_ccf_sptr self) -> long"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(pfb_clock_sync_ccf_sptr self) -> basic_block_sptr"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(pfb_clock_sync_ccf_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(pfb_clock_sync_ccf_sptr self) -> std::string"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(pfb_clock_sync_ccf_sptr self, std::string name)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(pfb_clock_sync_ccf_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(pfb_clock_sync_ccf_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(pfb_clock_sync_ccf_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(pfb_clock_sync_ccf_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_message_subscribers(self, which_port)

# Register pfb_clock_sync_ccf_sptr in _digital_swig2:
_digital_swig2.pfb_clock_sync_ccf_sptr_swigregister(pfb_clock_sync_ccf_sptr)


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

class pfb_clock_sync_fff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::pfb_clock_sync_fff > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(pfb_clock_sync_fff_sptr self) -> pfb_clock_sync_fff_sptr
        __init__(pfb_clock_sync_fff_sptr self, pfb_clock_sync_fff p) -> pfb_clock_sync_fff_sptr
        """
        _digital_swig2.pfb_clock_sync_fff_sptr_swiginit(self, _digital_swig2.new_pfb_clock_sync_fff_sptr(*args))

    def __deref__(self) -> "gr::digital::pfb_clock_sync_fff *":
        r"""__deref__(pfb_clock_sync_fff_sptr self) -> pfb_clock_sync_fff"""
        return _digital_swig2.pfb_clock_sync_fff_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_pfb_clock_sync_fff_sptr

    def make(self, sps: "double", gain: "float", taps: "pmt_vector_float", filter_size: "unsigned int"=32, init_phase: "float"=0, max_rate_deviation: "float"=1.5, osps: "int"=1) -> "gr::digital::pfb_clock_sync_fff::sptr":
        r"""make(pfb_clock_sync_fff_sptr self, double sps, float gain, pmt_vector_float taps, unsigned int filter_size=32, float init_phase=0, float max_rate_deviation=1.5, int osps=1) -> pfb_clock_sync_fff_sptr"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_make(self, sps, gain, taps, filter_size, init_phase, max_rate_deviation, osps)

    def update_gains(self) -> "void":
        r"""update_gains(pfb_clock_sync_fff_sptr self)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_update_gains(self)

    def update_taps(self, taps: "pmt_vector_float") -> "void":
        r"""update_taps(pfb_clock_sync_fff_sptr self, pmt_vector_float taps)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_update_taps(self, taps)

    def set_taps(self, taps: "pmt_vector_float", ourtaps: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > &", ourfilter: "std::vector< gr::filter::kernel::fir_filter_fff *,std::allocator< gr::filter::kernel::fir_filter_fff * > > &") -> "void":
        r"""set_taps(pfb_clock_sync_fff_sptr self, pmt_vector_float taps, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > & ourtaps, std::vector< gr::filter::kernel::fir_filter_fff *,std::allocator< gr::filter::kernel::fir_filter_fff * > > & ourfilter)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_set_taps(self, taps, ourtaps, ourfilter)

    def taps(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""taps(pfb_clock_sync_fff_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_taps(self)

    def diff_taps(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""diff_taps(pfb_clock_sync_fff_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_diff_taps(self)

    def channel_taps(self, channel: "int") -> "std::vector< float,std::allocator< float > >":
        r"""channel_taps(pfb_clock_sync_fff_sptr self, int channel) -> pmt_vector_float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_channel_taps(self, channel)

    def diff_channel_taps(self, channel: "int") -> "std::vector< float,std::allocator< float > >":
        r"""diff_channel_taps(pfb_clock_sync_fff_sptr self, int channel) -> pmt_vector_float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_diff_channel_taps(self, channel)

    def taps_as_string(self) -> "std::string":
        r"""taps_as_string(pfb_clock_sync_fff_sptr self) -> std::string"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_taps_as_string(self)

    def diff_taps_as_string(self) -> "std::string":
        r"""diff_taps_as_string(pfb_clock_sync_fff_sptr self) -> std::string"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_diff_taps_as_string(self)

    def set_loop_bandwidth(self, bw: "float") -> "void":
        r"""set_loop_bandwidth(pfb_clock_sync_fff_sptr self, float bw)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_set_loop_bandwidth(self, bw)

    def set_damping_factor(self, df: "float") -> "void":
        r"""set_damping_factor(pfb_clock_sync_fff_sptr self, float df)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_set_damping_factor(self, df)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(pfb_clock_sync_fff_sptr self, float alpha)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(pfb_clock_sync_fff_sptr self, float beta)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_set_beta(self, beta)

    def set_max_rate_deviation(self, m: "float") -> "void":
        r"""set_max_rate_deviation(pfb_clock_sync_fff_sptr self, float m)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_set_max_rate_deviation(self, m)

    def loop_bandwidth(self) -> "float":
        r"""loop_bandwidth(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_loop_bandwidth(self)

    def damping_factor(self) -> "float":
        r"""damping_factor(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_damping_factor(self)

    def alpha(self) -> "float":
        r"""alpha(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_alpha(self)

    def beta(self) -> "float":
        r"""beta(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_beta(self)

    def clock_rate(self) -> "float":
        r"""clock_rate(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_clock_rate(self)

    def history(self) -> "unsigned int":
        r"""history(pfb_clock_sync_fff_sptr self) -> unsigned int"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(pfb_clock_sync_fff_sptr self, int which, int delay)
        declare_sample_delay(pfb_clock_sync_fff_sptr self, unsigned int delay)
        """
        return _digital_swig2.pfb_clock_sync_fff_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(pfb_clock_sync_fff_sptr self, int which) -> unsigned int"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(pfb_clock_sync_fff_sptr self, int multiple)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(pfb_clock_sync_fff_sptr self) -> int"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(pfb_clock_sync_fff_sptr self) -> double"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(pfb_clock_sync_fff_sptr self) -> uint64_t"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(pfb_clock_sync_fff_sptr self) -> uint64_t"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(pfb_clock_sync_fff_sptr self) -> bool"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(pfb_clock_sync_fff_sptr self) -> bool"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(pfb_clock_sync_fff_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(pfb_clock_sync_fff_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(pfb_clock_sync_fff_sptr self, std::string level)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(pfb_clock_sync_fff_sptr self) -> std::string"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(pfb_clock_sync_fff_sptr self) -> int"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(pfb_clock_sync_fff_sptr self, int m)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(pfb_clock_sync_fff_sptr self)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(pfb_clock_sync_fff_sptr self) -> bool"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(pfb_clock_sync_fff_sptr self, int m)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(pfb_clock_sync_fff_sptr self) -> int"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(pfb_clock_sync_fff_sptr self, int i) -> long"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(pfb_clock_sync_fff_sptr self, long max_output_buffer)
        set_max_output_buffer(pfb_clock_sync_fff_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig2.pfb_clock_sync_fff_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(pfb_clock_sync_fff_sptr self, int i) -> long"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(pfb_clock_sync_fff_sptr self, long min_output_buffer)
        set_min_output_buffer(pfb_clock_sync_fff_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig2.pfb_clock_sync_fff_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(pfb_clock_sync_fff_sptr self, int which) -> float
        pc_input_buffers_full(pfb_clock_sync_fff_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.pfb_clock_sync_fff_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(pfb_clock_sync_fff_sptr self, int which) -> float
        pc_input_buffers_full_avg(pfb_clock_sync_fff_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.pfb_clock_sync_fff_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(pfb_clock_sync_fff_sptr self, int which) -> float
        pc_input_buffers_full_var(pfb_clock_sync_fff_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.pfb_clock_sync_fff_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(pfb_clock_sync_fff_sptr self, int which) -> float
        pc_output_buffers_full(pfb_clock_sync_fff_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.pfb_clock_sync_fff_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(pfb_clock_sync_fff_sptr self, int which) -> float
        pc_output_buffers_full_avg(pfb_clock_sync_fff_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.pfb_clock_sync_fff_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(pfb_clock_sync_fff_sptr self, int which) -> float
        pc_output_buffers_full_var(pfb_clock_sync_fff_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.pfb_clock_sync_fff_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(pfb_clock_sync_fff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(pfb_clock_sync_fff_sptr self)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(pfb_clock_sync_fff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(pfb_clock_sync_fff_sptr self) -> int"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(pfb_clock_sync_fff_sptr self) -> int"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(pfb_clock_sync_fff_sptr self, int priority) -> int"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(pfb_clock_sync_fff_sptr self) -> std::string"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(pfb_clock_sync_fff_sptr self) -> std::string"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(pfb_clock_sync_fff_sptr self) -> io_signature_sptr"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(pfb_clock_sync_fff_sptr self) -> io_signature_sptr"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(pfb_clock_sync_fff_sptr self) -> long"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(pfb_clock_sync_fff_sptr self) -> basic_block_sptr"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(pfb_clock_sync_fff_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(pfb_clock_sync_fff_sptr self) -> std::string"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(pfb_clock_sync_fff_sptr self, std::string name)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(pfb_clock_sync_fff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(pfb_clock_sync_fff_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(pfb_clock_sync_fff_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(pfb_clock_sync_fff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_message_subscribers(self, which_port)

# Register pfb_clock_sync_fff_sptr in _digital_swig2:
_digital_swig2.pfb_clock_sync_fff_sptr_swigregister(pfb_clock_sync_fff_sptr)


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

class pn_correlator_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::pn_correlator_cc > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(pn_correlator_cc_sptr self) -> pn_correlator_cc_sptr
        __init__(pn_correlator_cc_sptr self, pn_correlator_cc p) -> pn_correlator_cc_sptr
        """
        _digital_swig2.pn_correlator_cc_sptr_swiginit(self, _digital_swig2.new_pn_correlator_cc_sptr(*args))

    def __deref__(self) -> "gr::digital::pn_correlator_cc *":
        r"""__deref__(pn_correlator_cc_sptr self) -> pn_correlator_cc"""
        return _digital_swig2.pn_correlator_cc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_pn_correlator_cc_sptr

    def make(self, degree: "int", mask: "int"=0, seed: "int"=1) -> "gr::digital::pn_correlator_cc::sptr":
        r"""make(pn_correlator_cc_sptr self, int degree, int mask=0, int seed=1) -> pn_correlator_cc_sptr"""
        return _digital_swig2.pn_correlator_cc_sptr_make(self, degree, mask, seed)

    def history(self) -> "unsigned int":
        r"""history(pn_correlator_cc_sptr self) -> unsigned int"""
        return _digital_swig2.pn_correlator_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(pn_correlator_cc_sptr self, int which, int delay)
        declare_sample_delay(pn_correlator_cc_sptr self, unsigned int delay)
        """
        return _digital_swig2.pn_correlator_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(pn_correlator_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig2.pn_correlator_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(pn_correlator_cc_sptr self, int multiple)"""
        return _digital_swig2.pn_correlator_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(pn_correlator_cc_sptr self) -> int"""
        return _digital_swig2.pn_correlator_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(pn_correlator_cc_sptr self) -> double"""
        return _digital_swig2.pn_correlator_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(pn_correlator_cc_sptr self) -> uint64_t"""
        return _digital_swig2.pn_correlator_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(pn_correlator_cc_sptr self) -> uint64_t"""
        return _digital_swig2.pn_correlator_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(pn_correlator_cc_sptr self) -> bool"""
        return _digital_swig2.pn_correlator_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(pn_correlator_cc_sptr self) -> bool"""
        return _digital_swig2.pn_correlator_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(pn_correlator_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig2.pn_correlator_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(pn_correlator_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.pn_correlator_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(pn_correlator_cc_sptr self, std::string level)"""
        return _digital_swig2.pn_correlator_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(pn_correlator_cc_sptr self) -> std::string"""
        return _digital_swig2.pn_correlator_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(pn_correlator_cc_sptr self) -> int"""
        return _digital_swig2.pn_correlator_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(pn_correlator_cc_sptr self, int m)"""
        return _digital_swig2.pn_correlator_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(pn_correlator_cc_sptr self)"""
        return _digital_swig2.pn_correlator_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(pn_correlator_cc_sptr self) -> bool"""
        return _digital_swig2.pn_correlator_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(pn_correlator_cc_sptr self, int m)"""
        return _digital_swig2.pn_correlator_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(pn_correlator_cc_sptr self) -> int"""
        return _digital_swig2.pn_correlator_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(pn_correlator_cc_sptr self, int i) -> long"""
        return _digital_swig2.pn_correlator_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(pn_correlator_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(pn_correlator_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig2.pn_correlator_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(pn_correlator_cc_sptr self, int i) -> long"""
        return _digital_swig2.pn_correlator_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(pn_correlator_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(pn_correlator_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig2.pn_correlator_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(pn_correlator_cc_sptr self) -> float"""
        return _digital_swig2.pn_correlator_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(pn_correlator_cc_sptr self) -> float"""
        return _digital_swig2.pn_correlator_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(pn_correlator_cc_sptr self) -> float"""
        return _digital_swig2.pn_correlator_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(pn_correlator_cc_sptr self) -> float"""
        return _digital_swig2.pn_correlator_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(pn_correlator_cc_sptr self) -> float"""
        return _digital_swig2.pn_correlator_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(pn_correlator_cc_sptr self) -> float"""
        return _digital_swig2.pn_correlator_cc_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(pn_correlator_cc_sptr self, int which) -> float
        pc_input_buffers_full(pn_correlator_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.pn_correlator_cc_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(pn_correlator_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(pn_correlator_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.pn_correlator_cc_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(pn_correlator_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(pn_correlator_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.pn_correlator_cc_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(pn_correlator_cc_sptr self, int which) -> float
        pc_output_buffers_full(pn_correlator_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.pn_correlator_cc_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(pn_correlator_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(pn_correlator_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.pn_correlator_cc_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(pn_correlator_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(pn_correlator_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.pn_correlator_cc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(pn_correlator_cc_sptr self) -> float"""
        return _digital_swig2.pn_correlator_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(pn_correlator_cc_sptr self) -> float"""
        return _digital_swig2.pn_correlator_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(pn_correlator_cc_sptr self) -> float"""
        return _digital_swig2.pn_correlator_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(pn_correlator_cc_sptr self) -> float"""
        return _digital_swig2.pn_correlator_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(pn_correlator_cc_sptr self) -> float"""
        return _digital_swig2.pn_correlator_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(pn_correlator_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig2.pn_correlator_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(pn_correlator_cc_sptr self)"""
        return _digital_swig2.pn_correlator_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(pn_correlator_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.pn_correlator_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(pn_correlator_cc_sptr self) -> int"""
        return _digital_swig2.pn_correlator_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(pn_correlator_cc_sptr self) -> int"""
        return _digital_swig2.pn_correlator_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(pn_correlator_cc_sptr self, int priority) -> int"""
        return _digital_swig2.pn_correlator_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(pn_correlator_cc_sptr self) -> std::string"""
        return _digital_swig2.pn_correlator_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(pn_correlator_cc_sptr self) -> std::string"""
        return _digital_swig2.pn_correlator_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(pn_correlator_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig2.pn_correlator_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(pn_correlator_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig2.pn_correlator_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(pn_correlator_cc_sptr self) -> long"""
        return _digital_swig2.pn_correlator_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(pn_correlator_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig2.pn_correlator_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(pn_correlator_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig2.pn_correlator_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(pn_correlator_cc_sptr self) -> std::string"""
        return _digital_swig2.pn_correlator_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(pn_correlator_cc_sptr self, std::string name)"""
        return _digital_swig2.pn_correlator_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(pn_correlator_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig2.pn_correlator_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(pn_correlator_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.pn_correlator_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(pn_correlator_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.pn_correlator_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(pn_correlator_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig2.pn_correlator_cc_sptr_message_subscribers(self, which_port)

# Register pn_correlator_cc_sptr in _digital_swig2:
_digital_swig2.pn_correlator_cc_sptr_swigregister(pn_correlator_cc_sptr)


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

class probe_density_b_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::probe_density_b > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(probe_density_b_sptr self) -> probe_density_b_sptr
        __init__(probe_density_b_sptr self, probe_density_b p) -> probe_density_b_sptr
        """
        _digital_swig2.probe_density_b_sptr_swiginit(self, _digital_swig2.new_probe_density_b_sptr(*args))

    def __deref__(self) -> "gr::digital::probe_density_b *":
        r"""__deref__(probe_density_b_sptr self) -> probe_density_b"""
        return _digital_swig2.probe_density_b_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_probe_density_b_sptr

    def make(self, alpha: "double") -> "gr::digital::probe_density_b::sptr":
        r"""make(probe_density_b_sptr self, double alpha) -> probe_density_b_sptr"""
        return _digital_swig2.probe_density_b_sptr_make(self, alpha)

    def density(self) -> "double":
        r"""density(probe_density_b_sptr self) -> double"""
        return _digital_swig2.probe_density_b_sptr_density(self)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(probe_density_b_sptr self, double alpha)"""
        return _digital_swig2.probe_density_b_sptr_set_alpha(self, alpha)

    def history(self) -> "unsigned int":
        r"""history(probe_density_b_sptr self) -> unsigned int"""
        return _digital_swig2.probe_density_b_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(probe_density_b_sptr self, int which, int delay)
        declare_sample_delay(probe_density_b_sptr self, unsigned int delay)
        """
        return _digital_swig2.probe_density_b_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(probe_density_b_sptr self, int which) -> unsigned int"""
        return _digital_swig2.probe_density_b_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(probe_density_b_sptr self, int multiple)"""
        return _digital_swig2.probe_density_b_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(probe_density_b_sptr self) -> int"""
        return _digital_swig2.probe_density_b_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(probe_density_b_sptr self) -> double"""
        return _digital_swig2.probe_density_b_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(probe_density_b_sptr self) -> uint64_t"""
        return _digital_swig2.probe_density_b_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(probe_density_b_sptr self) -> uint64_t"""
        return _digital_swig2.probe_density_b_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(probe_density_b_sptr self) -> bool"""
        return _digital_swig2.probe_density_b_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(probe_density_b_sptr self) -> bool"""
        return _digital_swig2.probe_density_b_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(probe_density_b_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig2.probe_density_b_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(probe_density_b_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.probe_density_b_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(probe_density_b_sptr self, std::string level)"""
        return _digital_swig2.probe_density_b_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(probe_density_b_sptr self) -> std::string"""
        return _digital_swig2.probe_density_b_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(probe_density_b_sptr self) -> int"""
        return _digital_swig2.probe_density_b_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(probe_density_b_sptr self, int m)"""
        return _digital_swig2.probe_density_b_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(probe_density_b_sptr self)"""
        return _digital_swig2.probe_density_b_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(probe_density_b_sptr self) -> bool"""
        return _digital_swig2.probe_density_b_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(probe_density_b_sptr self, int m)"""
        return _digital_swig2.probe_density_b_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(probe_density_b_sptr self) -> int"""
        return _digital_swig2.probe_density_b_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(probe_density_b_sptr self, int i) -> long"""
        return _digital_swig2.probe_density_b_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(probe_density_b_sptr self, long max_output_buffer)
        set_max_output_buffer(probe_density_b_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig2.probe_density_b_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(probe_density_b_sptr self, int i) -> long"""
        return _digital_swig2.probe_density_b_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(probe_density_b_sptr self, long min_output_buffer)
        set_min_output_buffer(probe_density_b_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig2.probe_density_b_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(probe_density_b_sptr self) -> float"""
        return _digital_swig2.probe_density_b_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(probe_density_b_sptr self) -> float"""
        return _digital_swig2.probe_density_b_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(probe_density_b_sptr self) -> float"""
        return _digital_swig2.probe_density_b_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(probe_density_b_sptr self) -> float"""
        return _digital_swig2.probe_density_b_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(probe_density_b_sptr self) -> float"""
        return _digital_swig2.probe_density_b_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(probe_density_b_sptr self) -> float"""
        return _digital_swig2.probe_density_b_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(probe_density_b_sptr self, int which) -> float
        pc_input_buffers_full(probe_density_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.probe_density_b_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(probe_density_b_sptr self, int which) -> float
        pc_input_buffers_full_avg(probe_density_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.probe_density_b_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(probe_density_b_sptr self, int which) -> float
        pc_input_buffers_full_var(probe_density_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.probe_density_b_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(probe_density_b_sptr self, int which) -> float
        pc_output_buffers_full(probe_density_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.probe_density_b_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(probe_density_b_sptr self, int which) -> float
        pc_output_buffers_full_avg(probe_density_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.probe_density_b_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(probe_density_b_sptr self, int which) -> float
        pc_output_buffers_full_var(probe_density_b_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.probe_density_b_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(probe_density_b_sptr self) -> float"""
        return _digital_swig2.probe_density_b_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(probe_density_b_sptr self) -> float"""
        return _digital_swig2.probe_density_b_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(probe_density_b_sptr self) -> float"""
        return _digital_swig2.probe_density_b_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(probe_density_b_sptr self) -> float"""
        return _digital_swig2.probe_density_b_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(probe_density_b_sptr self) -> float"""
        return _digital_swig2.probe_density_b_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(probe_density_b_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig2.probe_density_b_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(probe_density_b_sptr self)"""
        return _digital_swig2.probe_density_b_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(probe_density_b_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.probe_density_b_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(probe_density_b_sptr self) -> int"""
        return _digital_swig2.probe_density_b_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(probe_density_b_sptr self) -> int"""
        return _digital_swig2.probe_density_b_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(probe_density_b_sptr self, int priority) -> int"""
        return _digital_swig2.probe_density_b_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(probe_density_b_sptr self) -> std::string"""
        return _digital_swig2.probe_density_b_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(probe_density_b_sptr self) -> std::string"""
        return _digital_swig2.probe_density_b_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(probe_density_b_sptr self) -> io_signature_sptr"""
        return _digital_swig2.probe_density_b_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(probe_density_b_sptr self) -> io_signature_sptr"""
        return _digital_swig2.probe_density_b_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(probe_density_b_sptr self) -> long"""
        return _digital_swig2.probe_density_b_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(probe_density_b_sptr self) -> basic_block_sptr"""
        return _digital_swig2.probe_density_b_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(probe_density_b_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig2.probe_density_b_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(probe_density_b_sptr self) -> std::string"""
        return _digital_swig2.probe_density_b_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(probe_density_b_sptr self, std::string name)"""
        return _digital_swig2.probe_density_b_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(probe_density_b_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig2.probe_density_b_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(probe_density_b_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.probe_density_b_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(probe_density_b_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.probe_density_b_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(probe_density_b_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig2.probe_density_b_sptr_message_subscribers(self, which_port)

# Register probe_density_b_sptr in _digital_swig2:
_digital_swig2.probe_density_b_sptr_swigregister(probe_density_b_sptr)


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

class probe_mpsk_snr_est_c_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::probe_mpsk_snr_est_c > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(probe_mpsk_snr_est_c_sptr self) -> probe_mpsk_snr_est_c_sptr
        __init__(probe_mpsk_snr_est_c_sptr self, probe_mpsk_snr_est_c p) -> probe_mpsk_snr_est_c_sptr
        """
        _digital_swig2.probe_mpsk_snr_est_c_sptr_swiginit(self, _digital_swig2.new_probe_mpsk_snr_est_c_sptr(*args))

    def __deref__(self) -> "gr::digital::probe_mpsk_snr_est_c *":
        r"""__deref__(probe_mpsk_snr_est_c_sptr self) -> probe_mpsk_snr_est_c"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_probe_mpsk_snr_est_c_sptr

    def make(self, type: "gr::digital::snr_est_type_t", msg_nsamples: "int"=10000, alpha: "double"=0.001) -> "gr::digital::probe_mpsk_snr_est_c::sptr":
        r"""make(probe_mpsk_snr_est_c_sptr self, gr::digital::snr_est_type_t type, int msg_nsamples=10000, double alpha=0.001) -> probe_mpsk_snr_est_c_sptr"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_make(self, type, msg_nsamples, alpha)

    def snr(self) -> "double":
        r"""snr(probe_mpsk_snr_est_c_sptr self) -> double"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_snr(self)

    def signal(self) -> "double":
        r"""signal(probe_mpsk_snr_est_c_sptr self) -> double"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_signal(self)

    def noise(self) -> "double":
        r"""noise(probe_mpsk_snr_est_c_sptr self) -> double"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_noise(self)

    def type(self) -> "gr::digital::snr_est_type_t":
        r"""type(probe_mpsk_snr_est_c_sptr self) -> gr::digital::snr_est_type_t"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_type(self)

    def msg_nsample(self) -> "int":
        r"""msg_nsample(probe_mpsk_snr_est_c_sptr self) -> int"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_msg_nsample(self)

    def alpha(self) -> "double":
        r"""alpha(probe_mpsk_snr_est_c_sptr self) -> double"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_alpha(self)

    def set_type(self, t: "gr::digital::snr_est_type_t") -> "void":
        r"""set_type(probe_mpsk_snr_est_c_sptr self, gr::digital::snr_est_type_t t)"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_set_type(self, t)

    def set_msg_nsample(self, n: "int") -> "void":
        r"""set_msg_nsample(probe_mpsk_snr_est_c_sptr self, int n)"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_set_msg_nsample(self, n)

    def set_alpha(self, alpha: "double") -> "void":
        r"""set_alpha(probe_mpsk_snr_est_c_sptr self, double alpha)"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_set_alpha(self, alpha)

    def history(self) -> "unsigned int":
        r"""history(probe_mpsk_snr_est_c_sptr self) -> unsigned int"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(probe_mpsk_snr_est_c_sptr self, int which, int delay)
        declare_sample_delay(probe_mpsk_snr_est_c_sptr self, unsigned int delay)
        """
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(probe_mpsk_snr_est_c_sptr self, int which) -> unsigned int"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(probe_mpsk_snr_est_c_sptr self, int multiple)"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(probe_mpsk_snr_est_c_sptr self) -> int"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(probe_mpsk_snr_est_c_sptr self) -> double"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(probe_mpsk_snr_est_c_sptr self) -> uint64_t"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(probe_mpsk_snr_est_c_sptr self) -> uint64_t"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(probe_mpsk_snr_est_c_sptr self) -> bool"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(probe_mpsk_snr_est_c_sptr self) -> bool"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(probe_mpsk_snr_est_c_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(probe_mpsk_snr_est_c_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(probe_mpsk_snr_est_c_sptr self, std::string level)"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(probe_mpsk_snr_est_c_sptr self) -> std::string"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(probe_mpsk_snr_est_c_sptr self) -> int"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(probe_mpsk_snr_est_c_sptr self, int m)"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(probe_mpsk_snr_est_c_sptr self)"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(probe_mpsk_snr_est_c_sptr self) -> bool"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(probe_mpsk_snr_est_c_sptr self, int m)"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(probe_mpsk_snr_est_c_sptr self) -> int"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(probe_mpsk_snr_est_c_sptr self, int i) -> long"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(probe_mpsk_snr_est_c_sptr self, long max_output_buffer)
        set_max_output_buffer(probe_mpsk_snr_est_c_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(probe_mpsk_snr_est_c_sptr self, int i) -> long"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(probe_mpsk_snr_est_c_sptr self, long min_output_buffer)
        set_min_output_buffer(probe_mpsk_snr_est_c_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(probe_mpsk_snr_est_c_sptr self) -> float"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(probe_mpsk_snr_est_c_sptr self) -> float"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(probe_mpsk_snr_est_c_sptr self) -> float"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(probe_mpsk_snr_est_c_sptr self) -> float"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(probe_mpsk_snr_est_c_sptr self) -> float"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(probe_mpsk_snr_est_c_sptr self) -> float"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(probe_mpsk_snr_est_c_sptr self, int which) -> float
        pc_input_buffers_full(probe_mpsk_snr_est_c_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(probe_mpsk_snr_est_c_sptr self, int which) -> float
        pc_input_buffers_full_avg(probe_mpsk_snr_est_c_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(probe_mpsk_snr_est_c_sptr self, int which) -> float
        pc_input_buffers_full_var(probe_mpsk_snr_est_c_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(probe_mpsk_snr_est_c_sptr self, int which) -> float
        pc_output_buffers_full(probe_mpsk_snr_est_c_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(probe_mpsk_snr_est_c_sptr self, int which) -> float
        pc_output_buffers_full_avg(probe_mpsk_snr_est_c_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(probe_mpsk_snr_est_c_sptr self, int which) -> float
        pc_output_buffers_full_var(probe_mpsk_snr_est_c_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(probe_mpsk_snr_est_c_sptr self) -> float"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(probe_mpsk_snr_est_c_sptr self) -> float"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(probe_mpsk_snr_est_c_sptr self) -> float"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(probe_mpsk_snr_est_c_sptr self) -> float"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(probe_mpsk_snr_est_c_sptr self) -> float"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(probe_mpsk_snr_est_c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(probe_mpsk_snr_est_c_sptr self)"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(probe_mpsk_snr_est_c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(probe_mpsk_snr_est_c_sptr self) -> int"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(probe_mpsk_snr_est_c_sptr self) -> int"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(probe_mpsk_snr_est_c_sptr self, int priority) -> int"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(probe_mpsk_snr_est_c_sptr self) -> std::string"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(probe_mpsk_snr_est_c_sptr self) -> std::string"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(probe_mpsk_snr_est_c_sptr self) -> io_signature_sptr"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(probe_mpsk_snr_est_c_sptr self) -> io_signature_sptr"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(probe_mpsk_snr_est_c_sptr self) -> long"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(probe_mpsk_snr_est_c_sptr self) -> basic_block_sptr"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(probe_mpsk_snr_est_c_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(probe_mpsk_snr_est_c_sptr self) -> std::string"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(probe_mpsk_snr_est_c_sptr self, std::string name)"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(probe_mpsk_snr_est_c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(probe_mpsk_snr_est_c_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(probe_mpsk_snr_est_c_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(probe_mpsk_snr_est_c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_message_subscribers(self, which_port)

# Register probe_mpsk_snr_est_c_sptr in _digital_swig2:
_digital_swig2.probe_mpsk_snr_est_c_sptr_swigregister(probe_mpsk_snr_est_c_sptr)


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

class scrambler_bb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::scrambler_bb > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(scrambler_bb_sptr self) -> scrambler_bb_sptr
        __init__(scrambler_bb_sptr self, scrambler_bb p) -> scrambler_bb_sptr
        """
        _digital_swig2.scrambler_bb_sptr_swiginit(self, _digital_swig2.new_scrambler_bb_sptr(*args))

    def __deref__(self) -> "gr::digital::scrambler_bb *":
        r"""__deref__(scrambler_bb_sptr self) -> scrambler_bb"""
        return _digital_swig2.scrambler_bb_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_scrambler_bb_sptr

    def make(self, mask: "int", seed: "int", len: "int") -> "gr::digital::scrambler_bb::sptr":
        r"""make(scrambler_bb_sptr self, int mask, int seed, int len) -> scrambler_bb_sptr"""
        return _digital_swig2.scrambler_bb_sptr_make(self, mask, seed, len)

    def history(self) -> "unsigned int":
        r"""history(scrambler_bb_sptr self) -> unsigned int"""
        return _digital_swig2.scrambler_bb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(scrambler_bb_sptr self, int which, int delay)
        declare_sample_delay(scrambler_bb_sptr self, unsigned int delay)
        """
        return _digital_swig2.scrambler_bb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(scrambler_bb_sptr self, int which) -> unsigned int"""
        return _digital_swig2.scrambler_bb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(scrambler_bb_sptr self, int multiple)"""
        return _digital_swig2.scrambler_bb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(scrambler_bb_sptr self) -> int"""
        return _digital_swig2.scrambler_bb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(scrambler_bb_sptr self) -> double"""
        return _digital_swig2.scrambler_bb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(scrambler_bb_sptr self) -> uint64_t"""
        return _digital_swig2.scrambler_bb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(scrambler_bb_sptr self) -> uint64_t"""
        return _digital_swig2.scrambler_bb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(scrambler_bb_sptr self) -> bool"""
        return _digital_swig2.scrambler_bb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(scrambler_bb_sptr self) -> bool"""
        return _digital_swig2.scrambler_bb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(scrambler_bb_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig2.scrambler_bb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(scrambler_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.scrambler_bb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(scrambler_bb_sptr self, std::string level)"""
        return _digital_swig2.scrambler_bb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(scrambler_bb_sptr self) -> std::string"""
        return _digital_swig2.scrambler_bb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(scrambler_bb_sptr self) -> int"""
        return _digital_swig2.scrambler_bb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(scrambler_bb_sptr self, int m)"""
        return _digital_swig2.scrambler_bb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(scrambler_bb_sptr self)"""
        return _digital_swig2.scrambler_bb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(scrambler_bb_sptr self) -> bool"""
        return _digital_swig2.scrambler_bb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(scrambler_bb_sptr self, int m)"""
        return _digital_swig2.scrambler_bb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(scrambler_bb_sptr self) -> int"""
        return _digital_swig2.scrambler_bb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(scrambler_bb_sptr self, int i) -> long"""
        return _digital_swig2.scrambler_bb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(scrambler_bb_sptr self, long max_output_buffer)
        set_max_output_buffer(scrambler_bb_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig2.scrambler_bb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(scrambler_bb_sptr self, int i) -> long"""
        return _digital_swig2.scrambler_bb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(scrambler_bb_sptr self, long min_output_buffer)
        set_min_output_buffer(scrambler_bb_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig2.scrambler_bb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(scrambler_bb_sptr self) -> float"""
        return _digital_swig2.scrambler_bb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(scrambler_bb_sptr self) -> float"""
        return _digital_swig2.scrambler_bb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(scrambler_bb_sptr self) -> float"""
        return _digital_swig2.scrambler_bb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(scrambler_bb_sptr self) -> float"""
        return _digital_swig2.scrambler_bb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(scrambler_bb_sptr self) -> float"""
        return _digital_swig2.scrambler_bb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(scrambler_bb_sptr self) -> float"""
        return _digital_swig2.scrambler_bb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(scrambler_bb_sptr self, int which) -> float
        pc_input_buffers_full(scrambler_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.scrambler_bb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(scrambler_bb_sptr self, int which) -> float
        pc_input_buffers_full_avg(scrambler_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.scrambler_bb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(scrambler_bb_sptr self, int which) -> float
        pc_input_buffers_full_var(scrambler_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.scrambler_bb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(scrambler_bb_sptr self, int which) -> float
        pc_output_buffers_full(scrambler_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.scrambler_bb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(scrambler_bb_sptr self, int which) -> float
        pc_output_buffers_full_avg(scrambler_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.scrambler_bb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(scrambler_bb_sptr self, int which) -> float
        pc_output_buffers_full_var(scrambler_bb_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.scrambler_bb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(scrambler_bb_sptr self) -> float"""
        return _digital_swig2.scrambler_bb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(scrambler_bb_sptr self) -> float"""
        return _digital_swig2.scrambler_bb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(scrambler_bb_sptr self) -> float"""
        return _digital_swig2.scrambler_bb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(scrambler_bb_sptr self) -> float"""
        return _digital_swig2.scrambler_bb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(scrambler_bb_sptr self) -> float"""
        return _digital_swig2.scrambler_bb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(scrambler_bb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig2.scrambler_bb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(scrambler_bb_sptr self)"""
        return _digital_swig2.scrambler_bb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(scrambler_bb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.scrambler_bb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(scrambler_bb_sptr self) -> int"""
        return _digital_swig2.scrambler_bb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(scrambler_bb_sptr self) -> int"""
        return _digital_swig2.scrambler_bb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(scrambler_bb_sptr self, int priority) -> int"""
        return _digital_swig2.scrambler_bb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(scrambler_bb_sptr self) -> std::string"""
        return _digital_swig2.scrambler_bb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(scrambler_bb_sptr self) -> std::string"""
        return _digital_swig2.scrambler_bb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(scrambler_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig2.scrambler_bb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(scrambler_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig2.scrambler_bb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(scrambler_bb_sptr self) -> long"""
        return _digital_swig2.scrambler_bb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(scrambler_bb_sptr self) -> basic_block_sptr"""
        return _digital_swig2.scrambler_bb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(scrambler_bb_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig2.scrambler_bb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(scrambler_bb_sptr self) -> std::string"""
        return _digital_swig2.scrambler_bb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(scrambler_bb_sptr self, std::string name)"""
        return _digital_swig2.scrambler_bb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(scrambler_bb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig2.scrambler_bb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(scrambler_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.scrambler_bb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(scrambler_bb_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.scrambler_bb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(scrambler_bb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig2.scrambler_bb_sptr_message_subscribers(self, which_port)

# Register scrambler_bb_sptr in _digital_swig2:
_digital_swig2.scrambler_bb_sptr_swigregister(scrambler_bb_sptr)


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

class simple_correlator_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::simple_correlator > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(simple_correlator_sptr self) -> simple_correlator_sptr
        __init__(simple_correlator_sptr self, simple_correlator p) -> simple_correlator_sptr
        """
        _digital_swig2.simple_correlator_sptr_swiginit(self, _digital_swig2.new_simple_correlator_sptr(*args))

    def __deref__(self) -> "gr::digital::simple_correlator *":
        r"""__deref__(simple_correlator_sptr self) -> simple_correlator"""
        return _digital_swig2.simple_correlator_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_simple_correlator_sptr

    def make(self, payload_bytesize: "int") -> "gr::digital::simple_correlator::sptr":
        r"""make(simple_correlator_sptr self, int payload_bytesize) -> simple_correlator_sptr"""
        return _digital_swig2.simple_correlator_sptr_make(self, payload_bytesize)

    def history(self) -> "unsigned int":
        r"""history(simple_correlator_sptr self) -> unsigned int"""
        return _digital_swig2.simple_correlator_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(simple_correlator_sptr self, int which, int delay)
        declare_sample_delay(simple_correlator_sptr self, unsigned int delay)
        """
        return _digital_swig2.simple_correlator_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(simple_correlator_sptr self, int which) -> unsigned int"""
        return _digital_swig2.simple_correlator_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(simple_correlator_sptr self, int multiple)"""
        return _digital_swig2.simple_correlator_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(simple_correlator_sptr self) -> int"""
        return _digital_swig2.simple_correlator_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(simple_correlator_sptr self) -> double"""
        return _digital_swig2.simple_correlator_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(simple_correlator_sptr self) -> uint64_t"""
        return _digital_swig2.simple_correlator_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(simple_correlator_sptr self) -> uint64_t"""
        return _digital_swig2.simple_correlator_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(simple_correlator_sptr self) -> bool"""
        return _digital_swig2.simple_correlator_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(simple_correlator_sptr self) -> bool"""
        return _digital_swig2.simple_correlator_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(simple_correlator_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig2.simple_correlator_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(simple_correlator_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.simple_correlator_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(simple_correlator_sptr self, std::string level)"""
        return _digital_swig2.simple_correlator_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(simple_correlator_sptr self) -> std::string"""
        return _digital_swig2.simple_correlator_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(simple_correlator_sptr self) -> int"""
        return _digital_swig2.simple_correlator_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(simple_correlator_sptr self, int m)"""
        return _digital_swig2.simple_correlator_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(simple_correlator_sptr self)"""
        return _digital_swig2.simple_correlator_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(simple_correlator_sptr self) -> bool"""
        return _digital_swig2.simple_correlator_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(simple_correlator_sptr self, int m)"""
        return _digital_swig2.simple_correlator_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(simple_correlator_sptr self) -> int"""
        return _digital_swig2.simple_correlator_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(simple_correlator_sptr self, int i) -> long"""
        return _digital_swig2.simple_correlator_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(simple_correlator_sptr self, long max_output_buffer)
        set_max_output_buffer(simple_correlator_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig2.simple_correlator_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(simple_correlator_sptr self, int i) -> long"""
        return _digital_swig2.simple_correlator_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(simple_correlator_sptr self, long min_output_buffer)
        set_min_output_buffer(simple_correlator_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig2.simple_correlator_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(simple_correlator_sptr self) -> float"""
        return _digital_swig2.simple_correlator_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(simple_correlator_sptr self) -> float"""
        return _digital_swig2.simple_correlator_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(simple_correlator_sptr self) -> float"""
        return _digital_swig2.simple_correlator_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(simple_correlator_sptr self) -> float"""
        return _digital_swig2.simple_correlator_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(simple_correlator_sptr self) -> float"""
        return _digital_swig2.simple_correlator_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(simple_correlator_sptr self) -> float"""
        return _digital_swig2.simple_correlator_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(simple_correlator_sptr self, int which) -> float
        pc_input_buffers_full(simple_correlator_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.simple_correlator_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(simple_correlator_sptr self, int which) -> float
        pc_input_buffers_full_avg(simple_correlator_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.simple_correlator_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(simple_correlator_sptr self, int which) -> float
        pc_input_buffers_full_var(simple_correlator_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.simple_correlator_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(simple_correlator_sptr self, int which) -> float
        pc_output_buffers_full(simple_correlator_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.simple_correlator_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(simple_correlator_sptr self, int which) -> float
        pc_output_buffers_full_avg(simple_correlator_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.simple_correlator_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(simple_correlator_sptr self, int which) -> float
        pc_output_buffers_full_var(simple_correlator_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.simple_correlator_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(simple_correlator_sptr self) -> float"""
        return _digital_swig2.simple_correlator_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(simple_correlator_sptr self) -> float"""
        return _digital_swig2.simple_correlator_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(simple_correlator_sptr self) -> float"""
        return _digital_swig2.simple_correlator_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(simple_correlator_sptr self) -> float"""
        return _digital_swig2.simple_correlator_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(simple_correlator_sptr self) -> float"""
        return _digital_swig2.simple_correlator_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(simple_correlator_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig2.simple_correlator_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(simple_correlator_sptr self)"""
        return _digital_swig2.simple_correlator_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(simple_correlator_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.simple_correlator_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(simple_correlator_sptr self) -> int"""
        return _digital_swig2.simple_correlator_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(simple_correlator_sptr self) -> int"""
        return _digital_swig2.simple_correlator_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(simple_correlator_sptr self, int priority) -> int"""
        return _digital_swig2.simple_correlator_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(simple_correlator_sptr self) -> std::string"""
        return _digital_swig2.simple_correlator_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(simple_correlator_sptr self) -> std::string"""
        return _digital_swig2.simple_correlator_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(simple_correlator_sptr self) -> io_signature_sptr"""
        return _digital_swig2.simple_correlator_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(simple_correlator_sptr self) -> io_signature_sptr"""
        return _digital_swig2.simple_correlator_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(simple_correlator_sptr self) -> long"""
        return _digital_swig2.simple_correlator_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(simple_correlator_sptr self) -> basic_block_sptr"""
        return _digital_swig2.simple_correlator_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(simple_correlator_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig2.simple_correlator_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(simple_correlator_sptr self) -> std::string"""
        return _digital_swig2.simple_correlator_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(simple_correlator_sptr self, std::string name)"""
        return _digital_swig2.simple_correlator_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(simple_correlator_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig2.simple_correlator_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(simple_correlator_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.simple_correlator_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(simple_correlator_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.simple_correlator_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(simple_correlator_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig2.simple_correlator_sptr_message_subscribers(self, which_port)

# Register simple_correlator_sptr in _digital_swig2:
_digital_swig2.simple_correlator_sptr_swigregister(simple_correlator_sptr)


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

class simple_framer_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::simple_framer > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(simple_framer_sptr self) -> simple_framer_sptr
        __init__(simple_framer_sptr self, simple_framer p) -> simple_framer_sptr
        """
        _digital_swig2.simple_framer_sptr_swiginit(self, _digital_swig2.new_simple_framer_sptr(*args))

    def __deref__(self) -> "gr::digital::simple_framer *":
        r"""__deref__(simple_framer_sptr self) -> simple_framer"""
        return _digital_swig2.simple_framer_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_simple_framer_sptr

    def make(self, payload_bytesize: "int") -> "gr::digital::simple_framer::sptr":
        r"""make(simple_framer_sptr self, int payload_bytesize) -> simple_framer_sptr"""
        return _digital_swig2.simple_framer_sptr_make(self, payload_bytesize)

    def history(self) -> "unsigned int":
        r"""history(simple_framer_sptr self) -> unsigned int"""
        return _digital_swig2.simple_framer_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(simple_framer_sptr self, int which, int delay)
        declare_sample_delay(simple_framer_sptr self, unsigned int delay)
        """
        return _digital_swig2.simple_framer_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(simple_framer_sptr self, int which) -> unsigned int"""
        return _digital_swig2.simple_framer_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(simple_framer_sptr self, int multiple)"""
        return _digital_swig2.simple_framer_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(simple_framer_sptr self) -> int"""
        return _digital_swig2.simple_framer_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(simple_framer_sptr self) -> double"""
        return _digital_swig2.simple_framer_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(simple_framer_sptr self) -> uint64_t"""
        return _digital_swig2.simple_framer_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(simple_framer_sptr self) -> uint64_t"""
        return _digital_swig2.simple_framer_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(simple_framer_sptr self) -> bool"""
        return _digital_swig2.simple_framer_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(simple_framer_sptr self) -> bool"""
        return _digital_swig2.simple_framer_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(simple_framer_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig2.simple_framer_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(simple_framer_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.simple_framer_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(simple_framer_sptr self, std::string level)"""
        return _digital_swig2.simple_framer_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(simple_framer_sptr self) -> std::string"""
        return _digital_swig2.simple_framer_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(simple_framer_sptr self) -> int"""
        return _digital_swig2.simple_framer_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(simple_framer_sptr self, int m)"""
        return _digital_swig2.simple_framer_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(simple_framer_sptr self)"""
        return _digital_swig2.simple_framer_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(simple_framer_sptr self) -> bool"""
        return _digital_swig2.simple_framer_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(simple_framer_sptr self, int m)"""
        return _digital_swig2.simple_framer_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(simple_framer_sptr self) -> int"""
        return _digital_swig2.simple_framer_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(simple_framer_sptr self, int i) -> long"""
        return _digital_swig2.simple_framer_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(simple_framer_sptr self, long max_output_buffer)
        set_max_output_buffer(simple_framer_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig2.simple_framer_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(simple_framer_sptr self, int i) -> long"""
        return _digital_swig2.simple_framer_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(simple_framer_sptr self, long min_output_buffer)
        set_min_output_buffer(simple_framer_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig2.simple_framer_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(simple_framer_sptr self) -> float"""
        return _digital_swig2.simple_framer_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(simple_framer_sptr self) -> float"""
        return _digital_swig2.simple_framer_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(simple_framer_sptr self) -> float"""
        return _digital_swig2.simple_framer_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(simple_framer_sptr self) -> float"""
        return _digital_swig2.simple_framer_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(simple_framer_sptr self) -> float"""
        return _digital_swig2.simple_framer_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(simple_framer_sptr self) -> float"""
        return _digital_swig2.simple_framer_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(simple_framer_sptr self, int which) -> float
        pc_input_buffers_full(simple_framer_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.simple_framer_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(simple_framer_sptr self, int which) -> float
        pc_input_buffers_full_avg(simple_framer_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.simple_framer_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(simple_framer_sptr self, int which) -> float
        pc_input_buffers_full_var(simple_framer_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.simple_framer_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(simple_framer_sptr self, int which) -> float
        pc_output_buffers_full(simple_framer_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.simple_framer_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(simple_framer_sptr self, int which) -> float
        pc_output_buffers_full_avg(simple_framer_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.simple_framer_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(simple_framer_sptr self, int which) -> float
        pc_output_buffers_full_var(simple_framer_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.simple_framer_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(simple_framer_sptr self) -> float"""
        return _digital_swig2.simple_framer_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(simple_framer_sptr self) -> float"""
        return _digital_swig2.simple_framer_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(simple_framer_sptr self) -> float"""
        return _digital_swig2.simple_framer_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(simple_framer_sptr self) -> float"""
        return _digital_swig2.simple_framer_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(simple_framer_sptr self) -> float"""
        return _digital_swig2.simple_framer_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(simple_framer_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig2.simple_framer_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(simple_framer_sptr self)"""
        return _digital_swig2.simple_framer_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(simple_framer_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.simple_framer_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(simple_framer_sptr self) -> int"""
        return _digital_swig2.simple_framer_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(simple_framer_sptr self) -> int"""
        return _digital_swig2.simple_framer_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(simple_framer_sptr self, int priority) -> int"""
        return _digital_swig2.simple_framer_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(simple_framer_sptr self) -> std::string"""
        return _digital_swig2.simple_framer_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(simple_framer_sptr self) -> std::string"""
        return _digital_swig2.simple_framer_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(simple_framer_sptr self) -> io_signature_sptr"""
        return _digital_swig2.simple_framer_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(simple_framer_sptr self) -> io_signature_sptr"""
        return _digital_swig2.simple_framer_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(simple_framer_sptr self) -> long"""
        return _digital_swig2.simple_framer_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(simple_framer_sptr self) -> basic_block_sptr"""
        return _digital_swig2.simple_framer_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(simple_framer_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig2.simple_framer_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(simple_framer_sptr self) -> std::string"""
        return _digital_swig2.simple_framer_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(simple_framer_sptr self, std::string name)"""
        return _digital_swig2.simple_framer_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(simple_framer_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig2.simple_framer_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(simple_framer_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.simple_framer_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(simple_framer_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.simple_framer_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(simple_framer_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig2.simple_framer_sptr_message_subscribers(self, which_port)

# Register simple_framer_sptr in _digital_swig2:
_digital_swig2.simple_framer_sptr_swigregister(simple_framer_sptr)


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

class symbol_sync_cc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::symbol_sync_cc > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(symbol_sync_cc_sptr self) -> symbol_sync_cc_sptr
        __init__(symbol_sync_cc_sptr self, symbol_sync_cc p) -> symbol_sync_cc_sptr
        """
        _digital_swig2.symbol_sync_cc_sptr_swiginit(self, _digital_swig2.new_symbol_sync_cc_sptr(*args))

    def __deref__(self) -> "gr::digital::symbol_sync_cc *":
        r"""__deref__(symbol_sync_cc_sptr self) -> symbol_sync_cc"""
        return _digital_swig2.symbol_sync_cc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_symbol_sync_cc_sptr

    def make(self, *args, **kwargs) -> "gr::digital::symbol_sync_cc::sptr":
        r"""make(symbol_sync_cc_sptr self, enum gr::digital::ted_type detector_type, float sps, float loop_bw, float damping_factor=1.0, float ted_gain=1.0, float max_deviation=1.5, int osps=1, constellation_sptr slicer=gr::digital::constellation_sptr(), gr::digital::ir_type interp_type=IR_MMSE_8TAP, int n_filters=128, pmt_vector_float taps=std::vector< float >()) -> symbol_sync_cc_sptr"""
        return _digital_swig2.symbol_sync_cc_sptr_make(self, *args, **kwargs)

    def loop_bandwidth(self) -> "float":
        r"""loop_bandwidth(symbol_sync_cc_sptr self) -> float"""
        return _digital_swig2.symbol_sync_cc_sptr_loop_bandwidth(self)

    def damping_factor(self) -> "float":
        r"""damping_factor(symbol_sync_cc_sptr self) -> float"""
        return _digital_swig2.symbol_sync_cc_sptr_damping_factor(self)

    def ted_gain(self) -> "float":
        r"""ted_gain(symbol_sync_cc_sptr self) -> float"""
        return _digital_swig2.symbol_sync_cc_sptr_ted_gain(self)

    def alpha(self) -> "float":
        r"""alpha(symbol_sync_cc_sptr self) -> float"""
        return _digital_swig2.symbol_sync_cc_sptr_alpha(self)

    def beta(self) -> "float":
        r"""beta(symbol_sync_cc_sptr self) -> float"""
        return _digital_swig2.symbol_sync_cc_sptr_beta(self)

    def set_loop_bandwidth(self, omega_n_norm: "float") -> "void":
        r"""set_loop_bandwidth(symbol_sync_cc_sptr self, float omega_n_norm)"""
        return _digital_swig2.symbol_sync_cc_sptr_set_loop_bandwidth(self, omega_n_norm)

    def set_damping_factor(self, zeta: "float") -> "void":
        r"""set_damping_factor(symbol_sync_cc_sptr self, float zeta)"""
        return _digital_swig2.symbol_sync_cc_sptr_set_damping_factor(self, zeta)

    def set_ted_gain(self, ted_gain: "float") -> "void":
        r"""set_ted_gain(symbol_sync_cc_sptr self, float ted_gain)"""
        return _digital_swig2.symbol_sync_cc_sptr_set_ted_gain(self, ted_gain)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(symbol_sync_cc_sptr self, float alpha)"""
        return _digital_swig2.symbol_sync_cc_sptr_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(symbol_sync_cc_sptr self, float beta)"""
        return _digital_swig2.symbol_sync_cc_sptr_set_beta(self, beta)

    def history(self) -> "unsigned int":
        r"""history(symbol_sync_cc_sptr self) -> unsigned int"""
        return _digital_swig2.symbol_sync_cc_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(symbol_sync_cc_sptr self, int which, int delay)
        declare_sample_delay(symbol_sync_cc_sptr self, unsigned int delay)
        """
        return _digital_swig2.symbol_sync_cc_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(symbol_sync_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig2.symbol_sync_cc_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(symbol_sync_cc_sptr self, int multiple)"""
        return _digital_swig2.symbol_sync_cc_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(symbol_sync_cc_sptr self) -> int"""
        return _digital_swig2.symbol_sync_cc_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(symbol_sync_cc_sptr self) -> double"""
        return _digital_swig2.symbol_sync_cc_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(symbol_sync_cc_sptr self) -> uint64_t"""
        return _digital_swig2.symbol_sync_cc_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(symbol_sync_cc_sptr self) -> uint64_t"""
        return _digital_swig2.symbol_sync_cc_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(symbol_sync_cc_sptr self) -> bool"""
        return _digital_swig2.symbol_sync_cc_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(symbol_sync_cc_sptr self) -> bool"""
        return _digital_swig2.symbol_sync_cc_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(symbol_sync_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig2.symbol_sync_cc_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(symbol_sync_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.symbol_sync_cc_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(symbol_sync_cc_sptr self, std::string level)"""
        return _digital_swig2.symbol_sync_cc_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(symbol_sync_cc_sptr self) -> std::string"""
        return _digital_swig2.symbol_sync_cc_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(symbol_sync_cc_sptr self) -> int"""
        return _digital_swig2.symbol_sync_cc_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(symbol_sync_cc_sptr self, int m)"""
        return _digital_swig2.symbol_sync_cc_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(symbol_sync_cc_sptr self)"""
        return _digital_swig2.symbol_sync_cc_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(symbol_sync_cc_sptr self) -> bool"""
        return _digital_swig2.symbol_sync_cc_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(symbol_sync_cc_sptr self, int m)"""
        return _digital_swig2.symbol_sync_cc_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(symbol_sync_cc_sptr self) -> int"""
        return _digital_swig2.symbol_sync_cc_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(symbol_sync_cc_sptr self, int i) -> long"""
        return _digital_swig2.symbol_sync_cc_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(symbol_sync_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(symbol_sync_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig2.symbol_sync_cc_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(symbol_sync_cc_sptr self, int i) -> long"""
        return _digital_swig2.symbol_sync_cc_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(symbol_sync_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(symbol_sync_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig2.symbol_sync_cc_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(symbol_sync_cc_sptr self) -> float"""
        return _digital_swig2.symbol_sync_cc_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(symbol_sync_cc_sptr self) -> float"""
        return _digital_swig2.symbol_sync_cc_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(symbol_sync_cc_sptr self) -> float"""
        return _digital_swig2.symbol_sync_cc_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(symbol_sync_cc_sptr self) -> float"""
        return _digital_swig2.symbol_sync_cc_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(symbol_sync_cc_sptr self) -> float"""
        return _digital_swig2.symbol_sync_cc_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(symbol_sync_cc_sptr self) -> float"""
        return _digital_swig2.symbol_sync_cc_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(symbol_sync_cc_sptr self, int which) -> float
        pc_input_buffers_full(symbol_sync_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.symbol_sync_cc_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(symbol_sync_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(symbol_sync_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.symbol_sync_cc_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(symbol_sync_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(symbol_sync_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.symbol_sync_cc_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(symbol_sync_cc_sptr self, int which) -> float
        pc_output_buffers_full(symbol_sync_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.symbol_sync_cc_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(symbol_sync_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(symbol_sync_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.symbol_sync_cc_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(symbol_sync_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(symbol_sync_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.symbol_sync_cc_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(symbol_sync_cc_sptr self) -> float"""
        return _digital_swig2.symbol_sync_cc_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(symbol_sync_cc_sptr self) -> float"""
        return _digital_swig2.symbol_sync_cc_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(symbol_sync_cc_sptr self) -> float"""
        return _digital_swig2.symbol_sync_cc_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(symbol_sync_cc_sptr self) -> float"""
        return _digital_swig2.symbol_sync_cc_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(symbol_sync_cc_sptr self) -> float"""
        return _digital_swig2.symbol_sync_cc_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(symbol_sync_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig2.symbol_sync_cc_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(symbol_sync_cc_sptr self)"""
        return _digital_swig2.symbol_sync_cc_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(symbol_sync_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.symbol_sync_cc_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(symbol_sync_cc_sptr self) -> int"""
        return _digital_swig2.symbol_sync_cc_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(symbol_sync_cc_sptr self) -> int"""
        return _digital_swig2.symbol_sync_cc_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(symbol_sync_cc_sptr self, int priority) -> int"""
        return _digital_swig2.symbol_sync_cc_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(symbol_sync_cc_sptr self) -> std::string"""
        return _digital_swig2.symbol_sync_cc_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(symbol_sync_cc_sptr self) -> std::string"""
        return _digital_swig2.symbol_sync_cc_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(symbol_sync_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig2.symbol_sync_cc_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(symbol_sync_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig2.symbol_sync_cc_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(symbol_sync_cc_sptr self) -> long"""
        return _digital_swig2.symbol_sync_cc_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(symbol_sync_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig2.symbol_sync_cc_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(symbol_sync_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig2.symbol_sync_cc_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(symbol_sync_cc_sptr self) -> std::string"""
        return _digital_swig2.symbol_sync_cc_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(symbol_sync_cc_sptr self, std::string name)"""
        return _digital_swig2.symbol_sync_cc_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(symbol_sync_cc_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig2.symbol_sync_cc_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(symbol_sync_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.symbol_sync_cc_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(symbol_sync_cc_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.symbol_sync_cc_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(symbol_sync_cc_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig2.symbol_sync_cc_sptr_message_subscribers(self, which_port)

# Register symbol_sync_cc_sptr in _digital_swig2:
_digital_swig2.symbol_sync_cc_sptr_swigregister(symbol_sync_cc_sptr)


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

class symbol_sync_ff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::symbol_sync_ff > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(symbol_sync_ff_sptr self) -> symbol_sync_ff_sptr
        __init__(symbol_sync_ff_sptr self, symbol_sync_ff p) -> symbol_sync_ff_sptr
        """
        _digital_swig2.symbol_sync_ff_sptr_swiginit(self, _digital_swig2.new_symbol_sync_ff_sptr(*args))

    def __deref__(self) -> "gr::digital::symbol_sync_ff *":
        r"""__deref__(symbol_sync_ff_sptr self) -> symbol_sync_ff"""
        return _digital_swig2.symbol_sync_ff_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_symbol_sync_ff_sptr

    def make(self, *args, **kwargs) -> "gr::digital::symbol_sync_ff::sptr":
        r"""make(symbol_sync_ff_sptr self, enum gr::digital::ted_type detector_type, float sps, float loop_bw, float damping_factor=1.0, float ted_gain=1.0, float max_deviation=1.5, int osps=1, constellation_sptr slicer=gr::digital::constellation_sptr(), gr::digital::ir_type interp_type=IR_MMSE_8TAP, int n_filters=128, pmt_vector_float taps=std::vector< float >()) -> symbol_sync_ff_sptr"""
        return _digital_swig2.symbol_sync_ff_sptr_make(self, *args, **kwargs)

    def loop_bandwidth(self) -> "float":
        r"""loop_bandwidth(symbol_sync_ff_sptr self) -> float"""
        return _digital_swig2.symbol_sync_ff_sptr_loop_bandwidth(self)

    def damping_factor(self) -> "float":
        r"""damping_factor(symbol_sync_ff_sptr self) -> float"""
        return _digital_swig2.symbol_sync_ff_sptr_damping_factor(self)

    def ted_gain(self) -> "float":
        r"""ted_gain(symbol_sync_ff_sptr self) -> float"""
        return _digital_swig2.symbol_sync_ff_sptr_ted_gain(self)

    def alpha(self) -> "float":
        r"""alpha(symbol_sync_ff_sptr self) -> float"""
        return _digital_swig2.symbol_sync_ff_sptr_alpha(self)

    def beta(self) -> "float":
        r"""beta(symbol_sync_ff_sptr self) -> float"""
        return _digital_swig2.symbol_sync_ff_sptr_beta(self)

    def set_loop_bandwidth(self, omega_n_norm: "float") -> "void":
        r"""set_loop_bandwidth(symbol_sync_ff_sptr self, float omega_n_norm)"""
        return _digital_swig2.symbol_sync_ff_sptr_set_loop_bandwidth(self, omega_n_norm)

    def set_damping_factor(self, zeta: "float") -> "void":
        r"""set_damping_factor(symbol_sync_ff_sptr self, float zeta)"""
        return _digital_swig2.symbol_sync_ff_sptr_set_damping_factor(self, zeta)

    def set_ted_gain(self, ted_gain: "float") -> "void":
        r"""set_ted_gain(symbol_sync_ff_sptr self, float ted_gain)"""
        return _digital_swig2.symbol_sync_ff_sptr_set_ted_gain(self, ted_gain)

    def set_alpha(self, alpha: "float") -> "void":
        r"""set_alpha(symbol_sync_ff_sptr self, float alpha)"""
        return _digital_swig2.symbol_sync_ff_sptr_set_alpha(self, alpha)

    def set_beta(self, beta: "float") -> "void":
        r"""set_beta(symbol_sync_ff_sptr self, float beta)"""
        return _digital_swig2.symbol_sync_ff_sptr_set_beta(self, beta)

    def history(self) -> "unsigned int":
        r"""history(symbol_sync_ff_sptr self) -> unsigned int"""
        return _digital_swig2.symbol_sync_ff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(symbol_sync_ff_sptr self, int which, int delay)
        declare_sample_delay(symbol_sync_ff_sptr self, unsigned int delay)
        """
        return _digital_swig2.symbol_sync_ff_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(symbol_sync_ff_sptr self, int which) -> unsigned int"""
        return _digital_swig2.symbol_sync_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(symbol_sync_ff_sptr self, int multiple)"""
        return _digital_swig2.symbol_sync_ff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(symbol_sync_ff_sptr self) -> int"""
        return _digital_swig2.symbol_sync_ff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(symbol_sync_ff_sptr self) -> double"""
        return _digital_swig2.symbol_sync_ff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(symbol_sync_ff_sptr self) -> uint64_t"""
        return _digital_swig2.symbol_sync_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(symbol_sync_ff_sptr self) -> uint64_t"""
        return _digital_swig2.symbol_sync_ff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(symbol_sync_ff_sptr self) -> bool"""
        return _digital_swig2.symbol_sync_ff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(symbol_sync_ff_sptr self) -> bool"""
        return _digital_swig2.symbol_sync_ff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(symbol_sync_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig2.symbol_sync_ff_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(symbol_sync_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.symbol_sync_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(symbol_sync_ff_sptr self, std::string level)"""
        return _digital_swig2.symbol_sync_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(symbol_sync_ff_sptr self) -> std::string"""
        return _digital_swig2.symbol_sync_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(symbol_sync_ff_sptr self) -> int"""
        return _digital_swig2.symbol_sync_ff_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(symbol_sync_ff_sptr self, int m)"""
        return _digital_swig2.symbol_sync_ff_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(symbol_sync_ff_sptr self)"""
        return _digital_swig2.symbol_sync_ff_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(symbol_sync_ff_sptr self) -> bool"""
        return _digital_swig2.symbol_sync_ff_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(symbol_sync_ff_sptr self, int m)"""
        return _digital_swig2.symbol_sync_ff_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(symbol_sync_ff_sptr self) -> int"""
        return _digital_swig2.symbol_sync_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(symbol_sync_ff_sptr self, int i) -> long"""
        return _digital_swig2.symbol_sync_ff_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(symbol_sync_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(symbol_sync_ff_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig2.symbol_sync_ff_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(symbol_sync_ff_sptr self, int i) -> long"""
        return _digital_swig2.symbol_sync_ff_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(symbol_sync_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(symbol_sync_ff_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig2.symbol_sync_ff_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(symbol_sync_ff_sptr self) -> float"""
        return _digital_swig2.symbol_sync_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(symbol_sync_ff_sptr self) -> float"""
        return _digital_swig2.symbol_sync_ff_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(symbol_sync_ff_sptr self) -> float"""
        return _digital_swig2.symbol_sync_ff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(symbol_sync_ff_sptr self) -> float"""
        return _digital_swig2.symbol_sync_ff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(symbol_sync_ff_sptr self) -> float"""
        return _digital_swig2.symbol_sync_ff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(symbol_sync_ff_sptr self) -> float"""
        return _digital_swig2.symbol_sync_ff_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(symbol_sync_ff_sptr self, int which) -> float
        pc_input_buffers_full(symbol_sync_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.symbol_sync_ff_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(symbol_sync_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(symbol_sync_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.symbol_sync_ff_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(symbol_sync_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(symbol_sync_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.symbol_sync_ff_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(symbol_sync_ff_sptr self, int which) -> float
        pc_output_buffers_full(symbol_sync_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.symbol_sync_ff_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(symbol_sync_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(symbol_sync_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.symbol_sync_ff_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(symbol_sync_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(symbol_sync_ff_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.symbol_sync_ff_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(symbol_sync_ff_sptr self) -> float"""
        return _digital_swig2.symbol_sync_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(symbol_sync_ff_sptr self) -> float"""
        return _digital_swig2.symbol_sync_ff_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(symbol_sync_ff_sptr self) -> float"""
        return _digital_swig2.symbol_sync_ff_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(symbol_sync_ff_sptr self) -> float"""
        return _digital_swig2.symbol_sync_ff_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(symbol_sync_ff_sptr self) -> float"""
        return _digital_swig2.symbol_sync_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(symbol_sync_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig2.symbol_sync_ff_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(symbol_sync_ff_sptr self)"""
        return _digital_swig2.symbol_sync_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(symbol_sync_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.symbol_sync_ff_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(symbol_sync_ff_sptr self) -> int"""
        return _digital_swig2.symbol_sync_ff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(symbol_sync_ff_sptr self) -> int"""
        return _digital_swig2.symbol_sync_ff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(symbol_sync_ff_sptr self, int priority) -> int"""
        return _digital_swig2.symbol_sync_ff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(symbol_sync_ff_sptr self) -> std::string"""
        return _digital_swig2.symbol_sync_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(symbol_sync_ff_sptr self) -> std::string"""
        return _digital_swig2.symbol_sync_ff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(symbol_sync_ff_sptr self) -> io_signature_sptr"""
        return _digital_swig2.symbol_sync_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(symbol_sync_ff_sptr self) -> io_signature_sptr"""
        return _digital_swig2.symbol_sync_ff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(symbol_sync_ff_sptr self) -> long"""
        return _digital_swig2.symbol_sync_ff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(symbol_sync_ff_sptr self) -> basic_block_sptr"""
        return _digital_swig2.symbol_sync_ff_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(symbol_sync_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig2.symbol_sync_ff_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(symbol_sync_ff_sptr self) -> std::string"""
        return _digital_swig2.symbol_sync_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(symbol_sync_ff_sptr self, std::string name)"""
        return _digital_swig2.symbol_sync_ff_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(symbol_sync_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _digital_swig2.symbol_sync_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(symbol_sync_ff_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.symbol_sync_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(symbol_sync_ff_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.symbol_sync_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(symbol_sync_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _digital_swig2.symbol_sync_ff_sptr_message_subscribers(self, which_port)

# Register symbol_sync_ff_sptr in _digital_swig2:
_digital_swig2.symbol_sync_ff_sptr_swigregister(symbol_sync_ff_sptr)


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

class packet_header_default_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::packet_header_default > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(packet_header_default_sptr self) -> packet_header_default_sptr
        __init__(packet_header_default_sptr self, packet_header_default p) -> packet_header_default_sptr
        """
        _digital_swig2.packet_header_default_sptr_swiginit(self, _digital_swig2.new_packet_header_default_sptr(*args))

    def __deref__(self) -> "gr::digital::packet_header_default *":
        r"""__deref__(packet_header_default_sptr self) -> packet_header_default"""
        return _digital_swig2.packet_header_default_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_packet_header_default_sptr

    def base(self) -> "gr::digital::packet_header_default::sptr":
        r"""base(packet_header_default_sptr self) -> packet_header_default_sptr"""
        return _digital_swig2.packet_header_default_sptr_base(self)

    def formatter(self) -> "gr::digital::packet_header_default::sptr":
        r"""formatter(packet_header_default_sptr self) -> packet_header_default_sptr"""
        return _digital_swig2.packet_header_default_sptr_formatter(self)

    def set_header_num(self, header_num: "unsigned int") -> "void":
        r"""set_header_num(packet_header_default_sptr self, unsigned int header_num)"""
        return _digital_swig2.packet_header_default_sptr_set_header_num(self, header_num)

    def header_len(self) -> "long":
        r"""header_len(packet_header_default_sptr self) -> long"""
        return _digital_swig2.packet_header_default_sptr_header_len(self)

    def len_tag_key(self) -> "pmt::pmt_t":
        r"""len_tag_key(packet_header_default_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.packet_header_default_sptr_len_tag_key(self)

    def header_formatter(self, *args, **kwargs) -> "bool":
        r"""header_formatter(packet_header_default_sptr self, long packet_len, unsigned char * out, tags_vector_t tags=std::vector< gr::tag_t >()) -> bool"""
        return _digital_swig2.packet_header_default_sptr_header_formatter(self, *args, **kwargs)

    def header_parser(self, header: "unsigned char const *", tags: "tags_vector_t") -> "bool":
        r"""header_parser(packet_header_default_sptr self, unsigned char const * header, tags_vector_t tags) -> bool"""
        return _digital_swig2.packet_header_default_sptr_header_parser(self, header, tags)

    def make(self, *args, **kwargs) -> "gr::digital::packet_header_default::sptr":
        r"""make(packet_header_default_sptr self, long header_len, std::string const & len_tag_key="packet_len", std::string const & num_tag_key="packet_num", int bits_per_byte=1) -> packet_header_default_sptr"""
        return _digital_swig2.packet_header_default_sptr_make(self, *args, **kwargs)

# Register packet_header_default_sptr in _digital_swig2:
_digital_swig2.packet_header_default_sptr_swigregister(packet_header_default_sptr)


packet_header_default_sptr.__repr__ = lambda self: "<packet_header_default>"
packet_header_default = packet_header_default .make;

class packet_header_ofdm_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::packet_header_ofdm > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(packet_header_ofdm_sptr self) -> packet_header_ofdm_sptr
        __init__(packet_header_ofdm_sptr self, packet_header_ofdm p) -> packet_header_ofdm_sptr
        """
        _digital_swig2.packet_header_ofdm_sptr_swiginit(self, _digital_swig2.new_packet_header_ofdm_sptr(*args))

    def __deref__(self) -> "gr::digital::packet_header_ofdm *":
        r"""__deref__(packet_header_ofdm_sptr self) -> packet_header_ofdm"""
        return _digital_swig2.packet_header_ofdm_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_packet_header_ofdm_sptr

    def make(self, *args, **kwargs) -> "gr::digital::packet_header_ofdm::sptr":
        r"""make(packet_header_ofdm_sptr self, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers, int n_syms, std::string const & len_tag_key="packet_len", std::string const & frame_len_tag_key="frame_len", std::string const & num_tag_key="packet_num", int bits_per_header_sym=1, int bits_per_payload_sym=1, bool scramble_header=False) -> packet_header_ofdm_sptr"""
        return _digital_swig2.packet_header_ofdm_sptr_make(self, *args, **kwargs)

    def base(self) -> "gr::digital::packet_header_default::sptr":
        r"""base(packet_header_ofdm_sptr self) -> packet_header_default_sptr"""
        return _digital_swig2.packet_header_ofdm_sptr_base(self)

    def formatter(self) -> "gr::digital::packet_header_default::sptr":
        r"""formatter(packet_header_ofdm_sptr self) -> packet_header_default_sptr"""
        return _digital_swig2.packet_header_ofdm_sptr_formatter(self)

    def set_header_num(self, header_num: "unsigned int") -> "void":
        r"""set_header_num(packet_header_ofdm_sptr self, unsigned int header_num)"""
        return _digital_swig2.packet_header_ofdm_sptr_set_header_num(self, header_num)

    def header_len(self) -> "long":
        r"""header_len(packet_header_ofdm_sptr self) -> long"""
        return _digital_swig2.packet_header_ofdm_sptr_header_len(self)

    def len_tag_key(self) -> "pmt::pmt_t":
        r"""len_tag_key(packet_header_ofdm_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.packet_header_ofdm_sptr_len_tag_key(self)

    def header_formatter(self, *args, **kwargs) -> "bool":
        r"""header_formatter(packet_header_ofdm_sptr self, long packet_len, unsigned char * out, tags_vector_t tags=std::vector< gr::tag_t >()) -> bool"""
        return _digital_swig2.packet_header_ofdm_sptr_header_formatter(self, *args, **kwargs)

    def header_parser(self, header: "unsigned char const *", tags: "tags_vector_t") -> "bool":
        r"""header_parser(packet_header_ofdm_sptr self, unsigned char const * header, tags_vector_t tags) -> bool"""
        return _digital_swig2.packet_header_ofdm_sptr_header_parser(self, header, tags)

# Register packet_header_ofdm_sptr in _digital_swig2:
_digital_swig2.packet_header_ofdm_sptr_swigregister(packet_header_ofdm_sptr)


packet_header_ofdm_sptr.__repr__ = lambda self: "<packet_header_ofdm>"
packet_header_ofdm = packet_header_ofdm .make;

class header_format_base_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::header_format_base > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(header_format_base_sptr self) -> header_format_base_sptr
        __init__(header_format_base_sptr self, header_format_base p) -> header_format_base_sptr
        """
        _digital_swig2.header_format_base_sptr_swiginit(self, _digital_swig2.new_header_format_base_sptr(*args))

    def __deref__(self) -> "gr::digital::header_format_base *":
        r"""__deref__(header_format_base_sptr self) -> header_format_base"""
        return _digital_swig2.header_format_base_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_header_format_base_sptr

    def base(self) -> "gr::digital::header_format_base::sptr":
        r"""base(header_format_base_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_base_sptr_base(self)

    def formatter(self) -> "gr::digital::header_format_base::sptr":
        r"""formatter(header_format_base_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_base_sptr_formatter(self)

    def format(self, nbytes_in: "int", input: "unsigned char const *", output: "swig_pmt_ptr", info: "swig_pmt_ptr") -> "bool":
        r"""format(header_format_base_sptr self, int nbytes_in, unsigned char const * input, swig_pmt_ptr output, swig_pmt_ptr info) -> bool"""
        return _digital_swig2.header_format_base_sptr_format(self, nbytes_in, input, output, info)

    def parse(self, nbits_in: "int", input: "unsigned char const *", info: "std::vector< pmt::pmt_t,std::allocator< pmt::pmt_t > > &", nbits_processed: "int &") -> "bool":
        r"""parse(header_format_base_sptr self, int nbits_in, unsigned char const * input, std::vector< pmt::pmt_t,std::allocator< pmt::pmt_t > > & info, int & nbits_processed) -> bool"""
        return _digital_swig2.header_format_base_sptr_parse(self, nbits_in, input, info, nbits_processed)

    def header_nbits(self) -> "size_t":
        r"""header_nbits(header_format_base_sptr self) -> size_t"""
        return _digital_swig2.header_format_base_sptr_header_nbits(self)

    def header_nbytes(self) -> "size_t":
        r"""header_nbytes(header_format_base_sptr self) -> size_t"""
        return _digital_swig2.header_format_base_sptr_header_nbytes(self)

# Register header_format_base_sptr in _digital_swig2:
_digital_swig2.header_format_base_sptr_swigregister(header_format_base_sptr)

class header_format_default_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::header_format_default > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(header_format_default_sptr self) -> header_format_default_sptr
        __init__(header_format_default_sptr self, header_format_default p) -> header_format_default_sptr
        """
        _digital_swig2.header_format_default_sptr_swiginit(self, _digital_swig2.new_header_format_default_sptr(*args))

    def __deref__(self) -> "gr::digital::header_format_default *":
        r"""__deref__(header_format_default_sptr self) -> header_format_default"""
        return _digital_swig2.header_format_default_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_header_format_default_sptr

    def set_access_code(self, access_code: "std::string const &") -> "bool":
        r"""set_access_code(header_format_default_sptr self, std::string const & access_code) -> bool"""
        return _digital_swig2.header_format_default_sptr_set_access_code(self, access_code)

    def access_code(self) -> "unsigned long long":
        r"""access_code(header_format_default_sptr self) -> unsigned long long"""
        return _digital_swig2.header_format_default_sptr_access_code(self)

    def set_threshold(self, thresh: "unsigned int"=0) -> "void":
        r"""set_threshold(header_format_default_sptr self, unsigned int thresh=0)"""
        return _digital_swig2.header_format_default_sptr_set_threshold(self, thresh)

    def threshold(self) -> "unsigned int":
        r"""threshold(header_format_default_sptr self) -> unsigned int"""
        return _digital_swig2.header_format_default_sptr_threshold(self)

    def make(self, access_code: "std::string const &", threshold: "int", bps: "int"=1) -> "gr::digital::header_format_base::sptr":
        r"""make(header_format_default_sptr self, std::string const & access_code, int threshold, int bps=1) -> header_format_base_sptr"""
        return _digital_swig2.header_format_default_sptr_make(self, access_code, threshold, bps)

    def base(self) -> "gr::digital::header_format_base::sptr":
        r"""base(header_format_default_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_default_sptr_base(self)

    def formatter(self) -> "gr::digital::header_format_base::sptr":
        r"""formatter(header_format_default_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_default_sptr_formatter(self)

    def format(self, nbytes_in: "int", input: "unsigned char const *", output: "swig_pmt_ptr", info: "swig_pmt_ptr") -> "bool":
        r"""format(header_format_default_sptr self, int nbytes_in, unsigned char const * input, swig_pmt_ptr output, swig_pmt_ptr info) -> bool"""
        return _digital_swig2.header_format_default_sptr_format(self, nbytes_in, input, output, info)

    def parse(self, nbits_in: "int", input: "unsigned char const *", info: "std::vector< pmt::pmt_t,std::allocator< pmt::pmt_t > > &", nbits_processed: "int &") -> "bool":
        r"""parse(header_format_default_sptr self, int nbits_in, unsigned char const * input, std::vector< pmt::pmt_t,std::allocator< pmt::pmt_t > > & info, int & nbits_processed) -> bool"""
        return _digital_swig2.header_format_default_sptr_parse(self, nbits_in, input, info, nbits_processed)

    def header_nbits(self) -> "size_t":
        r"""header_nbits(header_format_default_sptr self) -> size_t"""
        return _digital_swig2.header_format_default_sptr_header_nbits(self)

    def header_nbytes(self) -> "size_t":
        r"""header_nbytes(header_format_default_sptr self) -> size_t"""
        return _digital_swig2.header_format_default_sptr_header_nbytes(self)

# Register header_format_default_sptr in _digital_swig2:
_digital_swig2.header_format_default_sptr_swigregister(header_format_default_sptr)


header_format_default_sptr.__repr__ = lambda self: "<header_format_default>"
header_format_default = header_format_default .make;

class header_format_counter_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::header_format_counter > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(header_format_counter_sptr self) -> header_format_counter_sptr
        __init__(header_format_counter_sptr self, header_format_counter p) -> header_format_counter_sptr
        """
        _digital_swig2.header_format_counter_sptr_swiginit(self, _digital_swig2.new_header_format_counter_sptr(*args))

    def __deref__(self) -> "gr::digital::header_format_counter *":
        r"""__deref__(header_format_counter_sptr self) -> header_format_counter"""
        return _digital_swig2.header_format_counter_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_header_format_counter_sptr

    def make(self, access_code: "std::string const &", threshold: "int", bps: "int") -> "gr::digital::header_format_base::sptr":
        r"""make(header_format_counter_sptr self, std::string const & access_code, int threshold, int bps) -> header_format_base_sptr"""
        return _digital_swig2.header_format_counter_sptr_make(self, access_code, threshold, bps)

    def set_access_code(self, access_code: "std::string const &") -> "bool":
        r"""set_access_code(header_format_counter_sptr self, std::string const & access_code) -> bool"""
        return _digital_swig2.header_format_counter_sptr_set_access_code(self, access_code)

    def access_code(self) -> "unsigned long long":
        r"""access_code(header_format_counter_sptr self) -> unsigned long long"""
        return _digital_swig2.header_format_counter_sptr_access_code(self)

    def set_threshold(self, thresh: "unsigned int"=0) -> "void":
        r"""set_threshold(header_format_counter_sptr self, unsigned int thresh=0)"""
        return _digital_swig2.header_format_counter_sptr_set_threshold(self, thresh)

    def threshold(self) -> "unsigned int":
        r"""threshold(header_format_counter_sptr self) -> unsigned int"""
        return _digital_swig2.header_format_counter_sptr_threshold(self)

    def base(self) -> "gr::digital::header_format_base::sptr":
        r"""base(header_format_counter_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_counter_sptr_base(self)

    def formatter(self) -> "gr::digital::header_format_base::sptr":
        r"""formatter(header_format_counter_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_counter_sptr_formatter(self)

    def format(self, nbytes_in: "int", input: "unsigned char const *", output: "swig_pmt_ptr", info: "swig_pmt_ptr") -> "bool":
        r"""format(header_format_counter_sptr self, int nbytes_in, unsigned char const * input, swig_pmt_ptr output, swig_pmt_ptr info) -> bool"""
        return _digital_swig2.header_format_counter_sptr_format(self, nbytes_in, input, output, info)

    def parse(self, nbits_in: "int", input: "unsigned char const *", info: "std::vector< pmt::pmt_t,std::allocator< pmt::pmt_t > > &", nbits_processed: "int &") -> "bool":
        r"""parse(header_format_counter_sptr self, int nbits_in, unsigned char const * input, std::vector< pmt::pmt_t,std::allocator< pmt::pmt_t > > & info, int & nbits_processed) -> bool"""
        return _digital_swig2.header_format_counter_sptr_parse(self, nbits_in, input, info, nbits_processed)

    def header_nbits(self) -> "size_t":
        r"""header_nbits(header_format_counter_sptr self) -> size_t"""
        return _digital_swig2.header_format_counter_sptr_header_nbits(self)

    def header_nbytes(self) -> "size_t":
        r"""header_nbytes(header_format_counter_sptr self) -> size_t"""
        return _digital_swig2.header_format_counter_sptr_header_nbytes(self)

# Register header_format_counter_sptr in _digital_swig2:
_digital_swig2.header_format_counter_sptr_swigregister(header_format_counter_sptr)


header_format_counter_sptr.__repr__ = lambda self: "<header_format_counter>"
header_format_counter = header_format_counter .make;

class header_format_crc_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::header_format_crc > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(header_format_crc_sptr self) -> header_format_crc_sptr
        __init__(header_format_crc_sptr self, header_format_crc p) -> header_format_crc_sptr
        """
        _digital_swig2.header_format_crc_sptr_swiginit(self, _digital_swig2.new_header_format_crc_sptr(*args))

    def __deref__(self) -> "gr::digital::header_format_crc *":
        r"""__deref__(header_format_crc_sptr self) -> header_format_crc"""
        return _digital_swig2.header_format_crc_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_header_format_crc_sptr

    def set_header_num(self, header_num: "unsigned int") -> "void":
        r"""set_header_num(header_format_crc_sptr self, unsigned int header_num)"""
        return _digital_swig2.header_format_crc_sptr_set_header_num(self, header_num)

    def make(self, *args, **kwargs) -> "gr::digital::header_format_base::sptr":
        r"""make(header_format_crc_sptr self, std::string const & len_key_name="packet_len", std::string const & num_key_name="packet_num") -> header_format_base_sptr"""
        return _digital_swig2.header_format_crc_sptr_make(self, *args, **kwargs)

    def base(self) -> "gr::digital::header_format_base::sptr":
        r"""base(header_format_crc_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_crc_sptr_base(self)

    def formatter(self) -> "gr::digital::header_format_base::sptr":
        r"""formatter(header_format_crc_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_crc_sptr_formatter(self)

    def format(self, nbytes_in: "int", input: "unsigned char const *", output: "swig_pmt_ptr", info: "swig_pmt_ptr") -> "bool":
        r"""format(header_format_crc_sptr self, int nbytes_in, unsigned char const * input, swig_pmt_ptr output, swig_pmt_ptr info) -> bool"""
        return _digital_swig2.header_format_crc_sptr_format(self, nbytes_in, input, output, info)

    def parse(self, nbits_in: "int", input: "unsigned char const *", info: "std::vector< pmt::pmt_t,std::allocator< pmt::pmt_t > > &", nbits_processed: "int &") -> "bool":
        r"""parse(header_format_crc_sptr self, int nbits_in, unsigned char const * input, std::vector< pmt::pmt_t,std::allocator< pmt::pmt_t > > & info, int & nbits_processed) -> bool"""
        return _digital_swig2.header_format_crc_sptr_parse(self, nbits_in, input, info, nbits_processed)

    def header_nbits(self) -> "size_t":
        r"""header_nbits(header_format_crc_sptr self) -> size_t"""
        return _digital_swig2.header_format_crc_sptr_header_nbits(self)

    def header_nbytes(self) -> "size_t":
        r"""header_nbytes(header_format_crc_sptr self) -> size_t"""
        return _digital_swig2.header_format_crc_sptr_header_nbytes(self)

# Register header_format_crc_sptr in _digital_swig2:
_digital_swig2.header_format_crc_sptr_swigregister(header_format_crc_sptr)


header_format_crc_sptr.__repr__ = lambda self: "<header_format_crc>"
header_format_crc = header_format_crc .make;

class header_format_ofdm_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::header_format_ofdm > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(header_format_ofdm_sptr self) -> header_format_ofdm_sptr
        __init__(header_format_ofdm_sptr self, header_format_ofdm p) -> header_format_ofdm_sptr
        """
        _digital_swig2.header_format_ofdm_sptr_swiginit(self, _digital_swig2.new_header_format_ofdm_sptr(*args))

    def __deref__(self) -> "gr::digital::header_format_ofdm *":
        r"""__deref__(header_format_ofdm_sptr self) -> header_format_ofdm"""
        return _digital_swig2.header_format_ofdm_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_header_format_ofdm_sptr

    def make(self, *args, **kwargs) -> "gr::digital::header_format_base::sptr":
        r"""make(header_format_ofdm_sptr self, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & occupied_carriers, int n_syms, std::string const & len_key_name="packet_len", std::string const & frame_key_name="frame_len", std::string const & num_key_name="packet_num", int bits_per_header_sym=1, int bits_per_payload_sym=1, bool scramble_header=False) -> header_format_base_sptr"""
        return _digital_swig2.header_format_ofdm_sptr_make(self, *args, **kwargs)

    def set_header_num(self, header_num: "unsigned int") -> "void":
        r"""set_header_num(header_format_ofdm_sptr self, unsigned int header_num)"""
        return _digital_swig2.header_format_ofdm_sptr_set_header_num(self, header_num)

    def base(self) -> "gr::digital::header_format_base::sptr":
        r"""base(header_format_ofdm_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_ofdm_sptr_base(self)

    def formatter(self) -> "gr::digital::header_format_base::sptr":
        r"""formatter(header_format_ofdm_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_ofdm_sptr_formatter(self)

    def format(self, nbytes_in: "int", input: "unsigned char const *", output: "swig_pmt_ptr", info: "swig_pmt_ptr") -> "bool":
        r"""format(header_format_ofdm_sptr self, int nbytes_in, unsigned char const * input, swig_pmt_ptr output, swig_pmt_ptr info) -> bool"""
        return _digital_swig2.header_format_ofdm_sptr_format(self, nbytes_in, input, output, info)

    def parse(self, nbits_in: "int", input: "unsigned char const *", info: "std::vector< pmt::pmt_t,std::allocator< pmt::pmt_t > > &", nbits_processed: "int &") -> "bool":
        r"""parse(header_format_ofdm_sptr self, int nbits_in, unsigned char const * input, std::vector< pmt::pmt_t,std::allocator< pmt::pmt_t > > & info, int & nbits_processed) -> bool"""
        return _digital_swig2.header_format_ofdm_sptr_parse(self, nbits_in, input, info, nbits_processed)

    def header_nbits(self) -> "size_t":
        r"""header_nbits(header_format_ofdm_sptr self) -> size_t"""
        return _digital_swig2.header_format_ofdm_sptr_header_nbits(self)

    def header_nbytes(self) -> "size_t":
        r"""header_nbytes(header_format_ofdm_sptr self) -> size_t"""
        return _digital_swig2.header_format_ofdm_sptr_header_nbytes(self)

# Register header_format_ofdm_sptr in _digital_swig2:
_digital_swig2.header_format_ofdm_sptr_swigregister(header_format_ofdm_sptr)


header_format_ofdm_sptr.__repr__ = lambda self: "<header_format_ofdm>"
header_format_ofdm = header_format_ofdm .make;

class constellation_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(constellation_sptr self) -> constellation_sptr
        __init__(constellation_sptr self, constellation p) -> constellation_sptr
        """
        _digital_swig2.constellation_sptr_swiginit(self, _digital_swig2.new_constellation_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation *":
        r"""__deref__(constellation_sptr self) -> constellation"""
        return _digital_swig2.constellation_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_constellation_sptr

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig2.constellation_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig2.constellation_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig2.constellation_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig2.constellation_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig2.constellation_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig2.constellation_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_sptr self) -> bool"""
        return _digital_swig2.constellation_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_sptr self, bool a)"""
        return _digital_swig2.constellation_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.constellation_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_sptr self) -> constellation_sptr"""
        return _digital_swig2.constellation_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.constellation_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig2.constellation_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig2.constellation_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig2.constellation_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_sptr self) -> bool"""
        return _digital_swig2.constellation_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.constellation_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig2.constellation_sptr_soft_decision_maker(self, sample)

# Register constellation_sptr in _digital_swig2:
_digital_swig2.constellation_sptr_swigregister(constellation_sptr)

class constellation_calcdist_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_calcdist > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(constellation_calcdist_sptr self) -> constellation_calcdist_sptr
        __init__(constellation_calcdist_sptr self, constellation_calcdist p) -> constellation_calcdist_sptr
        """
        _digital_swig2.constellation_calcdist_sptr_swiginit(self, _digital_swig2.new_constellation_calcdist_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_calcdist *":
        r"""__deref__(constellation_calcdist_sptr self) -> constellation_calcdist"""
        return _digital_swig2.constellation_calcdist_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_constellation_calcdist_sptr

    def make(self, constell: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", rotational_symmetry: "unsigned int", dimensionality: "unsigned int", normalize_points: "bool"=True) -> "gr::digital::constellation_calcdist::sptr":
        r"""make(constellation_calcdist_sptr self, pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int dimensionality, bool normalize_points=True) -> constellation_calcdist_sptr"""
        return _digital_swig2.constellation_calcdist_sptr_make(self, constell, pre_diff_code, rotational_symmetry, dimensionality, normalize_points)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_calcdist_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig2.constellation_calcdist_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_calcdist_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_calcdist_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_calcdist_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig2.constellation_calcdist_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_calcdist_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig2.constellation_calcdist_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_calcdist_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig2.constellation_calcdist_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_calcdist_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig2.constellation_calcdist_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_calcdist_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_calcdist_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_calcdist_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_calcdist_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_calcdist_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_calcdist_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_calcdist_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_calcdist_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_calcdist_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig2.constellation_calcdist_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_calcdist_sptr self) -> bool"""
        return _digital_swig2.constellation_calcdist_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_calcdist_sptr self, bool a)"""
        return _digital_swig2.constellation_calcdist_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_calcdist_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.constellation_calcdist_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_calcdist_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_calcdist_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_calcdist_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_calcdist_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_calcdist_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_calcdist_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_calcdist_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_calcdist_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_calcdist_sptr self) -> constellation_sptr"""
        return _digital_swig2.constellation_calcdist_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_calcdist_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.constellation_calcdist_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_calcdist_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig2.constellation_calcdist_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_calcdist_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig2.constellation_calcdist_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_calcdist_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig2.constellation_calcdist_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_calcdist_sptr self) -> bool"""
        return _digital_swig2.constellation_calcdist_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_calcdist_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.constellation_calcdist_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_calcdist_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig2.constellation_calcdist_sptr_soft_decision_maker(self, sample)

# Register constellation_calcdist_sptr in _digital_swig2:
_digital_swig2.constellation_calcdist_sptr_swigregister(constellation_calcdist_sptr)


constellation_calcdist_sptr.__repr__ = lambda self: "<constellation calcdist (m=%d)>" % (len(self.points()))
constellation_calcdist = constellation_calcdist.make;

class constellation_rect_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_rect > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(constellation_rect_sptr self) -> constellation_rect_sptr
        __init__(constellation_rect_sptr self, constellation_rect p) -> constellation_rect_sptr
        """
        _digital_swig2.constellation_rect_sptr_swiginit(self, _digital_swig2.new_constellation_rect_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_rect *":
        r"""__deref__(constellation_rect_sptr self) -> constellation_rect"""
        return _digital_swig2.constellation_rect_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_constellation_rect_sptr

    def make(self, constell: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", rotational_symmetry: "unsigned int", real_sectors: "unsigned int", imag_sectors: "unsigned int", width_real_sectors: "float", width_imag_sectors: "float") -> "gr::digital::constellation_rect::sptr":
        r"""make(constellation_rect_sptr self, pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int real_sectors, unsigned int imag_sectors, float width_real_sectors, float width_imag_sectors) -> constellation_rect_sptr"""
        return _digital_swig2.constellation_rect_sptr_make(self, constell, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_rect_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig2.constellation_rect_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_rect_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_rect_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_rect_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig2.constellation_rect_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_rect_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig2.constellation_rect_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_rect_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig2.constellation_rect_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_rect_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig2.constellation_rect_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_rect_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_rect_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_rect_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_rect_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_rect_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_rect_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_rect_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_rect_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_rect_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig2.constellation_rect_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_rect_sptr self) -> bool"""
        return _digital_swig2.constellation_rect_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_rect_sptr self, bool a)"""
        return _digital_swig2.constellation_rect_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_rect_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.constellation_rect_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_rect_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_rect_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_rect_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_rect_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_rect_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_rect_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_rect_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_rect_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_rect_sptr self) -> constellation_sptr"""
        return _digital_swig2.constellation_rect_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_rect_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.constellation_rect_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_rect_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig2.constellation_rect_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_rect_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig2.constellation_rect_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_rect_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig2.constellation_rect_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_rect_sptr self) -> bool"""
        return _digital_swig2.constellation_rect_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_rect_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.constellation_rect_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_rect_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig2.constellation_rect_sptr_soft_decision_maker(self, sample)

# Register constellation_rect_sptr in _digital_swig2:
_digital_swig2.constellation_rect_sptr_swigregister(constellation_rect_sptr)


constellation_rect_sptr.__repr__ = lambda self: "<constellation rect (m=%d)>" % (len(self.points()))
constellation_rect = constellation_rect.make;

class constellation_expl_rect_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_expl_rect > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(constellation_expl_rect_sptr self) -> constellation_expl_rect_sptr
        __init__(constellation_expl_rect_sptr self, constellation_expl_rect p) -> constellation_expl_rect_sptr
        """
        _digital_swig2.constellation_expl_rect_sptr_swiginit(self, _digital_swig2.new_constellation_expl_rect_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_expl_rect *":
        r"""__deref__(constellation_expl_rect_sptr self) -> constellation_expl_rect"""
        return _digital_swig2.constellation_expl_rect_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_constellation_expl_rect_sptr

    def make(self, constellation: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", rotational_symmetry: "unsigned int", real_sectors: "unsigned int", imag_sectors: "unsigned int", width_real_sectors: "float", width_imag_sectors: "float", sector_values: "std::vector< unsigned int,std::allocator< unsigned int > >") -> "gr::digital::constellation_expl_rect::sptr":
        r"""make(constellation_expl_rect_sptr self, pmt_vector_cfloat constellation, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int real_sectors, unsigned int imag_sectors, float width_real_sectors, float width_imag_sectors, std::vector< unsigned int,std::allocator< unsigned int > > sector_values) -> constellation_expl_rect_sptr"""
        return _digital_swig2.constellation_expl_rect_sptr_make(self, constellation, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors, sector_values)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_expl_rect_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig2.constellation_expl_rect_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_expl_rect_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_expl_rect_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_expl_rect_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig2.constellation_expl_rect_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_expl_rect_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig2.constellation_expl_rect_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_expl_rect_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig2.constellation_expl_rect_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_expl_rect_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig2.constellation_expl_rect_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_expl_rect_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_expl_rect_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_expl_rect_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_expl_rect_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_expl_rect_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_expl_rect_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_expl_rect_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_expl_rect_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_expl_rect_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig2.constellation_expl_rect_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_expl_rect_sptr self) -> bool"""
        return _digital_swig2.constellation_expl_rect_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_expl_rect_sptr self, bool a)"""
        return _digital_swig2.constellation_expl_rect_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_expl_rect_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.constellation_expl_rect_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_expl_rect_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_expl_rect_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_expl_rect_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_expl_rect_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_expl_rect_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_expl_rect_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_expl_rect_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_expl_rect_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_expl_rect_sptr self) -> constellation_sptr"""
        return _digital_swig2.constellation_expl_rect_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_expl_rect_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.constellation_expl_rect_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_expl_rect_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig2.constellation_expl_rect_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_expl_rect_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig2.constellation_expl_rect_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_expl_rect_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig2.constellation_expl_rect_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_expl_rect_sptr self) -> bool"""
        return _digital_swig2.constellation_expl_rect_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_expl_rect_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.constellation_expl_rect_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_expl_rect_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig2.constellation_expl_rect_sptr_soft_decision_maker(self, sample)

# Register constellation_expl_rect_sptr in _digital_swig2:
_digital_swig2.constellation_expl_rect_sptr_swigregister(constellation_expl_rect_sptr)


constellation_expl_rect_sptr.__repr__ = lambda self: "<constellation expl rect (m=%d)>" % (len(self.points()))
constellation_expl_rect = constellation_expl_rect.make;

class constellation_psk_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_psk > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(constellation_psk_sptr self) -> constellation_psk_sptr
        __init__(constellation_psk_sptr self, constellation_psk p) -> constellation_psk_sptr
        """
        _digital_swig2.constellation_psk_sptr_swiginit(self, _digital_swig2.new_constellation_psk_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_psk *":
        r"""__deref__(constellation_psk_sptr self) -> constellation_psk"""
        return _digital_swig2.constellation_psk_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_constellation_psk_sptr

    def make(self, constell: "pmt_vector_cfloat", pre_diff_code: "std::vector< int,std::allocator< int > >", n_sectors: "unsigned int") -> "gr::digital::constellation_psk::sptr":
        r"""make(constellation_psk_sptr self, pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int n_sectors) -> constellation_psk_sptr"""
        return _digital_swig2.constellation_psk_sptr_make(self, constell, pre_diff_code, n_sectors)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_psk_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig2.constellation_psk_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_psk_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_psk_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_psk_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig2.constellation_psk_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_psk_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig2.constellation_psk_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_psk_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig2.constellation_psk_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_psk_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig2.constellation_psk_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_psk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_psk_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_psk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_psk_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_psk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_psk_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_psk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_psk_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_psk_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig2.constellation_psk_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_psk_sptr self) -> bool"""
        return _digital_swig2.constellation_psk_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_psk_sptr self, bool a)"""
        return _digital_swig2.constellation_psk_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_psk_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.constellation_psk_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_psk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_psk_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_psk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_psk_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_psk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_psk_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_psk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_psk_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_psk_sptr self) -> constellation_sptr"""
        return _digital_swig2.constellation_psk_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_psk_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.constellation_psk_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_psk_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig2.constellation_psk_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_psk_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig2.constellation_psk_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_psk_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig2.constellation_psk_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_psk_sptr self) -> bool"""
        return _digital_swig2.constellation_psk_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_psk_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.constellation_psk_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_psk_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig2.constellation_psk_sptr_soft_decision_maker(self, sample)

# Register constellation_psk_sptr in _digital_swig2:
_digital_swig2.constellation_psk_sptr_swigregister(constellation_psk_sptr)


constellation_psk_sptr.__repr__ = lambda self: "<constellation PSK (m=%d)>" % (len(self.points()))
constellation_psk = constellation_psk.make;

class constellation_bpsk_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_bpsk > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(constellation_bpsk_sptr self) -> constellation_bpsk_sptr
        __init__(constellation_bpsk_sptr self, constellation_bpsk p) -> constellation_bpsk_sptr
        """
        _digital_swig2.constellation_bpsk_sptr_swiginit(self, _digital_swig2.new_constellation_bpsk_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_bpsk *":
        r"""__deref__(constellation_bpsk_sptr self) -> constellation_bpsk"""
        return _digital_swig2.constellation_bpsk_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_constellation_bpsk_sptr

    def make(self) -> "gr::digital::constellation_bpsk::sptr":
        r"""make(constellation_bpsk_sptr self) -> constellation_bpsk_sptr"""
        return _digital_swig2.constellation_bpsk_sptr_make(self)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_bpsk_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig2.constellation_bpsk_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_bpsk_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_bpsk_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_bpsk_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig2.constellation_bpsk_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_bpsk_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig2.constellation_bpsk_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_bpsk_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig2.constellation_bpsk_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_bpsk_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig2.constellation_bpsk_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_bpsk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_bpsk_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_bpsk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_bpsk_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_bpsk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_bpsk_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_bpsk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_bpsk_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_bpsk_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig2.constellation_bpsk_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_bpsk_sptr self) -> bool"""
        return _digital_swig2.constellation_bpsk_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_bpsk_sptr self, bool a)"""
        return _digital_swig2.constellation_bpsk_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_bpsk_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.constellation_bpsk_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_bpsk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_bpsk_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_bpsk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_bpsk_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_bpsk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_bpsk_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_bpsk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_bpsk_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_bpsk_sptr self) -> constellation_sptr"""
        return _digital_swig2.constellation_bpsk_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_bpsk_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.constellation_bpsk_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_bpsk_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig2.constellation_bpsk_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_bpsk_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig2.constellation_bpsk_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_bpsk_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig2.constellation_bpsk_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_bpsk_sptr self) -> bool"""
        return _digital_swig2.constellation_bpsk_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_bpsk_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.constellation_bpsk_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_bpsk_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig2.constellation_bpsk_sptr_soft_decision_maker(self, sample)

# Register constellation_bpsk_sptr in _digital_swig2:
_digital_swig2.constellation_bpsk_sptr_swigregister(constellation_bpsk_sptr)


constellation_bpsk_sptr.__repr__ = lambda self: "<constellation BPSK>"
constellation_bpsk = constellation_bpsk.make;

class constellation_qpsk_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_qpsk > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(constellation_qpsk_sptr self) -> constellation_qpsk_sptr
        __init__(constellation_qpsk_sptr self, constellation_qpsk p) -> constellation_qpsk_sptr
        """
        _digital_swig2.constellation_qpsk_sptr_swiginit(self, _digital_swig2.new_constellation_qpsk_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_qpsk *":
        r"""__deref__(constellation_qpsk_sptr self) -> constellation_qpsk"""
        return _digital_swig2.constellation_qpsk_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_constellation_qpsk_sptr

    def make(self) -> "gr::digital::constellation_qpsk::sptr":
        r"""make(constellation_qpsk_sptr self) -> constellation_qpsk_sptr"""
        return _digital_swig2.constellation_qpsk_sptr_make(self)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_qpsk_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig2.constellation_qpsk_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_qpsk_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_qpsk_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_qpsk_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig2.constellation_qpsk_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_qpsk_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig2.constellation_qpsk_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_qpsk_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig2.constellation_qpsk_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_qpsk_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig2.constellation_qpsk_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_qpsk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_qpsk_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_qpsk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_qpsk_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_qpsk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_qpsk_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_qpsk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_qpsk_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_qpsk_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig2.constellation_qpsk_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_qpsk_sptr self) -> bool"""
        return _digital_swig2.constellation_qpsk_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_qpsk_sptr self, bool a)"""
        return _digital_swig2.constellation_qpsk_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_qpsk_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.constellation_qpsk_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_qpsk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_qpsk_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_qpsk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_qpsk_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_qpsk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_qpsk_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_qpsk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_qpsk_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_qpsk_sptr self) -> constellation_sptr"""
        return _digital_swig2.constellation_qpsk_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_qpsk_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.constellation_qpsk_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_qpsk_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig2.constellation_qpsk_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_qpsk_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig2.constellation_qpsk_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_qpsk_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig2.constellation_qpsk_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_qpsk_sptr self) -> bool"""
        return _digital_swig2.constellation_qpsk_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_qpsk_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.constellation_qpsk_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_qpsk_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig2.constellation_qpsk_sptr_soft_decision_maker(self, sample)

# Register constellation_qpsk_sptr in _digital_swig2:
_digital_swig2.constellation_qpsk_sptr_swigregister(constellation_qpsk_sptr)


constellation_qpsk_sptr.__repr__ = lambda self: "<constellation QPSK>"
constellation_qpsk = constellation_qpsk.make;

class constellation_dqpsk_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_dqpsk > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(constellation_dqpsk_sptr self) -> constellation_dqpsk_sptr
        __init__(constellation_dqpsk_sptr self, constellation_dqpsk p) -> constellation_dqpsk_sptr
        """
        _digital_swig2.constellation_dqpsk_sptr_swiginit(self, _digital_swig2.new_constellation_dqpsk_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_dqpsk *":
        r"""__deref__(constellation_dqpsk_sptr self) -> constellation_dqpsk"""
        return _digital_swig2.constellation_dqpsk_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_constellation_dqpsk_sptr

    def make(self) -> "gr::digital::constellation_dqpsk::sptr":
        r"""make(constellation_dqpsk_sptr self) -> constellation_dqpsk_sptr"""
        return _digital_swig2.constellation_dqpsk_sptr_make(self)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_dqpsk_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig2.constellation_dqpsk_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_dqpsk_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_dqpsk_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_dqpsk_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig2.constellation_dqpsk_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_dqpsk_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig2.constellation_dqpsk_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_dqpsk_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig2.constellation_dqpsk_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_dqpsk_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig2.constellation_dqpsk_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_dqpsk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_dqpsk_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_dqpsk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_dqpsk_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_dqpsk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_dqpsk_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_dqpsk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_dqpsk_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_dqpsk_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig2.constellation_dqpsk_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_dqpsk_sptr self) -> bool"""
        return _digital_swig2.constellation_dqpsk_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_dqpsk_sptr self, bool a)"""
        return _digital_swig2.constellation_dqpsk_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_dqpsk_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.constellation_dqpsk_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_dqpsk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_dqpsk_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_dqpsk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_dqpsk_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_dqpsk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_dqpsk_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_dqpsk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_dqpsk_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_dqpsk_sptr self) -> constellation_sptr"""
        return _digital_swig2.constellation_dqpsk_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_dqpsk_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.constellation_dqpsk_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_dqpsk_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig2.constellation_dqpsk_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_dqpsk_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig2.constellation_dqpsk_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_dqpsk_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig2.constellation_dqpsk_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_dqpsk_sptr self) -> bool"""
        return _digital_swig2.constellation_dqpsk_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_dqpsk_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.constellation_dqpsk_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_dqpsk_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig2.constellation_dqpsk_sptr_soft_decision_maker(self, sample)

# Register constellation_dqpsk_sptr in _digital_swig2:
_digital_swig2.constellation_dqpsk_sptr_swigregister(constellation_dqpsk_sptr)


constellation_dqpsk_sptr.__repr__ = lambda self: "<constellation DQPSK>"
constellation_dqpsk = constellation_dqpsk.make;

class constellation_8psk_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_8psk > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(constellation_8psk_sptr self) -> constellation_8psk_sptr
        __init__(constellation_8psk_sptr self, constellation_8psk p) -> constellation_8psk_sptr
        """
        _digital_swig2.constellation_8psk_sptr_swiginit(self, _digital_swig2.new_constellation_8psk_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_8psk *":
        r"""__deref__(constellation_8psk_sptr self) -> constellation_8psk"""
        return _digital_swig2.constellation_8psk_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_constellation_8psk_sptr

    def make(self) -> "gr::digital::constellation_8psk::sptr":
        r"""make(constellation_8psk_sptr self) -> constellation_8psk_sptr"""
        return _digital_swig2.constellation_8psk_sptr_make(self)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_8psk_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig2.constellation_8psk_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_8psk_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_8psk_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_8psk_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig2.constellation_8psk_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_8psk_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig2.constellation_8psk_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_8psk_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig2.constellation_8psk_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_8psk_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig2.constellation_8psk_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_8psk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_8psk_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_8psk_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_8psk_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_8psk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_8psk_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_8psk_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_8psk_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_8psk_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig2.constellation_8psk_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_8psk_sptr self) -> bool"""
        return _digital_swig2.constellation_8psk_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_8psk_sptr self, bool a)"""
        return _digital_swig2.constellation_8psk_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_8psk_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.constellation_8psk_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_8psk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_8psk_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_8psk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_8psk_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_8psk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_8psk_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_8psk_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_8psk_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_8psk_sptr self) -> constellation_sptr"""
        return _digital_swig2.constellation_8psk_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_8psk_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.constellation_8psk_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_8psk_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig2.constellation_8psk_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_8psk_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig2.constellation_8psk_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_8psk_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig2.constellation_8psk_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_8psk_sptr self) -> bool"""
        return _digital_swig2.constellation_8psk_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_8psk_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.constellation_8psk_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_8psk_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig2.constellation_8psk_sptr_soft_decision_maker(self, sample)

# Register constellation_8psk_sptr in _digital_swig2:
_digital_swig2.constellation_8psk_sptr_swigregister(constellation_8psk_sptr)


constellation_8psk_sptr.__repr__ = lambda self: "<constellation 8PSK>"
constellation_8psk = constellation_8psk.make;

class constellation_8psk_natural_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_8psk_natural > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(constellation_8psk_natural_sptr self) -> constellation_8psk_natural_sptr
        __init__(constellation_8psk_natural_sptr self, constellation_8psk_natural p) -> constellation_8psk_natural_sptr
        """
        _digital_swig2.constellation_8psk_natural_sptr_swiginit(self, _digital_swig2.new_constellation_8psk_natural_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_8psk_natural *":
        r"""__deref__(constellation_8psk_natural_sptr self) -> constellation_8psk_natural"""
        return _digital_swig2.constellation_8psk_natural_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_constellation_8psk_natural_sptr

    def make(self) -> "gr::digital::constellation_8psk_natural::sptr":
        r"""make(constellation_8psk_natural_sptr self) -> constellation_8psk_natural_sptr"""
        return _digital_swig2.constellation_8psk_natural_sptr_make(self)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_8psk_natural_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig2.constellation_8psk_natural_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_8psk_natural_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_8psk_natural_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_8psk_natural_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig2.constellation_8psk_natural_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_8psk_natural_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig2.constellation_8psk_natural_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_8psk_natural_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig2.constellation_8psk_natural_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_8psk_natural_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig2.constellation_8psk_natural_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_8psk_natural_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_8psk_natural_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_8psk_natural_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_8psk_natural_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_8psk_natural_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_8psk_natural_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_8psk_natural_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_8psk_natural_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_8psk_natural_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig2.constellation_8psk_natural_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_8psk_natural_sptr self) -> bool"""
        return _digital_swig2.constellation_8psk_natural_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_8psk_natural_sptr self, bool a)"""
        return _digital_swig2.constellation_8psk_natural_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_8psk_natural_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.constellation_8psk_natural_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_8psk_natural_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_8psk_natural_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_8psk_natural_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_8psk_natural_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_8psk_natural_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_8psk_natural_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_8psk_natural_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_8psk_natural_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_8psk_natural_sptr self) -> constellation_sptr"""
        return _digital_swig2.constellation_8psk_natural_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_8psk_natural_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.constellation_8psk_natural_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_8psk_natural_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig2.constellation_8psk_natural_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_8psk_natural_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig2.constellation_8psk_natural_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_8psk_natural_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig2.constellation_8psk_natural_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_8psk_natural_sptr self) -> bool"""
        return _digital_swig2.constellation_8psk_natural_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_8psk_natural_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.constellation_8psk_natural_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_8psk_natural_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig2.constellation_8psk_natural_sptr_soft_decision_maker(self, sample)

# Register constellation_8psk_natural_sptr in _digital_swig2:
_digital_swig2.constellation_8psk_natural_sptr_swigregister(constellation_8psk_natural_sptr)


constellation_8psk_natural_sptr.__repr__ = lambda self: "<constellation 8PSK_natural>"
constellation_8psk_natural = constellation_8psk_natural.make;

class constellation_16qam_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::digital::constellation_16qam > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(constellation_16qam_sptr self) -> constellation_16qam_sptr
        __init__(constellation_16qam_sptr self, constellation_16qam p) -> constellation_16qam_sptr
        """
        _digital_swig2.constellation_16qam_sptr_swiginit(self, _digital_swig2.new_constellation_16qam_sptr(*args))

    def __deref__(self) -> "gr::digital::constellation_16qam *":
        r"""__deref__(constellation_16qam_sptr self) -> constellation_16qam"""
        return _digital_swig2.constellation_16qam_sptr___deref__(self)
    __swig_destroy__ = _digital_swig2.delete_constellation_16qam_sptr

    def make(self) -> "gr::digital::constellation_16qam::sptr":
        r"""make(constellation_16qam_sptr self) -> constellation_16qam_sptr"""
        return _digital_swig2.constellation_16qam_sptr_make(self)

    def map_to_points(self, value: "unsigned int", points: "gr_complex *") -> "void":
        r"""map_to_points(constellation_16qam_sptr self, unsigned int value, gr_complex * points)"""
        return _digital_swig2.constellation_16qam_sptr_map_to_points(self, value, points)

    def map_to_points_v(self, value: "unsigned int") -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""map_to_points_v(constellation_16qam_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_16qam_sptr_map_to_points_v(self, value)

    def decision_maker(self, sample: "gr_complex const *") -> "unsigned int":
        r"""decision_maker(constellation_16qam_sptr self, gr_complex const * sample) -> unsigned int"""
        return _digital_swig2.constellation_16qam_sptr_decision_maker(self, sample)

    def decision_maker_v(self, sample: "pmt_vector_cfloat") -> "unsigned int":
        r"""decision_maker_v(constellation_16qam_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _digital_swig2.constellation_16qam_sptr_decision_maker_v(self, sample)

    def decision_maker_pe(self, sample: "gr_complex const *", phase_error: "float *") -> "unsigned int":
        r"""decision_maker_pe(constellation_16qam_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _digital_swig2.constellation_16qam_sptr_decision_maker_pe(self, sample, phase_error)

    def calc_metric(self, sample: "gr_complex const *", metric: "float *", type: "gr::digital::trellis_metric_type_t") -> "void":
        r"""calc_metric(constellation_16qam_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _digital_swig2.constellation_16qam_sptr_calc_metric(self, sample, metric, type)

    def calc_euclidean_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_euclidean_metric(constellation_16qam_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_16qam_sptr_calc_euclidean_metric(self, sample, metric)

    def calc_hard_symbol_metric(self, sample: "gr_complex const *", metric: "float *") -> "void":
        r"""calc_hard_symbol_metric(constellation_16qam_sptr self, gr_complex const * sample, float * metric)"""
        return _digital_swig2.constellation_16qam_sptr_calc_hard_symbol_metric(self, sample, metric)

    def points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""points(constellation_16qam_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_16qam_sptr_points(self)

    def s_points(self) -> "std::vector< gr_complex,std::allocator< gr_complex > >":
        r"""s_points(constellation_16qam_sptr self) -> pmt_vector_cfloat"""
        return _digital_swig2.constellation_16qam_sptr_s_points(self)

    def v_points(self) -> "std::vector< std::vector< gr_complex,std::allocator< gr_complex > >,std::allocator< std::vector< gr_complex,std::allocator< gr_complex > > > >":
        r"""v_points(constellation_16qam_sptr self) -> gr_vector_vector_complexf"""
        return _digital_swig2.constellation_16qam_sptr_v_points(self)

    def apply_pre_diff_code(self) -> "bool":
        r"""apply_pre_diff_code(constellation_16qam_sptr self) -> bool"""
        return _digital_swig2.constellation_16qam_sptr_apply_pre_diff_code(self)

    def set_pre_diff_code(self, a: "bool") -> "void":
        r"""set_pre_diff_code(constellation_16qam_sptr self, bool a)"""
        return _digital_swig2.constellation_16qam_sptr_set_pre_diff_code(self, a)

    def pre_diff_code(self) -> "std::vector< int,std::allocator< int > >":
        r"""pre_diff_code(constellation_16qam_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.constellation_16qam_sptr_pre_diff_code(self)

    def rotational_symmetry(self) -> "unsigned int":
        r"""rotational_symmetry(constellation_16qam_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_16qam_sptr_rotational_symmetry(self)

    def dimensionality(self) -> "unsigned int":
        r"""dimensionality(constellation_16qam_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_16qam_sptr_dimensionality(self)

    def bits_per_symbol(self) -> "unsigned int":
        r"""bits_per_symbol(constellation_16qam_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_16qam_sptr_bits_per_symbol(self)

    def arity(self) -> "unsigned int":
        r"""arity(constellation_16qam_sptr self) -> unsigned int"""
        return _digital_swig2.constellation_16qam_sptr_arity(self)

    def base(self) -> "gr::digital::constellation_sptr":
        r"""base(constellation_16qam_sptr self) -> constellation_sptr"""
        return _digital_swig2.constellation_16qam_sptr_base(self)

    def as_pmt(self) -> "pmt::pmt_t":
        r"""as_pmt(constellation_16qam_sptr self) -> swig_pmt_ptr"""
        return _digital_swig2.constellation_16qam_sptr_as_pmt(self)

    def gen_soft_dec_lut(self, precision: "int", npwr: "float"=1.0) -> "void":
        r"""gen_soft_dec_lut(constellation_16qam_sptr self, int precision, float npwr=1.0)"""
        return _digital_swig2.constellation_16qam_sptr_gen_soft_dec_lut(self, precision, npwr)

    def calc_soft_dec(self, sample: "gr_complex", npwr: "float"=1.0) -> "std::vector< float,std::allocator< float > >":
        r"""calc_soft_dec(constellation_16qam_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _digital_swig2.constellation_16qam_sptr_calc_soft_dec(self, sample, npwr)

    def set_soft_dec_lut(self, soft_dec_lut: "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const &", precision: "int") -> "void":
        r"""set_soft_dec_lut(constellation_16qam_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _digital_swig2.constellation_16qam_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)

    def has_soft_dec_lut(self) -> "bool":
        r"""has_soft_dec_lut(constellation_16qam_sptr self) -> bool"""
        return _digital_swig2.constellation_16qam_sptr_has_soft_dec_lut(self)

    def soft_dec_lut(self) -> "std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >":
        r"""soft_dec_lut(constellation_16qam_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _digital_swig2.constellation_16qam_sptr_soft_dec_lut(self)

    def soft_decision_maker(self, sample: "gr_complex") -> "std::vector< float,std::allocator< float > >":
        r"""soft_decision_maker(constellation_16qam_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _digital_swig2.constellation_16qam_sptr_soft_decision_maker(self, sample)

# Register constellation_16qam_sptr in _digital_swig2:
_digital_swig2.constellation_16qam_sptr_swigregister(constellation_16qam_sptr)


constellation_16qam_sptr.__repr__ = lambda self: "<constellation 16qam>"
constellation_16qam = constellation_16qam.make;



