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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_digital_swig2')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_digital_swig2')
    _digital_swig2 = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_digital_swig2', [dirname(__file__)])
        except ImportError:
            import _digital_swig2
            return _digital_swig2
        try:
            _mod = imp.load_module('_digital_swig2', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _digital_swig2 = swig_import_helper()
    del swig_import_helper
else:
    import _digital_swig2
del _swig_python_version_info

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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


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



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

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

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

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

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

    def __init__(self, *args):
        """
        __init__(gr::blocks::control_loop self) -> control_loop
        __init__(gr::blocks::control_loop self, float loop_bw, float max_freq, float min_freq) -> control_loop
        """
        this = _digital_swig2.new_control_loop(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _digital_swig2.delete_control_loop
    __del__ = lambda self: None

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

control_loop_swigregister = _digital_swig2.control_loop_swigregister
control_loop_swigregister(control_loop)


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

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

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

    def make(M, theta, loop_bw, fmin, fmax, mu, gain_mu, omega, gain_omega, omega_rel):
        """make(unsigned int M, float theta, float loop_bw, float fmin, float fmax, float mu, float gain_mu, float omega, float gain_omega, float omega_rel) -> mpsk_receiver_cc_sptr"""
        return _digital_swig2.mpsk_receiver_cc_make(M, theta, loop_bw, fmin, fmax, mu, gain_mu, omega, gain_omega, omega_rel)

    make = staticmethod(make)

    def modulation_order(self):
        """modulation_order(mpsk_receiver_cc self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_modulation_order(self)


    def theta(self):
        """theta(mpsk_receiver_cc self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_theta(self)


    def mu(self):
        """mu(mpsk_receiver_cc self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_mu(self)


    def omega(self):
        """omega(mpsk_receiver_cc self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_omega(self)


    def gain_mu(self):
        """gain_mu(mpsk_receiver_cc self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_gain_mu(self)


    def gain_omega(self):
        """gain_omega(mpsk_receiver_cc self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_gain_omega(self)


    def gain_omega_rel(self):
        """gain_omega_rel(mpsk_receiver_cc self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_gain_omega_rel(self)


    def set_modulation_order(self, M):
        """set_modulation_order(mpsk_receiver_cc self, unsigned int M)"""
        return _digital_swig2.mpsk_receiver_cc_set_modulation_order(self, M)


    def set_theta(self, theta):
        """set_theta(mpsk_receiver_cc self, float theta)"""
        return _digital_swig2.mpsk_receiver_cc_set_theta(self, theta)


    def set_mu(self, mu):
        """set_mu(mpsk_receiver_cc self, float mu)"""
        return _digital_swig2.mpsk_receiver_cc_set_mu(self, mu)


    def set_omega(self, omega):
        """set_omega(mpsk_receiver_cc self, float omega)"""
        return _digital_swig2.mpsk_receiver_cc_set_omega(self, omega)


    def set_gain_mu(self, gain_mu):
        """set_gain_mu(mpsk_receiver_cc self, float gain_mu)"""
        return _digital_swig2.mpsk_receiver_cc_set_gain_mu(self, gain_mu)


    def set_gain_omega(self, gain_omega):
        """set_gain_omega(mpsk_receiver_cc self, float gain_omega)"""
        return _digital_swig2.mpsk_receiver_cc_set_gain_omega(self, gain_omega)


    def set_gain_omega_rel(self, omega_rel):
        """set_gain_omega_rel(mpsk_receiver_cc self, float omega_rel)"""
        return _digital_swig2.mpsk_receiver_cc_set_gain_omega_rel(self, omega_rel)

    __swig_destroy__ = _digital_swig2.delete_mpsk_receiver_cc
    __del__ = lambda self: None
mpsk_receiver_cc_swigregister = _digital_swig2.mpsk_receiver_cc_swigregister
mpsk_receiver_cc_swigregister(mpsk_receiver_cc)
cvar = _digital_swig2.cvar

def mpsk_receiver_cc_make(M, theta, loop_bw, fmin, fmax, mu, gain_mu, omega, gain_omega, omega_rel):
    """mpsk_receiver_cc_make(unsigned int M, float theta, float loop_bw, float fmin, float fmax, float mu, float gain_mu, float omega, float gain_omega, float omega_rel) -> mpsk_receiver_cc_sptr"""
    return _digital_swig2.mpsk_receiver_cc_make(M, theta, loop_bw, fmin, fmax, mu, gain_mu, omega, gain_omega, omega_rel)

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):
    """Proxy of C++ gr::digital::mpsk_snr_est class."""

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

    def __init__(self, alpha):
        """__init__(gr::digital::mpsk_snr_est self, double alpha) -> mpsk_snr_est"""
        this = _digital_swig2.new_mpsk_snr_est(alpha)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _digital_swig2.delete_mpsk_snr_est
    __del__ = lambda self: None

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


    def set_alpha(self, alpha):
        """set_alpha(mpsk_snr_est self, double alpha)"""
        return _digital_swig2.mpsk_snr_est_set_alpha(self, alpha)


    def update(self, noutput_items, input):
        """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):
        """snr(mpsk_snr_est self) -> double"""
        return _digital_swig2.mpsk_snr_est_snr(self)


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


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

mpsk_snr_est_swigregister = _digital_swig2.mpsk_snr_est_swigregister
mpsk_snr_est_swigregister(mpsk_snr_est)

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

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

    def __init__(self, alpha):
        """__init__(gr::digital::mpsk_snr_est_simple self, double alpha) -> mpsk_snr_est_simple"""
        this = _digital_swig2.new_mpsk_snr_est_simple(alpha)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _digital_swig2.delete_mpsk_snr_est_simple
    __del__ = lambda self: None
mpsk_snr_est_simple_swigregister = _digital_swig2.mpsk_snr_est_simple_swigregister
mpsk_snr_est_simple_swigregister(mpsk_snr_est_simple)

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

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

    def __init__(self, alpha):
        """__init__(gr::digital::mpsk_snr_est_skew self, double alpha) -> mpsk_snr_est_skew"""
        this = _digital_swig2.new_mpsk_snr_est_skew(alpha)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _digital_swig2.delete_mpsk_snr_est_skew
    __del__ = lambda self: None
mpsk_snr_est_skew_swigregister = _digital_swig2.mpsk_snr_est_skew_swigregister
mpsk_snr_est_skew_swigregister(mpsk_snr_est_skew)

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

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

    def __init__(self, alpha):
        """__init__(gr::digital::mpsk_snr_est_m2m4 self, double alpha) -> mpsk_snr_est_m2m4"""
        this = _digital_swig2.new_mpsk_snr_est_m2m4(alpha)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _digital_swig2.delete_mpsk_snr_est_m2m4
    __del__ = lambda self: None
mpsk_snr_est_m2m4_swigregister = _digital_swig2.mpsk_snr_est_m2m4_swigregister
mpsk_snr_est_m2m4_swigregister(mpsk_snr_est_m2m4)

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

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

    def __init__(self, alpha, ka, kw):
        """__init__(gr::digital::snr_est_m2m4 self, double alpha, double ka, double kw) -> snr_est_m2m4"""
        this = _digital_swig2.new_snr_est_m2m4(alpha, ka, kw)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _digital_swig2.delete_snr_est_m2m4
    __del__ = lambda self: None
snr_est_m2m4_swigregister = _digital_swig2.snr_est_m2m4_swigregister
snr_est_m2m4_swigregister(snr_est_m2m4)

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

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

    def __init__(self, alpha):
        """__init__(gr::digital::mpsk_snr_est_svr self, double alpha) -> mpsk_snr_est_svr"""
        this = _digital_swig2.new_mpsk_snr_est_svr(alpha)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _digital_swig2.delete_mpsk_snr_est_svr
    __del__ = lambda self: None
mpsk_snr_est_svr_swigregister = _digital_swig2.mpsk_snr_est_svr_swigregister
mpsk_snr_est_svr_swigregister(mpsk_snr_est_svr)

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

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

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

    def make(type, tag_nsamples=10000, alpha=0.001):
        """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)

    make = staticmethod(make)

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


    def type(self):
        """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):
        """tag_nsample(mpsk_snr_est_cc self) -> int"""
        return _digital_swig2.mpsk_snr_est_cc_tag_nsample(self)


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


    def set_type(self, t):
        """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):
        """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):
        """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
    __del__ = lambda self: None
mpsk_snr_est_cc_swigregister = _digital_swig2.mpsk_snr_est_cc_swigregister
mpsk_snr_est_cc_swigregister(mpsk_snr_est_cc)

def mpsk_snr_est_cc_make(type, tag_nsamples=10000, alpha=0.001):
    """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):
    """Proxy of C++ gr::digital::header_format_base class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _digital_swig2.delete_header_format_base
    __del__ = lambda self: None

    def base(self):
        """base(header_format_base self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_base_base(self)


    def formatter(self):
        """formatter(header_format_base self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_base_formatter(self)


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


    def parse(self, nbits_in, input, info, nbits_processed):
        """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):
        """header_nbits(header_format_base self) -> size_t"""
        return _digital_swig2.header_format_base_header_nbits(self)


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

header_format_base_swigregister = _digital_swig2.header_format_base_swigregister
header_format_base_swigregister(header_format_base)

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

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

    def __init__(self, access_code, threshold):
        """__init__(gr::digital::header_format_default self, std::string const & access_code, int threshold) -> header_format_default"""
        this = _digital_swig2.new_header_format_default(access_code, threshold)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _digital_swig2.delete_header_format_default
    __del__ = lambda self: None

    def set_access_code(self, access_code):
        """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):
        """access_code(header_format_default self) -> unsigned long long"""
        return _digital_swig2.header_format_default_access_code(self)


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


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


    def make(access_code, threshold):
        """make(std::string const & access_code, int threshold) -> header_format_base_sptr"""
        return _digital_swig2.header_format_default_make(access_code, threshold)

    make = staticmethod(make)
header_format_default_swigregister = _digital_swig2.header_format_default_swigregister
header_format_default_swigregister(header_format_default)

def header_format_default_make(access_code, threshold):
    """header_format_default_make(std::string const & access_code, int threshold) -> header_format_base_sptr"""
    return _digital_swig2.header_format_default_make(access_code, threshold)

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

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

    def __init__(self, access_code, threshold, bps):
        """__init__(gr::digital::header_format_counter self, std::string const & access_code, int threshold, int bps) -> header_format_counter"""
        this = _digital_swig2.new_header_format_counter(access_code, threshold, bps)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _digital_swig2.delete_header_format_counter
    __del__ = lambda self: None

    def make(access_code, threshold, bps):
        """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)

    make = staticmethod(make)
header_format_counter_swigregister = _digital_swig2.header_format_counter_swigregister
header_format_counter_swigregister(header_format_counter)

def header_format_counter_make(access_code, threshold, bps):
    """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):
    """Proxy of C++ gr::digital::header_format_crc class."""

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

    def __init__(self, *args, **kwargs):
        """__init__(gr::digital::header_format_crc self, std::string const & len_key_name, std::string const & num_key_name) -> header_format_crc"""
        this = _digital_swig2.new_header_format_crc(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _digital_swig2.delete_header_format_crc
    __del__ = lambda self: None

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


    def make(*args, **kwargs):
        """make(std::string const & len_key_name, std::string const & num_key_name) -> header_format_base_sptr"""
        return _digital_swig2.header_format_crc_make(*args, **kwargs)

    make = staticmethod(make)
header_format_crc_swigregister = _digital_swig2.header_format_crc_swigregister
header_format_crc_swigregister(header_format_crc)

def header_format_crc_make(*args, **kwargs):
    """header_format_crc_make(std::string const & len_key_name, std::string const & num_key_name) -> header_format_base_sptr"""
    return _digital_swig2.header_format_crc_make(*args, **kwargs)

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

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

    def __init__(self, *args, **kwargs):
        """__init__(gr::digital::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, std::string const & frame_key_name, std::string const & num_key_name, int bits_per_header_sym=1, int bits_per_payload_sym=1, bool scramble_header=False) -> header_format_ofdm"""
        this = _digital_swig2.new_header_format_ofdm(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _digital_swig2.delete_header_format_ofdm
    __del__ = lambda self: None

    def make(*args, **kwargs):
        """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, std::string const & frame_key_name, std::string const & num_key_name, 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)

    make = staticmethod(make)
header_format_ofdm_swigregister = _digital_swig2.header_format_ofdm_swigregister
header_format_ofdm_swigregister(header_format_ofdm)

def header_format_ofdm_make(*args, **kwargs):
    """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, std::string const & frame_key_name, std::string const & num_key_name, 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):
    """Proxy of C++ gr::digital::protocol_formatter_async class."""

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

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

    def make(format):
        """make(header_format_base_sptr format) -> protocol_formatter_async_sptr"""
        return _digital_swig2.protocol_formatter_async_make(format)

    make = staticmethod(make)
    __swig_destroy__ = _digital_swig2.delete_protocol_formatter_async
    __del__ = lambda self: None
protocol_formatter_async_swigregister = _digital_swig2.protocol_formatter_async_swigregister
protocol_formatter_async_swigregister(protocol_formatter_async)

def protocol_formatter_async_make(format):
    """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):
    """Proxy of C++ gr::digital::protocol_formatter_bb class."""

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

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

    def make(*args, **kwargs):
        """make(header_format_base_sptr format, std::string const & len_tag_key) -> protocol_formatter_bb_sptr"""
        return _digital_swig2.protocol_formatter_bb_make(*args, **kwargs)

    make = staticmethod(make)

    def set_header_format(self, format):
        """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
    __del__ = lambda self: None
protocol_formatter_bb_swigregister = _digital_swig2.protocol_formatter_bb_swigregister
protocol_formatter_bb_swigregister(protocol_formatter_bb)

def protocol_formatter_bb_make(*args, **kwargs):
    """protocol_formatter_bb_make(header_format_base_sptr format, std::string const & len_tag_key) -> protocol_formatter_bb_sptr"""
    return _digital_swig2.protocol_formatter_bb_make(*args, **kwargs)

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

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

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

    def make(format):
        """make(header_format_base_sptr format) -> protocol_parser_b_sptr"""
        return _digital_swig2.protocol_parser_b_make(format)

    make = staticmethod(make)
    __swig_destroy__ = _digital_swig2.delete_protocol_parser_b
    __del__ = lambda self: None
protocol_parser_b_swigregister = _digital_swig2.protocol_parser_b_swigregister
protocol_parser_b_swigregister(protocol_parser_b)

def protocol_parser_b_make(format):
    """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):
    """Proxy of C++ gr::digital::packet_header_default class."""

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

    def __init__(self, *args, **kwargs):
        """__init__(gr::digital::packet_header_default self, long header_len, std::string const & len_tag_key, std::string const & num_tag_key, int bits_per_byte=1) -> packet_header_default"""
        this = _digital_swig2.new_packet_header_default(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _digital_swig2.delete_packet_header_default
    __del__ = lambda self: None

    def base(self):
        """base(packet_header_default self) -> packet_header_default_sptr"""
        return _digital_swig2.packet_header_default_base(self)


    def formatter(self):
        """formatter(packet_header_default self) -> packet_header_default_sptr"""
        return _digital_swig2.packet_header_default_formatter(self)


    def set_header_num(self, header_num):
        """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):
        """header_len(packet_header_default self) -> long"""
        return _digital_swig2.packet_header_default_header_len(self)


    def len_tag_key(self):
        """len_tag_key(packet_header_default self) -> swig_int_ptr"""
        return _digital_swig2.packet_header_default_len_tag_key(self)


    def header_formatter(self, *args, **kwargs):
        """header_formatter(packet_header_default self, long packet_len, unsigned char * out, tags_vector_t tags) -> bool"""
        return _digital_swig2.packet_header_default_header_formatter(self, *args, **kwargs)


    def header_parser(self, header, tags):
        """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)


    def make(*args, **kwargs):
        """make(long header_len, std::string const & len_tag_key, std::string const & num_tag_key, int bits_per_byte=1) -> packet_header_default_sptr"""
        return _digital_swig2.packet_header_default_make(*args, **kwargs)

    make = staticmethod(make)
packet_header_default_swigregister = _digital_swig2.packet_header_default_swigregister
packet_header_default_swigregister(packet_header_default)

def packet_header_default_make(*args, **kwargs):
    """packet_header_default_make(long header_len, std::string const & len_tag_key, std::string const & num_tag_key, 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):
    """Proxy of C++ gr::digital::packet_header_ofdm class."""

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

    def __init__(self, occupied_carriers, n_syms, len_tag_key, frame_len_tag_key, num_tag_key, bits_per_header_sym, bits_per_payload_sym, scramble_header):
        """__init__(gr::digital::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"""
        this = _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)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _digital_swig2.delete_packet_header_ofdm
    __del__ = lambda self: None

    def make(*args, **kwargs):
        """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, std::string const & frame_len_tag_key, std::string const & num_tag_key, 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)

    make = staticmethod(make)
packet_header_ofdm_swigregister = _digital_swig2.packet_header_ofdm_swigregister
packet_header_ofdm_swigregister(packet_header_ofdm)

def packet_header_ofdm_make(*args, **kwargs):
    """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, std::string const & frame_len_tag_key, std::string const & num_tag_key, 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):
    """Proxy of C++ gr::digital::packet_headergenerator_bb class."""

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

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

    def make(*args):
        """
        make(packet_header_default_sptr header_formatter, std::string const & len_tag_key) -> packet_headergenerator_bb_sptr
        make(long header_len, std::string const & len_tag_key) -> packet_headergenerator_bb_sptr
        """
        return _digital_swig2.packet_headergenerator_bb_make(*args)

    make = staticmethod(make)

    def set_header_formatter(self, header_formatter):
        """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
    __del__ = lambda self: None
packet_headergenerator_bb_swigregister = _digital_swig2.packet_headergenerator_bb_swigregister
packet_headergenerator_bb_swigregister(packet_headergenerator_bb)

def packet_headergenerator_bb_make(*args):
    """
    make(packet_header_default_sptr header_formatter, std::string const & len_tag_key) -> packet_headergenerator_bb_sptr
    packet_headergenerator_bb_make(long header_len, std::string const & len_tag_key) -> packet_headergenerator_bb_sptr
    """
    return _digital_swig2.packet_headergenerator_bb_make(*args)

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

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

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

    def make(*args):
        """
        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)

    make = staticmethod(make)
    __swig_destroy__ = _digital_swig2.delete_packet_headerparser_b
    __del__ = lambda self: None
packet_headerparser_b_swigregister = _digital_swig2.packet_headerparser_b_swigregister
packet_headerparser_b_swigregister(packet_headerparser_b)

def packet_headerparser_b_make(*args):
    """
    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):
    """Proxy of C++ gr::digital::packet_sink class."""

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

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

    def make(sync_vector, target_queue, threshold=-1):
        """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)

    make = staticmethod(make)

    def carrier_sensed(self):
        """carrier_sensed(packet_sink self) -> bool"""
        return _digital_swig2.packet_sink_carrier_sensed(self)

    __swig_destroy__ = _digital_swig2.delete_packet_sink
    __del__ = lambda self: None
packet_sink_swigregister = _digital_swig2.packet_sink_swigregister
packet_sink_swigregister(packet_sink)

def packet_sink_make(sync_vector, target_queue, threshold=-1):
    """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):
    """Proxy of C++ gr::digital::pfb_clock_sync_ccf class."""

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

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

    def make(sps, loop_bw, taps, filter_size=32, init_phase=0, max_rate_deviation=1.5, osps=1):
        """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)

    make = staticmethod(make)

    def update_gains(self):
        """update_gains(pfb_clock_sync_ccf self)"""
        return _digital_swig2.pfb_clock_sync_ccf_update_gains(self)


    def update_taps(self, taps):
        """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, ourtaps, ourfilter):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """loop_bandwidth(pfb_clock_sync_ccf self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_loop_bandwidth(self)


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


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


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


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


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


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


    def phase(self):
        """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
    __del__ = lambda self: None
pfb_clock_sync_ccf_swigregister = _digital_swig2.pfb_clock_sync_ccf_swigregister
pfb_clock_sync_ccf_swigregister(pfb_clock_sync_ccf)

def pfb_clock_sync_ccf_make(sps, loop_bw, taps, filter_size=32, init_phase=0, max_rate_deviation=1.5, osps=1):
    """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):
    """Proxy of C++ gr::digital::pfb_clock_sync_fff class."""

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

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

    def make(sps, gain, taps, filter_size=32, init_phase=0, max_rate_deviation=1.5, osps=1):
        """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)

    make = staticmethod(make)

    def update_gains(self):
        """update_gains(pfb_clock_sync_fff self)"""
        return _digital_swig2.pfb_clock_sync_fff_update_gains(self)


    def update_taps(self, taps):
        """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, ourtaps, ourfilter):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """loop_bandwidth(pfb_clock_sync_fff self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_loop_bandwidth(self)


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


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


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


    def clock_rate(self):
        """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
    __del__ = lambda self: None
pfb_clock_sync_fff_swigregister = _digital_swig2.pfb_clock_sync_fff_swigregister
pfb_clock_sync_fff_swigregister(pfb_clock_sync_fff)

def pfb_clock_sync_fff_make(sps, gain, taps, filter_size=32, init_phase=0, max_rate_deviation=1.5, osps=1):
    """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):
    """Proxy of C++ gr::digital::pn_correlator_cc class."""

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

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

    def make(degree, mask=0, seed=1):
        """make(int degree, int mask=0, int seed=1) -> pn_correlator_cc_sptr"""
        return _digital_swig2.pn_correlator_cc_make(degree, mask, seed)

    make = staticmethod(make)
    __swig_destroy__ = _digital_swig2.delete_pn_correlator_cc
    __del__ = lambda self: None
pn_correlator_cc_swigregister = _digital_swig2.pn_correlator_cc_swigregister
pn_correlator_cc_swigregister(pn_correlator_cc)

def pn_correlator_cc_make(degree, mask=0, seed=1):
    """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):
    """Proxy of C++ gr::digital::probe_density_b class."""

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

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

    def make(alpha):
        """make(double alpha) -> probe_density_b_sptr"""
        return _digital_swig2.probe_density_b_make(alpha)

    make = staticmethod(make)

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


    def set_alpha(self, alpha):
        """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
    __del__ = lambda self: None
probe_density_b_swigregister = _digital_swig2.probe_density_b_swigregister
probe_density_b_swigregister(probe_density_b)

def probe_density_b_make(alpha):
    """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):
    """Proxy of C++ gr::digital::probe_mpsk_snr_est_c class."""

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

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

    def make(type, msg_nsamples=10000, alpha=0.001):
        """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)

    make = staticmethod(make)

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


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


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


    def type(self):
        """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):
        """msg_nsample(probe_mpsk_snr_est_c self) -> int"""
        return _digital_swig2.probe_mpsk_snr_est_c_msg_nsample(self)


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


    def set_type(self, t):
        """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):
        """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):
        """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
    __del__ = lambda self: None
probe_mpsk_snr_est_c_swigregister = _digital_swig2.probe_mpsk_snr_est_c_swigregister
probe_mpsk_snr_est_c_swigregister(probe_mpsk_snr_est_c)

def probe_mpsk_snr_est_c_make(type, msg_nsamples=10000, alpha=0.001):
    """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):
    """Proxy of C++ gr::digital::scrambler_bb class."""

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

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

    def make(mask, seed, len):
        """make(int mask, int seed, int len) -> scrambler_bb_sptr"""
        return _digital_swig2.scrambler_bb_make(mask, seed, len)

    make = staticmethod(make)
    __swig_destroy__ = _digital_swig2.delete_scrambler_bb
    __del__ = lambda self: None
scrambler_bb_swigregister = _digital_swig2.scrambler_bb_swigregister
scrambler_bb_swigregister(scrambler_bb)

def scrambler_bb_make(mask, seed, len):
    """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):
    """Proxy of C++ gr::digital::simple_correlator class."""

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

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

    def make(payload_bytesize):
        """make(int payload_bytesize) -> simple_correlator_sptr"""
        return _digital_swig2.simple_correlator_make(payload_bytesize)

    make = staticmethod(make)
    __swig_destroy__ = _digital_swig2.delete_simple_correlator
    __del__ = lambda self: None
simple_correlator_swigregister = _digital_swig2.simple_correlator_swigregister
simple_correlator_swigregister(simple_correlator)

def simple_correlator_make(payload_bytesize):
    """simple_correlator_make(int payload_bytesize) -> simple_correlator_sptr"""
    return _digital_swig2.simple_correlator_make(payload_bytesize)

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

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

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

    def make(payload_bytesize):
        """make(int payload_bytesize) -> simple_framer_sptr"""
        return _digital_swig2.simple_framer_make(payload_bytesize)

    make = staticmethod(make)
    __swig_destroy__ = _digital_swig2.delete_simple_framer
    __del__ = lambda self: None
simple_framer_swigregister = _digital_swig2.simple_framer_swigregister
simple_framer_swigregister(simple_framer)

def simple_framer_make(payload_bytesize):
    """simple_framer_make(int payload_bytesize) -> simple_framer_sptr"""
    return _digital_swig2.simple_framer_make(payload_bytesize)

class mpsk_receiver_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::mpsk_receiver_cc)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::mpsk_receiver_cc)> self) -> mpsk_receiver_cc_sptr
        __init__(boost::shared_ptr<(gr::digital::mpsk_receiver_cc)> self, mpsk_receiver_cc p) -> mpsk_receiver_cc_sptr
        """
        this = _digital_swig2.new_mpsk_receiver_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(mpsk_receiver_cc_sptr self) -> mpsk_receiver_cc"""
        return _digital_swig2.mpsk_receiver_cc_sptr___deref__(self)

    __swig_destroy__ = _digital_swig2.delete_mpsk_receiver_cc_sptr
    __del__ = lambda self: None

    def make(self, M, theta, loop_bw, fmin, fmax, mu, gain_mu, omega, gain_omega, omega_rel):
        """make(mpsk_receiver_cc_sptr self, unsigned int M, float theta, float loop_bw, float fmin, float fmax, float mu, float gain_mu, float omega, float gain_omega, float omega_rel) -> mpsk_receiver_cc_sptr"""
        return _digital_swig2.mpsk_receiver_cc_sptr_make(self, M, theta, loop_bw, fmin, fmax, mu, gain_mu, omega, gain_omega, omega_rel)


    def modulation_order(self):
        """modulation_order(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_modulation_order(self)


    def theta(self):
        """theta(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_theta(self)


    def mu(self):
        """mu(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_mu(self)


    def omega(self):
        """omega(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_omega(self)


    def gain_mu(self):
        """gain_mu(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_gain_mu(self)


    def gain_omega(self):
        """gain_omega(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_gain_omega(self)


    def gain_omega_rel(self):
        """gain_omega_rel(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_gain_omega_rel(self)


    def set_modulation_order(self, M):
        """set_modulation_order(mpsk_receiver_cc_sptr self, unsigned int M)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_modulation_order(self, M)


    def set_theta(self, theta):
        """set_theta(mpsk_receiver_cc_sptr self, float theta)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_theta(self, theta)


    def set_mu(self, mu):
        """set_mu(mpsk_receiver_cc_sptr self, float mu)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_mu(self, mu)


    def set_omega(self, omega):
        """set_omega(mpsk_receiver_cc_sptr self, float omega)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_omega(self, omega)


    def set_gain_mu(self, gain_mu):
        """set_gain_mu(mpsk_receiver_cc_sptr self, float gain_mu)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_gain_mu(self, gain_mu)


    def set_gain_omega(self, gain_omega):
        """set_gain_omega(mpsk_receiver_cc_sptr self, float gain_omega)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_gain_omega(self, gain_omega)


    def set_gain_omega_rel(self, omega_rel):
        """set_gain_omega_rel(mpsk_receiver_cc_sptr self, float omega_rel)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_gain_omega_rel(self, omega_rel)


    def history(self):
        """history(mpsk_receiver_cc_sptr self) -> unsigned int"""
        return _digital_swig2.mpsk_receiver_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(mpsk_receiver_cc_sptr self, int which, int delay)
        declare_sample_delay(mpsk_receiver_cc_sptr self, unsigned int delay)
        """
        return _digital_swig2.mpsk_receiver_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(mpsk_receiver_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig2.mpsk_receiver_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(mpsk_receiver_cc_sptr self) -> int"""
        return _digital_swig2.mpsk_receiver_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(mpsk_receiver_cc_sptr self) -> double"""
        return _digital_swig2.mpsk_receiver_cc_sptr_relative_rate(self)


    def start(self):
        """start(mpsk_receiver_cc_sptr self) -> bool"""
        return _digital_swig2.mpsk_receiver_cc_sptr_start(self)


    def stop(self):
        """stop(mpsk_receiver_cc_sptr self) -> bool"""
        return _digital_swig2.mpsk_receiver_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(mpsk_receiver_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _digital_swig2.mpsk_receiver_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(mpsk_receiver_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.mpsk_receiver_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(mpsk_receiver_cc_sptr self) -> int"""
        return _digital_swig2.mpsk_receiver_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(mpsk_receiver_cc_sptr self, int m)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(mpsk_receiver_cc_sptr self)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(mpsk_receiver_cc_sptr self) -> bool"""
        return _digital_swig2.mpsk_receiver_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(mpsk_receiver_cc_sptr self, int m)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(mpsk_receiver_cc_sptr self) -> int"""
        return _digital_swig2.mpsk_receiver_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(mpsk_receiver_cc_sptr self, int i) -> long"""
        return _digital_swig2.mpsk_receiver_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(mpsk_receiver_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(mpsk_receiver_cc_sptr self, int port, long max_output_buffer)
        """
        return _digital_swig2.mpsk_receiver_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(mpsk_receiver_cc_sptr self, int i) -> long"""
        return _digital_swig2.mpsk_receiver_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(mpsk_receiver_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(mpsk_receiver_cc_sptr self, int port, long min_output_buffer)
        """
        return _digital_swig2.mpsk_receiver_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(mpsk_receiver_cc_sptr self, int which) -> float
        pc_input_buffers_full(mpsk_receiver_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.mpsk_receiver_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(mpsk_receiver_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(mpsk_receiver_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.mpsk_receiver_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(mpsk_receiver_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(mpsk_receiver_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.mpsk_receiver_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(mpsk_receiver_cc_sptr self, int which) -> float
        pc_output_buffers_full(mpsk_receiver_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.mpsk_receiver_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(mpsk_receiver_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(mpsk_receiver_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.mpsk_receiver_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(mpsk_receiver_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(mpsk_receiver_cc_sptr self) -> pmt_vector_float
        """
        return _digital_swig2.mpsk_receiver_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(mpsk_receiver_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(mpsk_receiver_cc_sptr self)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(mpsk_receiver_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _digital_swig2.mpsk_receiver_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(mpsk_receiver_cc_sptr self) -> int"""
        return _digital_swig2.mpsk_receiver_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(mpsk_receiver_cc_sptr self) -> int"""
        return _digital_swig2.mpsk_receiver_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(mpsk_receiver_cc_sptr self, int priority) -> int"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(mpsk_receiver_cc_sptr self) -> std::string"""
        return _digital_swig2.mpsk_receiver_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(mpsk_receiver_cc_sptr self) -> std::string"""
        return _digital_swig2.mpsk_receiver_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(mpsk_receiver_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig2.mpsk_receiver_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(mpsk_receiver_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig2.mpsk_receiver_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(mpsk_receiver_cc_sptr self) -> long"""
        return _digital_swig2.mpsk_receiver_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(mpsk_receiver_cc_sptr self) -> basic_block_sptr"""
        return _digital_swig2.mpsk_receiver_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(mpsk_receiver_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _digital_swig2.mpsk_receiver_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(mpsk_receiver_cc_sptr self) -> std::string"""
        return _digital_swig2.mpsk_receiver_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(mpsk_receiver_cc_sptr self, std::string name)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(mpsk_receiver_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig2.mpsk_receiver_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(mpsk_receiver_cc_sptr self) -> swig_int_ptr"""
        return _digital_swig2.mpsk_receiver_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(mpsk_receiver_cc_sptr self) -> swig_int_ptr"""
        return _digital_swig2.mpsk_receiver_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(mpsk_receiver_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig2.mpsk_receiver_cc_sptr_message_subscribers(self, which_port)


    def update_gains(self):
        """update_gains(mpsk_receiver_cc_sptr self)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_update_gains(self)


    def advance_loop(self, error):
        """advance_loop(mpsk_receiver_cc_sptr self, float error)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_advance_loop(self, error)


    def phase_wrap(self):
        """phase_wrap(mpsk_receiver_cc_sptr self)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_phase_wrap(self)


    def frequency_limit(self):
        """frequency_limit(mpsk_receiver_cc_sptr self)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_frequency_limit(self)


    def set_loop_bandwidth(self, bw):
        """set_loop_bandwidth(mpsk_receiver_cc_sptr self, float bw)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_loop_bandwidth(self, bw)


    def set_damping_factor(self, df):
        """set_damping_factor(mpsk_receiver_cc_sptr self, float df)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_damping_factor(self, df)


    def set_alpha(self, alpha):
        """set_alpha(mpsk_receiver_cc_sptr self, float alpha)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_alpha(self, alpha)


    def set_beta(self, beta):
        """set_beta(mpsk_receiver_cc_sptr self, float beta)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_beta(self, beta)


    def set_frequency(self, freq):
        """set_frequency(mpsk_receiver_cc_sptr self, float freq)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_frequency(self, freq)


    def set_phase(self, phase):
        """set_phase(mpsk_receiver_cc_sptr self, float phase)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_phase(self, phase)


    def set_max_freq(self, freq):
        """set_max_freq(mpsk_receiver_cc_sptr self, float freq)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_max_freq(self, freq)


    def set_min_freq(self, freq):
        """set_min_freq(mpsk_receiver_cc_sptr self, float freq)"""
        return _digital_swig2.mpsk_receiver_cc_sptr_set_min_freq(self, freq)


    def get_loop_bandwidth(self):
        """get_loop_bandwidth(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_get_loop_bandwidth(self)


    def get_damping_factor(self):
        """get_damping_factor(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_get_damping_factor(self)


    def get_alpha(self):
        """get_alpha(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_get_alpha(self)


    def get_beta(self):
        """get_beta(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_get_beta(self)


    def get_frequency(self):
        """get_frequency(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_get_frequency(self)


    def get_phase(self):
        """get_phase(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_get_phase(self)


    def get_max_freq(self):
        """get_max_freq(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_get_max_freq(self)


    def get_min_freq(self):
        """get_min_freq(mpsk_receiver_cc_sptr self) -> float"""
        return _digital_swig2.mpsk_receiver_cc_sptr_get_min_freq(self)

mpsk_receiver_cc_sptr_swigregister = _digital_swig2.mpsk_receiver_cc_sptr_swigregister
mpsk_receiver_cc_sptr_swigregister(mpsk_receiver_cc_sptr)


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

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

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::mpsk_snr_est_cc)> self) -> mpsk_snr_est_cc_sptr
        __init__(boost::shared_ptr<(gr::digital::mpsk_snr_est_cc)> self, mpsk_snr_est_cc p) -> mpsk_snr_est_cc_sptr
        """
        this = _digital_swig2.new_mpsk_snr_est_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, type, tag_nsamples=10000, alpha=0.001):
        """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):
        """snr(mpsk_snr_est_cc_sptr self) -> double"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_snr(self)


    def type(self):
        """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):
        """tag_nsample(mpsk_snr_est_cc_sptr self) -> int"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_tag_nsample(self)


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


    def set_type(self, t):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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 output_multiple(self):
        """output_multiple(mpsk_snr_est_cc_sptr self) -> int"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_output_multiple(self)


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


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


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


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """name(mpsk_snr_est_cc_sptr self) -> std::string"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_name(self)


    def symbol_name(self):
        """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):
        """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):
        """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):
        """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):
        """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, noutputs):
        """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):
        """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):
        """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, msg):
        """_post(mpsk_snr_est_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig2.mpsk_snr_est_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(mpsk_snr_est_cc_sptr self) -> swig_int_ptr"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(mpsk_snr_est_cc_sptr self) -> swig_int_ptr"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(mpsk_snr_est_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig2.mpsk_snr_est_cc_sptr_message_subscribers(self, which_port)

mpsk_snr_est_cc_sptr_swigregister = _digital_swig2.mpsk_snr_est_cc_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::protocol_formatter_async)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::protocol_formatter_async)> self) -> protocol_formatter_async_sptr
        __init__(boost::shared_ptr<(gr::digital::protocol_formatter_async)> self, protocol_formatter_async p) -> protocol_formatter_async_sptr
        """
        this = _digital_swig2.new_protocol_formatter_async_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, format):
        """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):
        """history(protocol_formatter_async_sptr self) -> unsigned int"""
        return _digital_swig2.protocol_formatter_async_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(protocol_formatter_async_sptr self, int which) -> unsigned int"""
        return _digital_swig2.protocol_formatter_async_sptr_sample_delay(self, which)


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


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


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


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


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(protocol_formatter_async_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_async_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(protocol_formatter_async_sptr self)"""
        return _digital_swig2.protocol_formatter_async_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(protocol_formatter_async_sptr self) -> int"""
        return _digital_swig2.protocol_formatter_async_sptr_active_thread_priority(self)


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


    def set_thread_priority(self, priority):
        """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):
        """name(protocol_formatter_async_sptr self) -> std::string"""
        return _digital_swig2.protocol_formatter_async_sptr_name(self)


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


    def input_signature(self):
        """input_signature(protocol_formatter_async_sptr self) -> io_signature_sptr"""
        return _digital_swig2.protocol_formatter_async_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(protocol_formatter_async_sptr self) -> io_signature_sptr"""
        return _digital_swig2.protocol_formatter_async_sptr_output_signature(self)


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


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(protocol_formatter_async_sptr self) -> std::string"""
        return _digital_swig2.protocol_formatter_async_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(protocol_formatter_async_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig2.protocol_formatter_async_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(protocol_formatter_async_sptr self) -> swig_int_ptr"""
        return _digital_swig2.protocol_formatter_async_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(protocol_formatter_async_sptr self) -> swig_int_ptr"""
        return _digital_swig2.protocol_formatter_async_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(protocol_formatter_async_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig2.protocol_formatter_async_sptr_message_subscribers(self, which_port)

protocol_formatter_async_sptr_swigregister = _digital_swig2.protocol_formatter_async_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::protocol_formatter_bb)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::protocol_formatter_bb)> self) -> protocol_formatter_bb_sptr
        __init__(boost::shared_ptr<(gr::digital::protocol_formatter_bb)> self, protocol_formatter_bb p) -> protocol_formatter_bb_sptr
        """
        this = _digital_swig2.new_protocol_formatter_bb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(protocol_formatter_bb_sptr self, header_format_base_sptr format, std::string const & len_tag_key) -> protocol_formatter_bb_sptr"""
        return _digital_swig2.protocol_formatter_bb_sptr_make(self, *args, **kwargs)


    def set_header_format(self, format):
        """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):
        """history(protocol_formatter_bb_sptr self) -> unsigned int"""
        return _digital_swig2.protocol_formatter_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(protocol_formatter_bb_sptr self, int which) -> unsigned int"""
        return _digital_swig2.protocol_formatter_bb_sptr_sample_delay(self, which)


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


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


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


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


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(protocol_formatter_bb_sptr self) -> float"""
        return _digital_swig2.protocol_formatter_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(protocol_formatter_bb_sptr self)"""
        return _digital_swig2.protocol_formatter_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(protocol_formatter_bb_sptr self) -> int"""
        return _digital_swig2.protocol_formatter_bb_sptr_active_thread_priority(self)


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


    def set_thread_priority(self, priority):
        """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):
        """name(protocol_formatter_bb_sptr self) -> std::string"""
        return _digital_swig2.protocol_formatter_bb_sptr_name(self)


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


    def input_signature(self):
        """input_signature(protocol_formatter_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig2.protocol_formatter_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(protocol_formatter_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig2.protocol_formatter_bb_sptr_output_signature(self)


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


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(protocol_formatter_bb_sptr self) -> std::string"""
        return _digital_swig2.protocol_formatter_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(protocol_formatter_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig2.protocol_formatter_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(protocol_formatter_bb_sptr self) -> swig_int_ptr"""
        return _digital_swig2.protocol_formatter_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(protocol_formatter_bb_sptr self) -> swig_int_ptr"""
        return _digital_swig2.protocol_formatter_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(protocol_formatter_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig2.protocol_formatter_bb_sptr_message_subscribers(self, which_port)

protocol_formatter_bb_sptr_swigregister = _digital_swig2.protocol_formatter_bb_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::protocol_parser_b)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::protocol_parser_b)> self) -> protocol_parser_b_sptr
        __init__(boost::shared_ptr<(gr::digital::protocol_parser_b)> self, protocol_parser_b p) -> protocol_parser_b_sptr
        """
        this = _digital_swig2.new_protocol_parser_b_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, format):
        """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):
        """history(protocol_parser_b_sptr self) -> unsigned int"""
        return _digital_swig2.protocol_parser_b_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(protocol_parser_b_sptr self, int which) -> unsigned int"""
        return _digital_swig2.protocol_parser_b_sptr_sample_delay(self, which)


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


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


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


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


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(protocol_parser_b_sptr self) -> float"""
        return _digital_swig2.protocol_parser_b_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(protocol_parser_b_sptr self)"""
        return _digital_swig2.protocol_parser_b_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(protocol_parser_b_sptr self) -> int"""
        return _digital_swig2.protocol_parser_b_sptr_active_thread_priority(self)


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


    def set_thread_priority(self, priority):
        """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):
        """name(protocol_parser_b_sptr self) -> std::string"""
        return _digital_swig2.protocol_parser_b_sptr_name(self)


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


    def input_signature(self):
        """input_signature(protocol_parser_b_sptr self) -> io_signature_sptr"""
        return _digital_swig2.protocol_parser_b_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(protocol_parser_b_sptr self) -> io_signature_sptr"""
        return _digital_swig2.protocol_parser_b_sptr_output_signature(self)


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


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(protocol_parser_b_sptr self) -> std::string"""
        return _digital_swig2.protocol_parser_b_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(protocol_parser_b_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig2.protocol_parser_b_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(protocol_parser_b_sptr self) -> swig_int_ptr"""
        return _digital_swig2.protocol_parser_b_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(protocol_parser_b_sptr self) -> swig_int_ptr"""
        return _digital_swig2.protocol_parser_b_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(protocol_parser_b_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig2.protocol_parser_b_sptr_message_subscribers(self, which_port)

protocol_parser_b_sptr_swigregister = _digital_swig2.protocol_parser_b_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::packet_headergenerator_bb)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::packet_headergenerator_bb)> self) -> packet_headergenerator_bb_sptr
        __init__(boost::shared_ptr<(gr::digital::packet_headergenerator_bb)> self, packet_headergenerator_bb p) -> packet_headergenerator_bb_sptr
        """
        this = _digital_swig2.new_packet_headergenerator_bb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, *args):
        """
        make(packet_headergenerator_bb_sptr self, packet_header_default_sptr header_formatter, std::string const & len_tag_key) -> packet_headergenerator_bb_sptr
        make(packet_headergenerator_bb_sptr self, long header_len, std::string const & len_tag_key) -> packet_headergenerator_bb_sptr
        """
        return _digital_swig2.packet_headergenerator_bb_sptr_make(self, *args)


    def set_header_formatter(self, header_formatter):
        """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):
        """history(packet_headergenerator_bb_sptr self) -> unsigned int"""
        return _digital_swig2.packet_headergenerator_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(packet_headergenerator_bb_sptr self, int which) -> unsigned int"""
        return _digital_swig2.packet_headergenerator_bb_sptr_sample_delay(self, which)


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


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


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


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


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(packet_headergenerator_bb_sptr self) -> float"""
        return _digital_swig2.packet_headergenerator_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(packet_headergenerator_bb_sptr self)"""
        return _digital_swig2.packet_headergenerator_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(packet_headergenerator_bb_sptr self) -> int"""
        return _digital_swig2.packet_headergenerator_bb_sptr_active_thread_priority(self)


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


    def set_thread_priority(self, priority):
        """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):
        """name(packet_headergenerator_bb_sptr self) -> std::string"""
        return _digital_swig2.packet_headergenerator_bb_sptr_name(self)


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


    def input_signature(self):
        """input_signature(packet_headergenerator_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig2.packet_headergenerator_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(packet_headergenerator_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig2.packet_headergenerator_bb_sptr_output_signature(self)


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


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(packet_headergenerator_bb_sptr self) -> std::string"""
        return _digital_swig2.packet_headergenerator_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(packet_headergenerator_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig2.packet_headergenerator_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(packet_headergenerator_bb_sptr self) -> swig_int_ptr"""
        return _digital_swig2.packet_headergenerator_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(packet_headergenerator_bb_sptr self) -> swig_int_ptr"""
        return _digital_swig2.packet_headergenerator_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(packet_headergenerator_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig2.packet_headergenerator_bb_sptr_message_subscribers(self, which_port)

packet_headergenerator_bb_sptr_swigregister = _digital_swig2.packet_headergenerator_bb_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::packet_headerparser_b)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::packet_headerparser_b)> self) -> packet_headerparser_b_sptr
        __init__(boost::shared_ptr<(gr::digital::packet_headerparser_b)> self, packet_headerparser_b p) -> packet_headerparser_b_sptr
        """
        this = _digital_swig2.new_packet_headerparser_b_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, *args):
        """
        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):
        """history(packet_headerparser_b_sptr self) -> unsigned int"""
        return _digital_swig2.packet_headerparser_b_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(packet_headerparser_b_sptr self, int which) -> unsigned int"""
        return _digital_swig2.packet_headerparser_b_sptr_sample_delay(self, which)


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


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


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


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


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(packet_headerparser_b_sptr self) -> float"""
        return _digital_swig2.packet_headerparser_b_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(packet_headerparser_b_sptr self)"""
        return _digital_swig2.packet_headerparser_b_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(packet_headerparser_b_sptr self) -> int"""
        return _digital_swig2.packet_headerparser_b_sptr_active_thread_priority(self)


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


    def set_thread_priority(self, priority):
        """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):
        """name(packet_headerparser_b_sptr self) -> std::string"""
        return _digital_swig2.packet_headerparser_b_sptr_name(self)


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


    def input_signature(self):
        """input_signature(packet_headerparser_b_sptr self) -> io_signature_sptr"""
        return _digital_swig2.packet_headerparser_b_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(packet_headerparser_b_sptr self) -> io_signature_sptr"""
        return _digital_swig2.packet_headerparser_b_sptr_output_signature(self)


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


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(packet_headerparser_b_sptr self) -> std::string"""
        return _digital_swig2.packet_headerparser_b_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(packet_headerparser_b_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig2.packet_headerparser_b_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(packet_headerparser_b_sptr self) -> swig_int_ptr"""
        return _digital_swig2.packet_headerparser_b_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(packet_headerparser_b_sptr self) -> swig_int_ptr"""
        return _digital_swig2.packet_headerparser_b_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(packet_headerparser_b_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig2.packet_headerparser_b_sptr_message_subscribers(self, which_port)

packet_headerparser_b_sptr_swigregister = _digital_swig2.packet_headerparser_b_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::packet_sink)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::packet_sink)> self) -> packet_sink_sptr
        __init__(boost::shared_ptr<(gr::digital::packet_sink)> self, packet_sink p) -> packet_sink_sptr
        """
        this = _digital_swig2.new_packet_sink_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(packet_sink_sptr self) -> packet_sink"""
        return _digital_swig2.packet_sink_sptr___deref__(self)

    __swig_destroy__ = _digital_swig2.delete_packet_sink_sptr
    __del__ = lambda self: None

    def make(self, sync_vector, target_queue, threshold=-1):
        """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):
        """carrier_sensed(packet_sink_sptr self) -> bool"""
        return _digital_swig2.packet_sink_sptr_carrier_sensed(self)


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


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(packet_sink_sptr self, int which) -> unsigned int"""
        return _digital_swig2.packet_sink_sptr_sample_delay(self, which)


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


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


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


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


    def nitems_read(self, which_input):
        """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):
        """nitems_written(packet_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.packet_sink_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """min_noutput_items(packet_sink_sptr self) -> int"""
        return _digital_swig2.packet_sink_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """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):
        """
        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):
        """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):
        """
        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):
        """pc_noutput_items(packet_sink_sptr self) -> float"""
        return _digital_swig2.packet_sink_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """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):
        """pc_noutput_items_var(packet_sink_sptr self) -> float"""
        return _digital_swig2.packet_sink_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(packet_sink_sptr self) -> float"""
        return _digital_swig2.packet_sink_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(packet_sink_sptr self) -> float"""
        return _digital_swig2.packet_sink_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """pc_work_time(packet_sink_sptr self) -> float"""
        return _digital_swig2.packet_sink_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """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):
        """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):
        """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):
        """pc_throughput_avg(packet_sink_sptr self) -> float"""
        return _digital_swig2.packet_sink_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """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):
        """unset_processor_affinity(packet_sink_sptr self)"""
        return _digital_swig2.packet_sink_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(packet_sink_sptr self) -> int"""
        return _digital_swig2.packet_sink_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(packet_sink_sptr self) -> int"""
        return _digital_swig2.packet_sink_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(packet_sink_sptr self, int priority) -> int"""
        return _digital_swig2.packet_sink_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(packet_sink_sptr self) -> std::string"""
        return _digital_swig2.packet_sink_sptr_name(self)


    def symbol_name(self):
        """symbol_name(packet_sink_sptr self) -> std::string"""
        return _digital_swig2.packet_sink_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(packet_sink_sptr self) -> io_signature_sptr"""
        return _digital_swig2.packet_sink_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(packet_sink_sptr self) -> io_signature_sptr"""
        return _digital_swig2.packet_sink_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(packet_sink_sptr self) -> long"""
        return _digital_swig2.packet_sink_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(packet_sink_sptr self) -> std::string"""
        return _digital_swig2.packet_sink_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(packet_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig2.packet_sink_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(packet_sink_sptr self) -> swig_int_ptr"""
        return _digital_swig2.packet_sink_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(packet_sink_sptr self) -> swig_int_ptr"""
        return _digital_swig2.packet_sink_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(packet_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig2.packet_sink_sptr_message_subscribers(self, which_port)

packet_sink_sptr_swigregister = _digital_swig2.packet_sink_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::pfb_clock_sync_ccf)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::pfb_clock_sync_ccf)> self) -> pfb_clock_sync_ccf_sptr
        __init__(boost::shared_ptr<(gr::digital::pfb_clock_sync_ccf)> self, pfb_clock_sync_ccf p) -> pfb_clock_sync_ccf_sptr
        """
        this = _digital_swig2.new_pfb_clock_sync_ccf_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, sps, loop_bw, taps, filter_size=32, init_phase=0, max_rate_deviation=1.5, osps=1):
        """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):
        """update_gains(pfb_clock_sync_ccf_sptr self)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_update_gains(self)


    def update_taps(self, taps):
        """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, ourtaps, ourfilter):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """loop_bandwidth(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_loop_bandwidth(self)


    def damping_factor(self):
        """damping_factor(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_damping_factor(self)


    def alpha(self):
        """alpha(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_alpha(self)


    def beta(self):
        """beta(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_beta(self)


    def clock_rate(self):
        """clock_rate(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_clock_rate(self)


    def error(self):
        """error(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_error(self)


    def rate(self):
        """rate(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_rate(self)


    def phase(self):
        """phase(pfb_clock_sync_ccf_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_phase(self)


    def history(self):
        """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):
        """
        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):
        """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 output_multiple(self):
        """output_multiple(pfb_clock_sync_ccf_sptr self) -> int"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(pfb_clock_sync_ccf_sptr self) -> double"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_relative_rate(self)


    def start(self):
        """start(pfb_clock_sync_ccf_sptr self) -> bool"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_start(self)


    def stop(self):
        """stop(pfb_clock_sync_ccf_sptr self) -> bool"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """name(pfb_clock_sync_ccf_sptr self) -> std::string"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_name(self)


    def symbol_name(self):
        """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):
        """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):
        """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):
        """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):
        """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, noutputs):
        """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):
        """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):
        """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, msg):
        """_post(pfb_clock_sync_ccf_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(pfb_clock_sync_ccf_sptr self) -> swig_int_ptr"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(pfb_clock_sync_ccf_sptr self) -> swig_int_ptr"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(pfb_clock_sync_ccf_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig2.pfb_clock_sync_ccf_sptr_message_subscribers(self, which_port)

pfb_clock_sync_ccf_sptr_swigregister = _digital_swig2.pfb_clock_sync_ccf_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::pfb_clock_sync_fff)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::pfb_clock_sync_fff)> self) -> pfb_clock_sync_fff_sptr
        __init__(boost::shared_ptr<(gr::digital::pfb_clock_sync_fff)> self, pfb_clock_sync_fff p) -> pfb_clock_sync_fff_sptr
        """
        this = _digital_swig2.new_pfb_clock_sync_fff_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, sps, gain, taps, filter_size=32, init_phase=0, max_rate_deviation=1.5, osps=1):
        """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):
        """update_gains(pfb_clock_sync_fff_sptr self)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_update_gains(self)


    def update_taps(self, taps):
        """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, ourtaps, ourfilter):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """loop_bandwidth(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_loop_bandwidth(self)


    def damping_factor(self):
        """damping_factor(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_damping_factor(self)


    def alpha(self):
        """alpha(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_alpha(self)


    def beta(self):
        """beta(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_beta(self)


    def clock_rate(self):
        """clock_rate(pfb_clock_sync_fff_sptr self) -> float"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_clock_rate(self)


    def history(self):
        """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):
        """
        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):
        """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 output_multiple(self):
        """output_multiple(pfb_clock_sync_fff_sptr self) -> int"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(pfb_clock_sync_fff_sptr self) -> double"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_relative_rate(self)


    def start(self):
        """start(pfb_clock_sync_fff_sptr self) -> bool"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_start(self)


    def stop(self):
        """stop(pfb_clock_sync_fff_sptr self) -> bool"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """name(pfb_clock_sync_fff_sptr self) -> std::string"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_name(self)


    def symbol_name(self):
        """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):
        """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):
        """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):
        """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):
        """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, noutputs):
        """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):
        """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):
        """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, msg):
        """_post(pfb_clock_sync_fff_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig2.pfb_clock_sync_fff_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(pfb_clock_sync_fff_sptr self) -> swig_int_ptr"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(pfb_clock_sync_fff_sptr self) -> swig_int_ptr"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(pfb_clock_sync_fff_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig2.pfb_clock_sync_fff_sptr_message_subscribers(self, which_port)

pfb_clock_sync_fff_sptr_swigregister = _digital_swig2.pfb_clock_sync_fff_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::pn_correlator_cc)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::pn_correlator_cc)> self) -> pn_correlator_cc_sptr
        __init__(boost::shared_ptr<(gr::digital::pn_correlator_cc)> self, pn_correlator_cc p) -> pn_correlator_cc_sptr
        """
        this = _digital_swig2.new_pn_correlator_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, degree, mask=0, seed=1):
        """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):
        """history(pn_correlator_cc_sptr self) -> unsigned int"""
        return _digital_swig2.pn_correlator_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(pn_correlator_cc_sptr self, int which) -> unsigned int"""
        return _digital_swig2.pn_correlator_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(pn_correlator_cc_sptr self) -> int"""
        return _digital_swig2.pn_correlator_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(pn_correlator_cc_sptr self) -> double"""
        return _digital_swig2.pn_correlator_cc_sptr_relative_rate(self)


    def start(self):
        """start(pn_correlator_cc_sptr self) -> bool"""
        return _digital_swig2.pn_correlator_cc_sptr_start(self)


    def stop(self):
        """stop(pn_correlator_cc_sptr self) -> bool"""
        return _digital_swig2.pn_correlator_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(pn_correlator_cc_sptr self) -> float"""
        return _digital_swig2.pn_correlator_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(pn_correlator_cc_sptr self)"""
        return _digital_swig2.pn_correlator_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(pn_correlator_cc_sptr self) -> int"""
        return _digital_swig2.pn_correlator_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(pn_correlator_cc_sptr self) -> int"""
        return _digital_swig2.pn_correlator_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(pn_correlator_cc_sptr self) -> std::string"""
        return _digital_swig2.pn_correlator_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(pn_correlator_cc_sptr self) -> std::string"""
        return _digital_swig2.pn_correlator_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(pn_correlator_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig2.pn_correlator_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(pn_correlator_cc_sptr self) -> io_signature_sptr"""
        return _digital_swig2.pn_correlator_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(pn_correlator_cc_sptr self) -> long"""
        return _digital_swig2.pn_correlator_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(pn_correlator_cc_sptr self) -> std::string"""
        return _digital_swig2.pn_correlator_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(pn_correlator_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig2.pn_correlator_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(pn_correlator_cc_sptr self) -> swig_int_ptr"""
        return _digital_swig2.pn_correlator_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(pn_correlator_cc_sptr self) -> swig_int_ptr"""
        return _digital_swig2.pn_correlator_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(pn_correlator_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig2.pn_correlator_cc_sptr_message_subscribers(self, which_port)

pn_correlator_cc_sptr_swigregister = _digital_swig2.pn_correlator_cc_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::probe_density_b)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::probe_density_b)> self) -> probe_density_b_sptr
        __init__(boost::shared_ptr<(gr::digital::probe_density_b)> self, probe_density_b p) -> probe_density_b_sptr
        """
        this = _digital_swig2.new_probe_density_b_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, alpha):
        """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):
        """density(probe_density_b_sptr self) -> double"""
        return _digital_swig2.probe_density_b_sptr_density(self)


    def set_alpha(self, alpha):
        """set_alpha(probe_density_b_sptr self, double alpha)"""
        return _digital_swig2.probe_density_b_sptr_set_alpha(self, alpha)


    def history(self):
        """history(probe_density_b_sptr self) -> unsigned int"""
        return _digital_swig2.probe_density_b_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(probe_density_b_sptr self, int which) -> unsigned int"""
        return _digital_swig2.probe_density_b_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(probe_density_b_sptr self) -> int"""
        return _digital_swig2.probe_density_b_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(probe_density_b_sptr self) -> double"""
        return _digital_swig2.probe_density_b_sptr_relative_rate(self)


    def start(self):
        """start(probe_density_b_sptr self) -> bool"""
        return _digital_swig2.probe_density_b_sptr_start(self)


    def stop(self):
        """stop(probe_density_b_sptr self) -> bool"""
        return _digital_swig2.probe_density_b_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """pc_nproduced(probe_density_b_sptr self) -> float"""
        return _digital_swig2.probe_density_b_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """unset_processor_affinity(probe_density_b_sptr self)"""
        return _digital_swig2.probe_density_b_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(probe_density_b_sptr self) -> int"""
        return _digital_swig2.probe_density_b_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(probe_density_b_sptr self) -> int"""
        return _digital_swig2.probe_density_b_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """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):
        """name(probe_density_b_sptr self) -> std::string"""
        return _digital_swig2.probe_density_b_sptr_name(self)


    def symbol_name(self):
        """symbol_name(probe_density_b_sptr self) -> std::string"""
        return _digital_swig2.probe_density_b_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(probe_density_b_sptr self) -> io_signature_sptr"""
        return _digital_swig2.probe_density_b_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(probe_density_b_sptr self) -> io_signature_sptr"""
        return _digital_swig2.probe_density_b_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(probe_density_b_sptr self) -> long"""
        return _digital_swig2.probe_density_b_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(probe_density_b_sptr self) -> std::string"""
        return _digital_swig2.probe_density_b_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(probe_density_b_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig2.probe_density_b_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(probe_density_b_sptr self) -> swig_int_ptr"""
        return _digital_swig2.probe_density_b_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(probe_density_b_sptr self) -> swig_int_ptr"""
        return _digital_swig2.probe_density_b_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(probe_density_b_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig2.probe_density_b_sptr_message_subscribers(self, which_port)

probe_density_b_sptr_swigregister = _digital_swig2.probe_density_b_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::probe_mpsk_snr_est_c)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::probe_mpsk_snr_est_c)> self) -> probe_mpsk_snr_est_c_sptr
        __init__(boost::shared_ptr<(gr::digital::probe_mpsk_snr_est_c)> self, probe_mpsk_snr_est_c p) -> probe_mpsk_snr_est_c_sptr
        """
        this = _digital_swig2.new_probe_mpsk_snr_est_c_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, type, msg_nsamples=10000, alpha=0.001):
        """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):
        """snr(probe_mpsk_snr_est_c_sptr self) -> double"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_snr(self)


    def signal(self):
        """signal(probe_mpsk_snr_est_c_sptr self) -> double"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_signal(self)


    def noise(self):
        """noise(probe_mpsk_snr_est_c_sptr self) -> double"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_noise(self)


    def type(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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 output_multiple(self):
        """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):
        """relative_rate(probe_mpsk_snr_est_c_sptr self) -> double"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_relative_rate(self)


    def start(self):
        """start(probe_mpsk_snr_est_c_sptr self) -> bool"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_start(self)


    def stop(self):
        """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):
        """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):
        """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 max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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):
        """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, noutputs):
        """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):
        """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):
        """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, msg):
        """_post(probe_mpsk_snr_est_c_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(probe_mpsk_snr_est_c_sptr self) -> swig_int_ptr"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(probe_mpsk_snr_est_c_sptr self) -> swig_int_ptr"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(probe_mpsk_snr_est_c_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig2.probe_mpsk_snr_est_c_sptr_message_subscribers(self, which_port)

probe_mpsk_snr_est_c_sptr_swigregister = _digital_swig2.probe_mpsk_snr_est_c_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::scrambler_bb)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::scrambler_bb)> self) -> scrambler_bb_sptr
        __init__(boost::shared_ptr<(gr::digital::scrambler_bb)> self, scrambler_bb p) -> scrambler_bb_sptr
        """
        this = _digital_swig2.new_scrambler_bb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(scrambler_bb_sptr self) -> scrambler_bb"""
        return _digital_swig2.scrambler_bb_sptr___deref__(self)

    __swig_destroy__ = _digital_swig2.delete_scrambler_bb_sptr
    __del__ = lambda self: None

    def make(self, mask, seed, len):
        """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):
        """history(scrambler_bb_sptr self) -> unsigned int"""
        return _digital_swig2.scrambler_bb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(scrambler_bb_sptr self, int which) -> unsigned int"""
        return _digital_swig2.scrambler_bb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(scrambler_bb_sptr self) -> int"""
        return _digital_swig2.scrambler_bb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(scrambler_bb_sptr self) -> double"""
        return _digital_swig2.scrambler_bb_sptr_relative_rate(self)


    def start(self):
        """start(scrambler_bb_sptr self) -> bool"""
        return _digital_swig2.scrambler_bb_sptr_start(self)


    def stop(self):
        """stop(scrambler_bb_sptr self) -> bool"""
        return _digital_swig2.scrambler_bb_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """nitems_written(scrambler_bb_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.scrambler_bb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """min_noutput_items(scrambler_bb_sptr self) -> int"""
        return _digital_swig2.scrambler_bb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """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):
        """
        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):
        """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):
        """
        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):
        """pc_noutput_items(scrambler_bb_sptr self) -> float"""
        return _digital_swig2.scrambler_bb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """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):
        """pc_noutput_items_var(scrambler_bb_sptr self) -> float"""
        return _digital_swig2.scrambler_bb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(scrambler_bb_sptr self) -> float"""
        return _digital_swig2.scrambler_bb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(scrambler_bb_sptr self) -> float"""
        return _digital_swig2.scrambler_bb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """pc_work_time(scrambler_bb_sptr self) -> float"""
        return _digital_swig2.scrambler_bb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """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):
        """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):
        """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):
        """pc_throughput_avg(scrambler_bb_sptr self) -> float"""
        return _digital_swig2.scrambler_bb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """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):
        """unset_processor_affinity(scrambler_bb_sptr self)"""
        return _digital_swig2.scrambler_bb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(scrambler_bb_sptr self) -> int"""
        return _digital_swig2.scrambler_bb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(scrambler_bb_sptr self) -> int"""
        return _digital_swig2.scrambler_bb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(scrambler_bb_sptr self, int priority) -> int"""
        return _digital_swig2.scrambler_bb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(scrambler_bb_sptr self) -> std::string"""
        return _digital_swig2.scrambler_bb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(scrambler_bb_sptr self) -> std::string"""
        return _digital_swig2.scrambler_bb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(scrambler_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig2.scrambler_bb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(scrambler_bb_sptr self) -> io_signature_sptr"""
        return _digital_swig2.scrambler_bb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(scrambler_bb_sptr self) -> long"""
        return _digital_swig2.scrambler_bb_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(scrambler_bb_sptr self) -> std::string"""
        return _digital_swig2.scrambler_bb_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(scrambler_bb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig2.scrambler_bb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(scrambler_bb_sptr self) -> swig_int_ptr"""
        return _digital_swig2.scrambler_bb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(scrambler_bb_sptr self) -> swig_int_ptr"""
        return _digital_swig2.scrambler_bb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(scrambler_bb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig2.scrambler_bb_sptr_message_subscribers(self, which_port)

scrambler_bb_sptr_swigregister = _digital_swig2.scrambler_bb_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::simple_correlator)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::simple_correlator)> self) -> simple_correlator_sptr
        __init__(boost::shared_ptr<(gr::digital::simple_correlator)> self, simple_correlator p) -> simple_correlator_sptr
        """
        this = _digital_swig2.new_simple_correlator_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(simple_correlator_sptr self) -> simple_correlator"""
        return _digital_swig2.simple_correlator_sptr___deref__(self)

    __swig_destroy__ = _digital_swig2.delete_simple_correlator_sptr
    __del__ = lambda self: None

    def make(self, payload_bytesize):
        """make(simple_correlator_sptr self, int payload_bytesize) -> simple_correlator_sptr"""
        return _digital_swig2.simple_correlator_sptr_make(self, payload_bytesize)


    def history(self):
        """history(simple_correlator_sptr self) -> unsigned int"""
        return _digital_swig2.simple_correlator_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(simple_correlator_sptr self, int which) -> unsigned int"""
        return _digital_swig2.simple_correlator_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(simple_correlator_sptr self) -> int"""
        return _digital_swig2.simple_correlator_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(simple_correlator_sptr self) -> double"""
        return _digital_swig2.simple_correlator_sptr_relative_rate(self)


    def start(self):
        """start(simple_correlator_sptr self) -> bool"""
        return _digital_swig2.simple_correlator_sptr_start(self)


    def stop(self):
        """stop(simple_correlator_sptr self) -> bool"""
        return _digital_swig2.simple_correlator_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """nitems_written(simple_correlator_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.simple_correlator_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """min_noutput_items(simple_correlator_sptr self) -> int"""
        return _digital_swig2.simple_correlator_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """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):
        """
        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):
        """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):
        """
        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):
        """pc_noutput_items(simple_correlator_sptr self) -> float"""
        return _digital_swig2.simple_correlator_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """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):
        """pc_noutput_items_var(simple_correlator_sptr self) -> float"""
        return _digital_swig2.simple_correlator_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(simple_correlator_sptr self) -> float"""
        return _digital_swig2.simple_correlator_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(simple_correlator_sptr self) -> float"""
        return _digital_swig2.simple_correlator_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """pc_work_time(simple_correlator_sptr self) -> float"""
        return _digital_swig2.simple_correlator_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """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):
        """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):
        """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):
        """pc_throughput_avg(simple_correlator_sptr self) -> float"""
        return _digital_swig2.simple_correlator_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """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):
        """unset_processor_affinity(simple_correlator_sptr self)"""
        return _digital_swig2.simple_correlator_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(simple_correlator_sptr self) -> int"""
        return _digital_swig2.simple_correlator_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(simple_correlator_sptr self) -> int"""
        return _digital_swig2.simple_correlator_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(simple_correlator_sptr self, int priority) -> int"""
        return _digital_swig2.simple_correlator_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(simple_correlator_sptr self) -> std::string"""
        return _digital_swig2.simple_correlator_sptr_name(self)


    def symbol_name(self):
        """symbol_name(simple_correlator_sptr self) -> std::string"""
        return _digital_swig2.simple_correlator_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(simple_correlator_sptr self) -> io_signature_sptr"""
        return _digital_swig2.simple_correlator_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(simple_correlator_sptr self) -> io_signature_sptr"""
        return _digital_swig2.simple_correlator_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(simple_correlator_sptr self) -> long"""
        return _digital_swig2.simple_correlator_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(simple_correlator_sptr self) -> std::string"""
        return _digital_swig2.simple_correlator_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(simple_correlator_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig2.simple_correlator_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(simple_correlator_sptr self) -> swig_int_ptr"""
        return _digital_swig2.simple_correlator_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(simple_correlator_sptr self) -> swig_int_ptr"""
        return _digital_swig2.simple_correlator_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(simple_correlator_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig2.simple_correlator_sptr_message_subscribers(self, which_port)

simple_correlator_sptr_swigregister = _digital_swig2.simple_correlator_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::simple_framer)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::simple_framer)> self) -> simple_framer_sptr
        __init__(boost::shared_ptr<(gr::digital::simple_framer)> self, simple_framer p) -> simple_framer_sptr
        """
        this = _digital_swig2.new_simple_framer_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(simple_framer_sptr self) -> simple_framer"""
        return _digital_swig2.simple_framer_sptr___deref__(self)

    __swig_destroy__ = _digital_swig2.delete_simple_framer_sptr
    __del__ = lambda self: None

    def make(self, payload_bytesize):
        """make(simple_framer_sptr self, int payload_bytesize) -> simple_framer_sptr"""
        return _digital_swig2.simple_framer_sptr_make(self, payload_bytesize)


    def history(self):
        """history(simple_framer_sptr self) -> unsigned int"""
        return _digital_swig2.simple_framer_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        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):
        """sample_delay(simple_framer_sptr self, int which) -> unsigned int"""
        return _digital_swig2.simple_framer_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(simple_framer_sptr self) -> int"""
        return _digital_swig2.simple_framer_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(simple_framer_sptr self) -> double"""
        return _digital_swig2.simple_framer_sptr_relative_rate(self)


    def start(self):
        """start(simple_framer_sptr self) -> bool"""
        return _digital_swig2.simple_framer_sptr_start(self)


    def stop(self):
        """stop(simple_framer_sptr self) -> bool"""
        return _digital_swig2.simple_framer_sptr_stop(self)


    def nitems_read(self, which_input):
        """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):
        """nitems_written(simple_framer_sptr self, unsigned int which_output) -> uint64_t"""
        return _digital_swig2.simple_framer_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """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):
        """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):
        """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):
        """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):
        """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):
        """min_noutput_items(simple_framer_sptr self) -> int"""
        return _digital_swig2.simple_framer_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """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):
        """
        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):
        """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):
        """
        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):
        """pc_noutput_items(simple_framer_sptr self) -> float"""
        return _digital_swig2.simple_framer_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """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):
        """pc_noutput_items_var(simple_framer_sptr self) -> float"""
        return _digital_swig2.simple_framer_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(simple_framer_sptr self) -> float"""
        return _digital_swig2.simple_framer_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(simple_framer_sptr self) -> float"""
        return _digital_swig2.simple_framer_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """
        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):
        """pc_work_time(simple_framer_sptr self) -> float"""
        return _digital_swig2.simple_framer_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """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):
        """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):
        """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):
        """pc_throughput_avg(simple_framer_sptr self) -> float"""
        return _digital_swig2.simple_framer_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """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):
        """unset_processor_affinity(simple_framer_sptr self)"""
        return _digital_swig2.simple_framer_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """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):
        """active_thread_priority(simple_framer_sptr self) -> int"""
        return _digital_swig2.simple_framer_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(simple_framer_sptr self) -> int"""
        return _digital_swig2.simple_framer_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(simple_framer_sptr self, int priority) -> int"""
        return _digital_swig2.simple_framer_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(simple_framer_sptr self) -> std::string"""
        return _digital_swig2.simple_framer_sptr_name(self)


    def symbol_name(self):
        """symbol_name(simple_framer_sptr self) -> std::string"""
        return _digital_swig2.simple_framer_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(simple_framer_sptr self) -> io_signature_sptr"""
        return _digital_swig2.simple_framer_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(simple_framer_sptr self) -> io_signature_sptr"""
        return _digital_swig2.simple_framer_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(simple_framer_sptr self) -> long"""
        return _digital_swig2.simple_framer_sptr_unique_id(self)


    def to_basic_block(self):
        """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, noutputs):
        """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):
        """alias(simple_framer_sptr self) -> std::string"""
        return _digital_swig2.simple_framer_sptr_alias(self)


    def set_block_alias(self, name):
        """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, msg):
        """_post(simple_framer_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _digital_swig2.simple_framer_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(simple_framer_sptr self) -> swig_int_ptr"""
        return _digital_swig2.simple_framer_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(simple_framer_sptr self) -> swig_int_ptr"""
        return _digital_swig2.simple_framer_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(simple_framer_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _digital_swig2.simple_framer_sptr_message_subscribers(self, which_port)

simple_framer_sptr_swigregister = _digital_swig2.simple_framer_sptr_swigregister
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 packet_header_default_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::packet_header_default)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::packet_header_default)> self) -> packet_header_default_sptr
        __init__(boost::shared_ptr<(gr::digital::packet_header_default)> self, packet_header_default p) -> packet_header_default_sptr
        """
        this = _digital_swig2.new_packet_header_default_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def base(self):
        """base(packet_header_default_sptr self) -> packet_header_default_sptr"""
        return _digital_swig2.packet_header_default_sptr_base(self)


    def formatter(self):
        """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):
        """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):
        """header_len(packet_header_default_sptr self) -> long"""
        return _digital_swig2.packet_header_default_sptr_header_len(self)


    def len_tag_key(self):
        """len_tag_key(packet_header_default_sptr self) -> swig_int_ptr"""
        return _digital_swig2.packet_header_default_sptr_len_tag_key(self)


    def header_formatter(self, *args, **kwargs):
        """header_formatter(packet_header_default_sptr self, long packet_len, unsigned char * out, tags_vector_t tags) -> bool"""
        return _digital_swig2.packet_header_default_sptr_header_formatter(self, *args, **kwargs)


    def header_parser(self, header, tags):
        """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):
        """make(packet_header_default_sptr self, long header_len, std::string const & len_tag_key, std::string const & num_tag_key, int bits_per_byte=1) -> packet_header_default_sptr"""
        return _digital_swig2.packet_header_default_sptr_make(self, *args, **kwargs)

packet_header_default_sptr_swigregister = _digital_swig2.packet_header_default_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::packet_header_ofdm)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::packet_header_ofdm)> self) -> packet_header_ofdm_sptr
        __init__(boost::shared_ptr<(gr::digital::packet_header_ofdm)> self, packet_header_ofdm p) -> packet_header_ofdm_sptr
        """
        this = _digital_swig2.new_packet_header_ofdm_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """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, std::string const & frame_len_tag_key, std::string const & num_tag_key, 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):
        """base(packet_header_ofdm_sptr self) -> packet_header_default_sptr"""
        return _digital_swig2.packet_header_ofdm_sptr_base(self)


    def formatter(self):
        """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):
        """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):
        """header_len(packet_header_ofdm_sptr self) -> long"""
        return _digital_swig2.packet_header_ofdm_sptr_header_len(self)


    def len_tag_key(self):
        """len_tag_key(packet_header_ofdm_sptr self) -> swig_int_ptr"""
        return _digital_swig2.packet_header_ofdm_sptr_len_tag_key(self)


    def header_formatter(self, *args, **kwargs):
        """header_formatter(packet_header_ofdm_sptr self, long packet_len, unsigned char * out, tags_vector_t tags) -> bool"""
        return _digital_swig2.packet_header_ofdm_sptr_header_formatter(self, *args, **kwargs)


    def header_parser(self, header, tags):
        """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)

packet_header_ofdm_sptr_swigregister = _digital_swig2.packet_header_ofdm_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::header_format_base)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::header_format_base)> self) -> header_format_base_sptr
        __init__(boost::shared_ptr<(gr::digital::header_format_base)> self, header_format_base p) -> header_format_base_sptr
        """
        this = _digital_swig2.new_header_format_base_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def base(self):
        """base(header_format_base_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_base_sptr_base(self)


    def formatter(self):
        """formatter(header_format_base_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_base_sptr_formatter(self)


    def format(self, nbytes_in, input, output, info):
        """format(header_format_base_sptr self, int nbytes_in, unsigned char const * input, swig_int_ptr output, swig_int_ptr info) -> bool"""
        return _digital_swig2.header_format_base_sptr_format(self, nbytes_in, input, output, info)


    def parse(self, nbits_in, input, info, nbits_processed):
        """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):
        """header_nbits(header_format_base_sptr self) -> size_t"""
        return _digital_swig2.header_format_base_sptr_header_nbits(self)


    def header_nbytes(self):
        """header_nbytes(header_format_base_sptr self) -> size_t"""
        return _digital_swig2.header_format_base_sptr_header_nbytes(self)

header_format_base_sptr_swigregister = _digital_swig2.header_format_base_sptr_swigregister
header_format_base_sptr_swigregister(header_format_base_sptr)

class header_format_default_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::header_format_default)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::header_format_default)> self) -> header_format_default_sptr
        __init__(boost::shared_ptr<(gr::digital::header_format_default)> self, header_format_default p) -> header_format_default_sptr
        """
        this = _digital_swig2.new_header_format_default_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def set_access_code(self, access_code):
        """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):
        """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=0):
        """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):
        """threshold(header_format_default_sptr self) -> unsigned int"""
        return _digital_swig2.header_format_default_sptr_threshold(self)


    def make(self, access_code, threshold):
        """make(header_format_default_sptr self, std::string const & access_code, int threshold) -> header_format_base_sptr"""
        return _digital_swig2.header_format_default_sptr_make(self, access_code, threshold)


    def base(self):
        """base(header_format_default_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_default_sptr_base(self)


    def formatter(self):
        """formatter(header_format_default_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_default_sptr_formatter(self)


    def format(self, nbytes_in, input, output, info):
        """format(header_format_default_sptr self, int nbytes_in, unsigned char const * input, swig_int_ptr output, swig_int_ptr info) -> bool"""
        return _digital_swig2.header_format_default_sptr_format(self, nbytes_in, input, output, info)


    def parse(self, nbits_in, input, info, nbits_processed):
        """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):
        """header_nbits(header_format_default_sptr self) -> size_t"""
        return _digital_swig2.header_format_default_sptr_header_nbits(self)


    def header_nbytes(self):
        """header_nbytes(header_format_default_sptr self) -> size_t"""
        return _digital_swig2.header_format_default_sptr_header_nbytes(self)

header_format_default_sptr_swigregister = _digital_swig2.header_format_default_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::header_format_counter)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::header_format_counter)> self) -> header_format_counter_sptr
        __init__(boost::shared_ptr<(gr::digital::header_format_counter)> self, header_format_counter p) -> header_format_counter_sptr
        """
        this = _digital_swig2.new_header_format_counter_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, access_code, threshold, bps):
        """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):
        """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):
        """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=0):
        """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):
        """threshold(header_format_counter_sptr self) -> unsigned int"""
        return _digital_swig2.header_format_counter_sptr_threshold(self)


    def base(self):
        """base(header_format_counter_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_counter_sptr_base(self)


    def formatter(self):
        """formatter(header_format_counter_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_counter_sptr_formatter(self)


    def format(self, nbytes_in, input, output, info):
        """format(header_format_counter_sptr self, int nbytes_in, unsigned char const * input, swig_int_ptr output, swig_int_ptr info) -> bool"""
        return _digital_swig2.header_format_counter_sptr_format(self, nbytes_in, input, output, info)


    def parse(self, nbits_in, input, info, nbits_processed):
        """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):
        """header_nbits(header_format_counter_sptr self) -> size_t"""
        return _digital_swig2.header_format_counter_sptr_header_nbits(self)


    def header_nbytes(self):
        """header_nbytes(header_format_counter_sptr self) -> size_t"""
        return _digital_swig2.header_format_counter_sptr_header_nbytes(self)

header_format_counter_sptr_swigregister = _digital_swig2.header_format_counter_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::header_format_crc)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::header_format_crc)> self) -> header_format_crc_sptr
        __init__(boost::shared_ptr<(gr::digital::header_format_crc)> self, header_format_crc p) -> header_format_crc_sptr
        """
        this = _digital_swig2.new_header_format_crc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def set_header_num(self, header_num):
        """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):
        """make(header_format_crc_sptr self, std::string const & len_key_name, std::string const & num_key_name) -> header_format_base_sptr"""
        return _digital_swig2.header_format_crc_sptr_make(self, *args, **kwargs)


    def base(self):
        """base(header_format_crc_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_crc_sptr_base(self)


    def formatter(self):
        """formatter(header_format_crc_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_crc_sptr_formatter(self)


    def format(self, nbytes_in, input, output, info):
        """format(header_format_crc_sptr self, int nbytes_in, unsigned char const * input, swig_int_ptr output, swig_int_ptr info) -> bool"""
        return _digital_swig2.header_format_crc_sptr_format(self, nbytes_in, input, output, info)


    def parse(self, nbits_in, input, info, nbits_processed):
        """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):
        """header_nbits(header_format_crc_sptr self) -> size_t"""
        return _digital_swig2.header_format_crc_sptr_header_nbits(self)


    def header_nbytes(self):
        """header_nbytes(header_format_crc_sptr self) -> size_t"""
        return _digital_swig2.header_format_crc_sptr_header_nbytes(self)

header_format_crc_sptr_swigregister = _digital_swig2.header_format_crc_sptr_swigregister
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):
    """Proxy of C++ boost::shared_ptr<(gr::digital::header_format_ofdm)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::digital::header_format_ofdm)> self) -> header_format_ofdm_sptr
        __init__(boost::shared_ptr<(gr::digital::header_format_ofdm)> self, header_format_ofdm p) -> header_format_ofdm_sptr
        """
        this = _digital_swig2.new_header_format_ofdm_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__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
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """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, std::string const & frame_key_name, std::string const & num_key_name, 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):
        """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):
        """base(header_format_ofdm_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_ofdm_sptr_base(self)


    def formatter(self):
        """formatter(header_format_ofdm_sptr self) -> header_format_base_sptr"""
        return _digital_swig2.header_format_ofdm_sptr_formatter(self)


    def format(self, nbytes_in, input, output, info):
        """format(header_format_ofdm_sptr self, int nbytes_in, unsigned char const * input, swig_int_ptr output, swig_int_ptr info) -> bool"""
        return _digital_swig2.header_format_ofdm_sptr_format(self, nbytes_in, input, output, info)


    def parse(self, nbits_in, input, info, nbits_processed):
        """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):
        """header_nbits(header_format_ofdm_sptr self) -> size_t"""
        return _digital_swig2.header_format_ofdm_sptr_header_nbits(self)


    def header_nbytes(self):
        """header_nbytes(header_format_ofdm_sptr self) -> size_t"""
        return _digital_swig2.header_format_ofdm_sptr_header_nbytes(self)

header_format_ofdm_sptr_swigregister = _digital_swig2.header_format_ofdm_sptr_swigregister
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;



