# 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, '_gfdm_swig')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_gfdm_swig')
    _gfdm_swig = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_gfdm_swig', [dirname(__file__)])
        except ImportError:
            import _gfdm_swig
            return _gfdm_swig
        try:
            _mod = imp.load_module('_gfdm_swig', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _gfdm_swig = swig_import_helper()
    del swig_import_helper
else:
    import _gfdm_swig
del _swig_python_version_info

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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



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

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

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

def high_res_timer_epoch():
    """high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _gfdm_swig.high_res_timer_epoch()
class modulator_cc(object):
    """
    modulator_cc modulates an input tagged input stream with subcarrier-wise sorting according to "Generalized Frequency Division Multiplexing: Analysis of an Alternative
    Multi-Carrier Technique for Next Generation Cellular Systems" by N. Michailow Low Complexity, Sparse Frequency Domain Processing
    """

    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, **kwargs):
        """
        make(int nsubcarrier, int ntimeslots, double filter_alpha, int fft_len, int sync_fft_len, std::string const & len_tag_key) -> modulator_cc_sptr

        Return a shared_ptr to a new instance of gfdm::modulator_cc.

        To avoid accidental use of raw pointers, gfdm::modulator_cc's constructor is in a private implementation class. gfdm::modulator_cc::make is the public interface for creating new instances.

        Params: (nsubcarrier, ntimeslots, filter_alpha, fft_len, sync_fft_len, len_tag_key)
        """
        return _gfdm_swig.modulator_cc_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_modulator_cc
    __del__ = lambda self: None
modulator_cc_swigregister = _gfdm_swig.modulator_cc_swigregister
modulator_cc_swigregister(modulator_cc)

def modulator_cc_make(*args, **kwargs):
    """
    modulator_cc_make(int nsubcarrier, int ntimeslots, double filter_alpha, int fft_len, int sync_fft_len, std::string const & len_tag_key) -> modulator_cc_sptr

    Return a shared_ptr to a new instance of gfdm::modulator_cc.

    To avoid accidental use of raw pointers, gfdm::modulator_cc's constructor is in a private implementation class. gfdm::modulator_cc::make is the public interface for creating new instances.

    Params: (nsubcarrier, ntimeslots, filter_alpha, fft_len, sync_fft_len, len_tag_key)
    """
    return _gfdm_swig.modulator_cc_make(*args, **kwargs)

class constellation(object):
    """Proxy of C++ gr::digital::constellation 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__ = _gfdm_swig.delete_constellation
    __del__ = lambda self: None

    def map_to_points(self, value, points):
        """map_to_points(constellation self, unsigned int value, gr_complex * points)"""
        return _gfdm_swig.constellation_map_to_points(self, value, points)


    def map_to_points_v(self, value):
        """map_to_points_v(constellation self, unsigned int value) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_map_to_points_v(self, value)


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


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


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


    def calc_metric(self, sample, metric, type):
        """calc_metric(constellation self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _gfdm_swig.constellation_calc_metric(self, sample, metric, type)


    def calc_euclidean_metric(self, sample, metric):
        """calc_euclidean_metric(constellation self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_calc_euclidean_metric(self, sample, metric)


    def calc_hard_symbol_metric(self, sample, metric):
        """calc_hard_symbol_metric(constellation self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_calc_hard_symbol_metric(self, sample, metric)


    def points(self):
        """points(constellation self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_points(self)


    def s_points(self):
        """s_points(constellation self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_s_points(self)


    def v_points(self):
        """v_points(constellation self) -> gr_vector_vector_complexf"""
        return _gfdm_swig.constellation_v_points(self)


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


    def set_pre_diff_code(self, a):
        """set_pre_diff_code(constellation self, bool a)"""
        return _gfdm_swig.constellation_set_pre_diff_code(self, a)


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


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


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


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


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


    def base(self):
        """base(constellation self) -> constellation_sptr"""
        return _gfdm_swig.constellation_base(self)


    def as_pmt(self):
        """as_pmt(constellation self) -> swig_int_ptr"""
        return _gfdm_swig.constellation_as_pmt(self)


    def gen_soft_dec_lut(self, precision, npwr=1.0):
        """gen_soft_dec_lut(constellation self, int precision, float npwr=1.0)"""
        return _gfdm_swig.constellation_gen_soft_dec_lut(self, precision, npwr)


    def calc_soft_dec(self, sample, npwr=1.0):
        """calc_soft_dec(constellation self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _gfdm_swig.constellation_calc_soft_dec(self, sample, npwr)


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


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


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


    def soft_decision_maker(self, sample):
        """soft_decision_maker(constellation self, gr_complex sample) -> pmt_vector_float"""
        return _gfdm_swig.constellation_soft_decision_maker(self, sample)

constellation_swigregister = _gfdm_swig.constellation_swigregister
constellation_swigregister(constellation)

class constellation_calcdist(constellation):
    """Proxy of C++ gr::digital::constellation_calcdist 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(constell, pre_diff_code, rotational_symmetry, dimensionality, normalize_points=True):
        """make(pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int dimensionality, bool normalize_points=True) -> constellation_calcdist_sptr"""
        return _gfdm_swig.constellation_calcdist_make(constell, pre_diff_code, rotational_symmetry, dimensionality, normalize_points)

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_constellation_calcdist
    __del__ = lambda self: None
constellation_calcdist_swigregister = _gfdm_swig.constellation_calcdist_swigregister
constellation_calcdist_swigregister(constellation_calcdist)

def constellation_calcdist_make(constell, pre_diff_code, rotational_symmetry, dimensionality, normalize_points=True):
    """constellation_calcdist_make(pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int dimensionality, bool normalize_points=True) -> constellation_calcdist_sptr"""
    return _gfdm_swig.constellation_calcdist_make(constell, pre_diff_code, rotational_symmetry, dimensionality, normalize_points)

class constellation_sector(constellation):
    """Proxy of C++ gr::digital::constellation_sector 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__ = _gfdm_swig.delete_constellation_sector
    __del__ = lambda self: None
constellation_sector_swigregister = _gfdm_swig.constellation_sector_swigregister
constellation_sector_swigregister(constellation_sector)

class constellation_rect(constellation_sector):
    """Proxy of C++ gr::digital::constellation_rect 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(constell, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors):
        """make(pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int real_sectors, unsigned int imag_sectors, float width_real_sectors, float width_imag_sectors) -> constellation_rect_sptr"""
        return _gfdm_swig.constellation_rect_make(constell, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors)

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_constellation_rect
    __del__ = lambda self: None
constellation_rect_swigregister = _gfdm_swig.constellation_rect_swigregister
constellation_rect_swigregister(constellation_rect)

def constellation_rect_make(constell, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors):
    """constellation_rect_make(pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int real_sectors, unsigned int imag_sectors, float width_real_sectors, float width_imag_sectors) -> constellation_rect_sptr"""
    return _gfdm_swig.constellation_rect_make(constell, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors)

class constellation_expl_rect(constellation_rect):
    """Proxy of C++ gr::digital::constellation_expl_rect 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(constellation, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors, sector_values):
        """make(pmt_vector_cfloat constellation, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int real_sectors, unsigned int imag_sectors, float width_real_sectors, float width_imag_sectors, std::vector< unsigned int,std::allocator< unsigned int > > sector_values) -> constellation_expl_rect_sptr"""
        return _gfdm_swig.constellation_expl_rect_make(constellation, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors, sector_values)

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_constellation_expl_rect
    __del__ = lambda self: None
constellation_expl_rect_swigregister = _gfdm_swig.constellation_expl_rect_swigregister
constellation_expl_rect_swigregister(constellation_expl_rect)

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

class constellation_psk(constellation_sector):
    """Proxy of C++ gr::digital::constellation_psk 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(constell, pre_diff_code, n_sectors):
        """make(pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int n_sectors) -> constellation_psk_sptr"""
        return _gfdm_swig.constellation_psk_make(constell, pre_diff_code, n_sectors)

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_constellation_psk
    __del__ = lambda self: None
constellation_psk_swigregister = _gfdm_swig.constellation_psk_swigregister
constellation_psk_swigregister(constellation_psk)

def constellation_psk_make(constell, pre_diff_code, n_sectors):
    """constellation_psk_make(pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int n_sectors) -> constellation_psk_sptr"""
    return _gfdm_swig.constellation_psk_make(constell, pre_diff_code, n_sectors)

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

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

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

    def make():
        """make() -> constellation_bpsk_sptr"""
        return _gfdm_swig.constellation_bpsk_make()

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_constellation_bpsk
    __del__ = lambda self: None
constellation_bpsk_swigregister = _gfdm_swig.constellation_bpsk_swigregister
constellation_bpsk_swigregister(constellation_bpsk)

def constellation_bpsk_make():
    """constellation_bpsk_make() -> constellation_bpsk_sptr"""
    return _gfdm_swig.constellation_bpsk_make()

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

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

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

    def make():
        """make() -> constellation_qpsk_sptr"""
        return _gfdm_swig.constellation_qpsk_make()

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_constellation_qpsk
    __del__ = lambda self: None
constellation_qpsk_swigregister = _gfdm_swig.constellation_qpsk_swigregister
constellation_qpsk_swigregister(constellation_qpsk)

def constellation_qpsk_make():
    """constellation_qpsk_make() -> constellation_qpsk_sptr"""
    return _gfdm_swig.constellation_qpsk_make()

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

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

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

    def make():
        """make() -> constellation_dqpsk_sptr"""
        return _gfdm_swig.constellation_dqpsk_make()

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_constellation_dqpsk
    __del__ = lambda self: None
constellation_dqpsk_swigregister = _gfdm_swig.constellation_dqpsk_swigregister
constellation_dqpsk_swigregister(constellation_dqpsk)

def constellation_dqpsk_make():
    """constellation_dqpsk_make() -> constellation_dqpsk_sptr"""
    return _gfdm_swig.constellation_dqpsk_make()

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

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

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

    def make():
        """make() -> constellation_8psk_sptr"""
        return _gfdm_swig.constellation_8psk_make()

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_constellation_8psk
    __del__ = lambda self: None
constellation_8psk_swigregister = _gfdm_swig.constellation_8psk_swigregister
constellation_8psk_swigregister(constellation_8psk)

def constellation_8psk_make():
    """constellation_8psk_make() -> constellation_8psk_sptr"""
    return _gfdm_swig.constellation_8psk_make()

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

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

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

    def make():
        """make() -> constellation_8psk_natural_sptr"""
        return _gfdm_swig.constellation_8psk_natural_make()

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_constellation_8psk_natural
    __del__ = lambda self: None
constellation_8psk_natural_swigregister = _gfdm_swig.constellation_8psk_natural_swigregister
constellation_8psk_natural_swigregister(constellation_8psk_natural)

def constellation_8psk_natural_make():
    """constellation_8psk_natural_make() -> constellation_8psk_natural_sptr"""
    return _gfdm_swig.constellation_8psk_natural_make()

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

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

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

    def make():
        """make() -> constellation_16qam_sptr"""
        return _gfdm_swig.constellation_16qam_make()

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_constellation_16qam
    __del__ = lambda self: None
constellation_16qam_swigregister = _gfdm_swig.constellation_16qam_swigregister
constellation_16qam_swigregister(constellation_16qam)

def constellation_16qam_make():
    """constellation_16qam_make() -> constellation_16qam_sptr"""
    return _gfdm_swig.constellation_16qam_make()

class modulator_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::gfdm::modulator_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::gfdm::modulator_cc)> self) -> modulator_cc_sptr
        __init__(boost::shared_ptr<(gr::gfdm::modulator_cc)> self, modulator_cc p) -> modulator_cc_sptr
        """
        this = _gfdm_swig.new_modulator_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(modulator_cc_sptr self) -> modulator_cc"""
        return _gfdm_swig.modulator_cc_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_modulator_cc_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """
        make(modulator_cc_sptr self, int nsubcarrier, int ntimeslots, double filter_alpha, int fft_len, int sync_fft_len, std::string const & len_tag_key) -> modulator_cc_sptr

        Return a shared_ptr to a new instance of gfdm::modulator_cc.

        To avoid accidental use of raw pointers, gfdm::modulator_cc's constructor is in a private implementation class. gfdm::modulator_cc::make is the public interface for creating new instances.

        Params: (nsubcarrier, ntimeslots, filter_alpha, fft_len, sync_fft_len, len_tag_key)
        """
        return _gfdm_swig.modulator_cc_sptr_make(self, *args, **kwargs)


    def history(self):
        """history(modulator_cc_sptr self) -> unsigned int"""
        return _gfdm_swig.modulator_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(modulator_cc_sptr self, int which, int delay)
        declare_sample_delay(modulator_cc_sptr self, unsigned int delay)
        """
        return _gfdm_swig.modulator_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(modulator_cc_sptr self, int which) -> unsigned int"""
        return _gfdm_swig.modulator_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(modulator_cc_sptr self) -> int"""
        return _gfdm_swig.modulator_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(modulator_cc_sptr self) -> double"""
        return _gfdm_swig.modulator_cc_sptr_relative_rate(self)


    def start(self):
        """start(modulator_cc_sptr self) -> bool"""
        return _gfdm_swig.modulator_cc_sptr_start(self)


    def stop(self):
        """stop(modulator_cc_sptr self) -> bool"""
        return _gfdm_swig.modulator_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(modulator_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _gfdm_swig.modulator_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(modulator_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _gfdm_swig.modulator_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(modulator_cc_sptr self) -> int"""
        return _gfdm_swig.modulator_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(modulator_cc_sptr self, int m)"""
        return _gfdm_swig.modulator_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(modulator_cc_sptr self)"""
        return _gfdm_swig.modulator_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(modulator_cc_sptr self) -> bool"""
        return _gfdm_swig.modulator_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(modulator_cc_sptr self, int m)"""
        return _gfdm_swig.modulator_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(modulator_cc_sptr self) -> int"""
        return _gfdm_swig.modulator_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(modulator_cc_sptr self, int i) -> long"""
        return _gfdm_swig.modulator_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(modulator_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(modulator_cc_sptr self, int port, long max_output_buffer)
        """
        return _gfdm_swig.modulator_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(modulator_cc_sptr self, int i) -> long"""
        return _gfdm_swig.modulator_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(modulator_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(modulator_cc_sptr self, int port, long min_output_buffer)
        """
        return _gfdm_swig.modulator_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(modulator_cc_sptr self) -> float"""
        return _gfdm_swig.modulator_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(modulator_cc_sptr self) -> float"""
        return _gfdm_swig.modulator_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(modulator_cc_sptr self) -> float"""
        return _gfdm_swig.modulator_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(modulator_cc_sptr self) -> float"""
        return _gfdm_swig.modulator_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(modulator_cc_sptr self) -> float"""
        return _gfdm_swig.modulator_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(modulator_cc_sptr self) -> float"""
        return _gfdm_swig.modulator_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(modulator_cc_sptr self, int which) -> float
        pc_input_buffers_full(modulator_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.modulator_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(modulator_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(modulator_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.modulator_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(modulator_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(modulator_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.modulator_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(modulator_cc_sptr self, int which) -> float
        pc_output_buffers_full(modulator_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.modulator_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(modulator_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(modulator_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.modulator_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(modulator_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(modulator_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.modulator_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(modulator_cc_sptr self) -> float"""
        return _gfdm_swig.modulator_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(modulator_cc_sptr self) -> float"""
        return _gfdm_swig.modulator_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(modulator_cc_sptr self) -> float"""
        return _gfdm_swig.modulator_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(modulator_cc_sptr self) -> float"""
        return _gfdm_swig.modulator_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(modulator_cc_sptr self) -> float"""
        return _gfdm_swig.modulator_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(modulator_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _gfdm_swig.modulator_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(modulator_cc_sptr self)"""
        return _gfdm_swig.modulator_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(modulator_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.modulator_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(modulator_cc_sptr self) -> int"""
        return _gfdm_swig.modulator_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(modulator_cc_sptr self) -> int"""
        return _gfdm_swig.modulator_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(modulator_cc_sptr self, int priority) -> int"""
        return _gfdm_swig.modulator_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(modulator_cc_sptr self) -> std::string"""
        return _gfdm_swig.modulator_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(modulator_cc_sptr self) -> std::string"""
        return _gfdm_swig.modulator_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(modulator_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.modulator_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(modulator_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.modulator_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(modulator_cc_sptr self) -> long"""
        return _gfdm_swig.modulator_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(modulator_cc_sptr self) -> basic_block_sptr"""
        return _gfdm_swig.modulator_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(modulator_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _gfdm_swig.modulator_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(modulator_cc_sptr self) -> std::string"""
        return _gfdm_swig.modulator_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(modulator_cc_sptr self, std::string name)"""
        return _gfdm_swig.modulator_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(modulator_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _gfdm_swig.modulator_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(modulator_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.modulator_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(modulator_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.modulator_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(modulator_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _gfdm_swig.modulator_cc_sptr_message_subscribers(self, which_port)

modulator_cc_sptr_swigregister = _gfdm_swig.modulator_cc_sptr_swigregister
modulator_cc_sptr_swigregister(modulator_cc_sptr)


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

class constellation_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::constellation)> 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::constellation)> self) -> constellation_sptr
        __init__(boost::shared_ptr<(gr::digital::constellation)> self, constellation p) -> constellation_sptr
        """
        this = _gfdm_swig.new_constellation_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(constellation_sptr self) -> constellation"""
        return _gfdm_swig.constellation_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_constellation_sptr
    __del__ = lambda self: None

    def map_to_points(self, value, points):
        """map_to_points(constellation_sptr self, unsigned int value, gr_complex * points)"""
        return _gfdm_swig.constellation_sptr_map_to_points(self, value, points)


    def map_to_points_v(self, value):
        """map_to_points_v(constellation_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_sptr_map_to_points_v(self, value)


    def decision_maker(self, sample):
        """decision_maker(constellation_sptr self, gr_complex const * sample) -> unsigned int"""
        return _gfdm_swig.constellation_sptr_decision_maker(self, sample)


    def decision_maker_v(self, sample):
        """decision_maker_v(constellation_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _gfdm_swig.constellation_sptr_decision_maker_v(self, sample)


    def decision_maker_pe(self, sample, phase_error):
        """decision_maker_pe(constellation_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _gfdm_swig.constellation_sptr_decision_maker_pe(self, sample, phase_error)


    def calc_metric(self, sample, metric, type):
        """calc_metric(constellation_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _gfdm_swig.constellation_sptr_calc_metric(self, sample, metric, type)


    def calc_euclidean_metric(self, sample, metric):
        """calc_euclidean_metric(constellation_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_sptr_calc_euclidean_metric(self, sample, metric)


    def calc_hard_symbol_metric(self, sample, metric):
        """calc_hard_symbol_metric(constellation_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_sptr_calc_hard_symbol_metric(self, sample, metric)


    def points(self):
        """points(constellation_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_sptr_points(self)


    def s_points(self):
        """s_points(constellation_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_sptr_s_points(self)


    def v_points(self):
        """v_points(constellation_sptr self) -> gr_vector_vector_complexf"""
        return _gfdm_swig.constellation_sptr_v_points(self)


    def apply_pre_diff_code(self):
        """apply_pre_diff_code(constellation_sptr self) -> bool"""
        return _gfdm_swig.constellation_sptr_apply_pre_diff_code(self)


    def set_pre_diff_code(self, a):
        """set_pre_diff_code(constellation_sptr self, bool a)"""
        return _gfdm_swig.constellation_sptr_set_pre_diff_code(self, a)


    def pre_diff_code(self):
        """pre_diff_code(constellation_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.constellation_sptr_pre_diff_code(self)


    def rotational_symmetry(self):
        """rotational_symmetry(constellation_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_sptr_rotational_symmetry(self)


    def dimensionality(self):
        """dimensionality(constellation_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_sptr_dimensionality(self)


    def bits_per_symbol(self):
        """bits_per_symbol(constellation_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_sptr_bits_per_symbol(self)


    def arity(self):
        """arity(constellation_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_sptr_arity(self)


    def base(self):
        """base(constellation_sptr self) -> constellation_sptr"""
        return _gfdm_swig.constellation_sptr_base(self)


    def as_pmt(self):
        """as_pmt(constellation_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.constellation_sptr_as_pmt(self)


    def gen_soft_dec_lut(self, precision, npwr=1.0):
        """gen_soft_dec_lut(constellation_sptr self, int precision, float npwr=1.0)"""
        return _gfdm_swig.constellation_sptr_gen_soft_dec_lut(self, precision, npwr)


    def calc_soft_dec(self, sample, npwr=1.0):
        """calc_soft_dec(constellation_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _gfdm_swig.constellation_sptr_calc_soft_dec(self, sample, npwr)


    def set_soft_dec_lut(self, soft_dec_lut, precision):
        """set_soft_dec_lut(constellation_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _gfdm_swig.constellation_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)


    def has_soft_dec_lut(self):
        """has_soft_dec_lut(constellation_sptr self) -> bool"""
        return _gfdm_swig.constellation_sptr_has_soft_dec_lut(self)


    def soft_dec_lut(self):
        """soft_dec_lut(constellation_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _gfdm_swig.constellation_sptr_soft_dec_lut(self)


    def soft_decision_maker(self, sample):
        """soft_decision_maker(constellation_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _gfdm_swig.constellation_sptr_soft_decision_maker(self, sample)

constellation_sptr_swigregister = _gfdm_swig.constellation_sptr_swigregister
constellation_sptr_swigregister(constellation_sptr)

class constellation_calcdist_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::constellation_calcdist)> 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::constellation_calcdist)> self) -> constellation_calcdist_sptr
        __init__(boost::shared_ptr<(gr::digital::constellation_calcdist)> self, constellation_calcdist p) -> constellation_calcdist_sptr
        """
        this = _gfdm_swig.new_constellation_calcdist_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(constellation_calcdist_sptr self) -> constellation_calcdist"""
        return _gfdm_swig.constellation_calcdist_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_constellation_calcdist_sptr
    __del__ = lambda self: None

    def make(self, constell, pre_diff_code, rotational_symmetry, dimensionality, normalize_points=True):
        """make(constellation_calcdist_sptr self, pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int dimensionality, bool normalize_points=True) -> constellation_calcdist_sptr"""
        return _gfdm_swig.constellation_calcdist_sptr_make(self, constell, pre_diff_code, rotational_symmetry, dimensionality, normalize_points)


    def map_to_points(self, value, points):
        """map_to_points(constellation_calcdist_sptr self, unsigned int value, gr_complex * points)"""
        return _gfdm_swig.constellation_calcdist_sptr_map_to_points(self, value, points)


    def map_to_points_v(self, value):
        """map_to_points_v(constellation_calcdist_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_calcdist_sptr_map_to_points_v(self, value)


    def decision_maker(self, sample):
        """decision_maker(constellation_calcdist_sptr self, gr_complex const * sample) -> unsigned int"""
        return _gfdm_swig.constellation_calcdist_sptr_decision_maker(self, sample)


    def decision_maker_v(self, sample):
        """decision_maker_v(constellation_calcdist_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _gfdm_swig.constellation_calcdist_sptr_decision_maker_v(self, sample)


    def decision_maker_pe(self, sample, phase_error):
        """decision_maker_pe(constellation_calcdist_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _gfdm_swig.constellation_calcdist_sptr_decision_maker_pe(self, sample, phase_error)


    def calc_metric(self, sample, metric, type):
        """calc_metric(constellation_calcdist_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _gfdm_swig.constellation_calcdist_sptr_calc_metric(self, sample, metric, type)


    def calc_euclidean_metric(self, sample, metric):
        """calc_euclidean_metric(constellation_calcdist_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_calcdist_sptr_calc_euclidean_metric(self, sample, metric)


    def calc_hard_symbol_metric(self, sample, metric):
        """calc_hard_symbol_metric(constellation_calcdist_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_calcdist_sptr_calc_hard_symbol_metric(self, sample, metric)


    def points(self):
        """points(constellation_calcdist_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_calcdist_sptr_points(self)


    def s_points(self):
        """s_points(constellation_calcdist_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_calcdist_sptr_s_points(self)


    def v_points(self):
        """v_points(constellation_calcdist_sptr self) -> gr_vector_vector_complexf"""
        return _gfdm_swig.constellation_calcdist_sptr_v_points(self)


    def apply_pre_diff_code(self):
        """apply_pre_diff_code(constellation_calcdist_sptr self) -> bool"""
        return _gfdm_swig.constellation_calcdist_sptr_apply_pre_diff_code(self)


    def set_pre_diff_code(self, a):
        """set_pre_diff_code(constellation_calcdist_sptr self, bool a)"""
        return _gfdm_swig.constellation_calcdist_sptr_set_pre_diff_code(self, a)


    def pre_diff_code(self):
        """pre_diff_code(constellation_calcdist_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.constellation_calcdist_sptr_pre_diff_code(self)


    def rotational_symmetry(self):
        """rotational_symmetry(constellation_calcdist_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_calcdist_sptr_rotational_symmetry(self)


    def dimensionality(self):
        """dimensionality(constellation_calcdist_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_calcdist_sptr_dimensionality(self)


    def bits_per_symbol(self):
        """bits_per_symbol(constellation_calcdist_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_calcdist_sptr_bits_per_symbol(self)


    def arity(self):
        """arity(constellation_calcdist_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_calcdist_sptr_arity(self)


    def base(self):
        """base(constellation_calcdist_sptr self) -> constellation_sptr"""
        return _gfdm_swig.constellation_calcdist_sptr_base(self)


    def as_pmt(self):
        """as_pmt(constellation_calcdist_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.constellation_calcdist_sptr_as_pmt(self)


    def gen_soft_dec_lut(self, precision, npwr=1.0):
        """gen_soft_dec_lut(constellation_calcdist_sptr self, int precision, float npwr=1.0)"""
        return _gfdm_swig.constellation_calcdist_sptr_gen_soft_dec_lut(self, precision, npwr)


    def calc_soft_dec(self, sample, npwr=1.0):
        """calc_soft_dec(constellation_calcdist_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _gfdm_swig.constellation_calcdist_sptr_calc_soft_dec(self, sample, npwr)


    def set_soft_dec_lut(self, soft_dec_lut, precision):
        """set_soft_dec_lut(constellation_calcdist_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _gfdm_swig.constellation_calcdist_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)


    def has_soft_dec_lut(self):
        """has_soft_dec_lut(constellation_calcdist_sptr self) -> bool"""
        return _gfdm_swig.constellation_calcdist_sptr_has_soft_dec_lut(self)


    def soft_dec_lut(self):
        """soft_dec_lut(constellation_calcdist_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _gfdm_swig.constellation_calcdist_sptr_soft_dec_lut(self)


    def soft_decision_maker(self, sample):
        """soft_decision_maker(constellation_calcdist_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _gfdm_swig.constellation_calcdist_sptr_soft_decision_maker(self, sample)

constellation_calcdist_sptr_swigregister = _gfdm_swig.constellation_calcdist_sptr_swigregister
constellation_calcdist_sptr_swigregister(constellation_calcdist_sptr)


constellation_calcdist_sptr.__repr__ = lambda self: "<constellation calcdist (m=%d)>" % (len(self.points()))
constellation_calcdist = constellation_calcdist.make;

class constellation_rect_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::constellation_rect)> 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::constellation_rect)> self) -> constellation_rect_sptr
        __init__(boost::shared_ptr<(gr::digital::constellation_rect)> self, constellation_rect p) -> constellation_rect_sptr
        """
        this = _gfdm_swig.new_constellation_rect_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(constellation_rect_sptr self) -> constellation_rect"""
        return _gfdm_swig.constellation_rect_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_constellation_rect_sptr
    __del__ = lambda self: None

    def make(self, constell, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors):
        """make(constellation_rect_sptr self, pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int real_sectors, unsigned int imag_sectors, float width_real_sectors, float width_imag_sectors) -> constellation_rect_sptr"""
        return _gfdm_swig.constellation_rect_sptr_make(self, constell, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors)


    def map_to_points(self, value, points):
        """map_to_points(constellation_rect_sptr self, unsigned int value, gr_complex * points)"""
        return _gfdm_swig.constellation_rect_sptr_map_to_points(self, value, points)


    def map_to_points_v(self, value):
        """map_to_points_v(constellation_rect_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_rect_sptr_map_to_points_v(self, value)


    def decision_maker(self, sample):
        """decision_maker(constellation_rect_sptr self, gr_complex const * sample) -> unsigned int"""
        return _gfdm_swig.constellation_rect_sptr_decision_maker(self, sample)


    def decision_maker_v(self, sample):
        """decision_maker_v(constellation_rect_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _gfdm_swig.constellation_rect_sptr_decision_maker_v(self, sample)


    def decision_maker_pe(self, sample, phase_error):
        """decision_maker_pe(constellation_rect_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _gfdm_swig.constellation_rect_sptr_decision_maker_pe(self, sample, phase_error)


    def calc_metric(self, sample, metric, type):
        """calc_metric(constellation_rect_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _gfdm_swig.constellation_rect_sptr_calc_metric(self, sample, metric, type)


    def calc_euclidean_metric(self, sample, metric):
        """calc_euclidean_metric(constellation_rect_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_rect_sptr_calc_euclidean_metric(self, sample, metric)


    def calc_hard_symbol_metric(self, sample, metric):
        """calc_hard_symbol_metric(constellation_rect_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_rect_sptr_calc_hard_symbol_metric(self, sample, metric)


    def points(self):
        """points(constellation_rect_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_rect_sptr_points(self)


    def s_points(self):
        """s_points(constellation_rect_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_rect_sptr_s_points(self)


    def v_points(self):
        """v_points(constellation_rect_sptr self) -> gr_vector_vector_complexf"""
        return _gfdm_swig.constellation_rect_sptr_v_points(self)


    def apply_pre_diff_code(self):
        """apply_pre_diff_code(constellation_rect_sptr self) -> bool"""
        return _gfdm_swig.constellation_rect_sptr_apply_pre_diff_code(self)


    def set_pre_diff_code(self, a):
        """set_pre_diff_code(constellation_rect_sptr self, bool a)"""
        return _gfdm_swig.constellation_rect_sptr_set_pre_diff_code(self, a)


    def pre_diff_code(self):
        """pre_diff_code(constellation_rect_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.constellation_rect_sptr_pre_diff_code(self)


    def rotational_symmetry(self):
        """rotational_symmetry(constellation_rect_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_rect_sptr_rotational_symmetry(self)


    def dimensionality(self):
        """dimensionality(constellation_rect_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_rect_sptr_dimensionality(self)


    def bits_per_symbol(self):
        """bits_per_symbol(constellation_rect_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_rect_sptr_bits_per_symbol(self)


    def arity(self):
        """arity(constellation_rect_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_rect_sptr_arity(self)


    def base(self):
        """base(constellation_rect_sptr self) -> constellation_sptr"""
        return _gfdm_swig.constellation_rect_sptr_base(self)


    def as_pmt(self):
        """as_pmt(constellation_rect_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.constellation_rect_sptr_as_pmt(self)


    def gen_soft_dec_lut(self, precision, npwr=1.0):
        """gen_soft_dec_lut(constellation_rect_sptr self, int precision, float npwr=1.0)"""
        return _gfdm_swig.constellation_rect_sptr_gen_soft_dec_lut(self, precision, npwr)


    def calc_soft_dec(self, sample, npwr=1.0):
        """calc_soft_dec(constellation_rect_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _gfdm_swig.constellation_rect_sptr_calc_soft_dec(self, sample, npwr)


    def set_soft_dec_lut(self, soft_dec_lut, precision):
        """set_soft_dec_lut(constellation_rect_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _gfdm_swig.constellation_rect_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)


    def has_soft_dec_lut(self):
        """has_soft_dec_lut(constellation_rect_sptr self) -> bool"""
        return _gfdm_swig.constellation_rect_sptr_has_soft_dec_lut(self)


    def soft_dec_lut(self):
        """soft_dec_lut(constellation_rect_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _gfdm_swig.constellation_rect_sptr_soft_dec_lut(self)


    def soft_decision_maker(self, sample):
        """soft_decision_maker(constellation_rect_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _gfdm_swig.constellation_rect_sptr_soft_decision_maker(self, sample)

constellation_rect_sptr_swigregister = _gfdm_swig.constellation_rect_sptr_swigregister
constellation_rect_sptr_swigregister(constellation_rect_sptr)


constellation_rect_sptr.__repr__ = lambda self: "<constellation rect (m=%d)>" % (len(self.points()))
constellation_rect = constellation_rect.make;

class constellation_expl_rect_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::constellation_expl_rect)> 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::constellation_expl_rect)> self) -> constellation_expl_rect_sptr
        __init__(boost::shared_ptr<(gr::digital::constellation_expl_rect)> self, constellation_expl_rect p) -> constellation_expl_rect_sptr
        """
        this = _gfdm_swig.new_constellation_expl_rect_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(constellation_expl_rect_sptr self) -> constellation_expl_rect"""
        return _gfdm_swig.constellation_expl_rect_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_constellation_expl_rect_sptr
    __del__ = lambda self: None

    def make(self, constellation, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors, sector_values):
        """make(constellation_expl_rect_sptr self, pmt_vector_cfloat constellation, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int rotational_symmetry, unsigned int real_sectors, unsigned int imag_sectors, float width_real_sectors, float width_imag_sectors, std::vector< unsigned int,std::allocator< unsigned int > > sector_values) -> constellation_expl_rect_sptr"""
        return _gfdm_swig.constellation_expl_rect_sptr_make(self, constellation, pre_diff_code, rotational_symmetry, real_sectors, imag_sectors, width_real_sectors, width_imag_sectors, sector_values)


    def map_to_points(self, value, points):
        """map_to_points(constellation_expl_rect_sptr self, unsigned int value, gr_complex * points)"""
        return _gfdm_swig.constellation_expl_rect_sptr_map_to_points(self, value, points)


    def map_to_points_v(self, value):
        """map_to_points_v(constellation_expl_rect_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_expl_rect_sptr_map_to_points_v(self, value)


    def decision_maker(self, sample):
        """decision_maker(constellation_expl_rect_sptr self, gr_complex const * sample) -> unsigned int"""
        return _gfdm_swig.constellation_expl_rect_sptr_decision_maker(self, sample)


    def decision_maker_v(self, sample):
        """decision_maker_v(constellation_expl_rect_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _gfdm_swig.constellation_expl_rect_sptr_decision_maker_v(self, sample)


    def decision_maker_pe(self, sample, phase_error):
        """decision_maker_pe(constellation_expl_rect_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _gfdm_swig.constellation_expl_rect_sptr_decision_maker_pe(self, sample, phase_error)


    def calc_metric(self, sample, metric, type):
        """calc_metric(constellation_expl_rect_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _gfdm_swig.constellation_expl_rect_sptr_calc_metric(self, sample, metric, type)


    def calc_euclidean_metric(self, sample, metric):
        """calc_euclidean_metric(constellation_expl_rect_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_expl_rect_sptr_calc_euclidean_metric(self, sample, metric)


    def calc_hard_symbol_metric(self, sample, metric):
        """calc_hard_symbol_metric(constellation_expl_rect_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_expl_rect_sptr_calc_hard_symbol_metric(self, sample, metric)


    def points(self):
        """points(constellation_expl_rect_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_expl_rect_sptr_points(self)


    def s_points(self):
        """s_points(constellation_expl_rect_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_expl_rect_sptr_s_points(self)


    def v_points(self):
        """v_points(constellation_expl_rect_sptr self) -> gr_vector_vector_complexf"""
        return _gfdm_swig.constellation_expl_rect_sptr_v_points(self)


    def apply_pre_diff_code(self):
        """apply_pre_diff_code(constellation_expl_rect_sptr self) -> bool"""
        return _gfdm_swig.constellation_expl_rect_sptr_apply_pre_diff_code(self)


    def set_pre_diff_code(self, a):
        """set_pre_diff_code(constellation_expl_rect_sptr self, bool a)"""
        return _gfdm_swig.constellation_expl_rect_sptr_set_pre_diff_code(self, a)


    def pre_diff_code(self):
        """pre_diff_code(constellation_expl_rect_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.constellation_expl_rect_sptr_pre_diff_code(self)


    def rotational_symmetry(self):
        """rotational_symmetry(constellation_expl_rect_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_expl_rect_sptr_rotational_symmetry(self)


    def dimensionality(self):
        """dimensionality(constellation_expl_rect_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_expl_rect_sptr_dimensionality(self)


    def bits_per_symbol(self):
        """bits_per_symbol(constellation_expl_rect_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_expl_rect_sptr_bits_per_symbol(self)


    def arity(self):
        """arity(constellation_expl_rect_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_expl_rect_sptr_arity(self)


    def base(self):
        """base(constellation_expl_rect_sptr self) -> constellation_sptr"""
        return _gfdm_swig.constellation_expl_rect_sptr_base(self)


    def as_pmt(self):
        """as_pmt(constellation_expl_rect_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.constellation_expl_rect_sptr_as_pmt(self)


    def gen_soft_dec_lut(self, precision, npwr=1.0):
        """gen_soft_dec_lut(constellation_expl_rect_sptr self, int precision, float npwr=1.0)"""
        return _gfdm_swig.constellation_expl_rect_sptr_gen_soft_dec_lut(self, precision, npwr)


    def calc_soft_dec(self, sample, npwr=1.0):
        """calc_soft_dec(constellation_expl_rect_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _gfdm_swig.constellation_expl_rect_sptr_calc_soft_dec(self, sample, npwr)


    def set_soft_dec_lut(self, soft_dec_lut, precision):
        """set_soft_dec_lut(constellation_expl_rect_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _gfdm_swig.constellation_expl_rect_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)


    def has_soft_dec_lut(self):
        """has_soft_dec_lut(constellation_expl_rect_sptr self) -> bool"""
        return _gfdm_swig.constellation_expl_rect_sptr_has_soft_dec_lut(self)


    def soft_dec_lut(self):
        """soft_dec_lut(constellation_expl_rect_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _gfdm_swig.constellation_expl_rect_sptr_soft_dec_lut(self)


    def soft_decision_maker(self, sample):
        """soft_decision_maker(constellation_expl_rect_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _gfdm_swig.constellation_expl_rect_sptr_soft_decision_maker(self, sample)

constellation_expl_rect_sptr_swigregister = _gfdm_swig.constellation_expl_rect_sptr_swigregister
constellation_expl_rect_sptr_swigregister(constellation_expl_rect_sptr)


constellation_expl_rect_sptr.__repr__ = lambda self: "<constellation expl rect (m=%d)>" % (len(self.points()))
constellation_expl_rect = constellation_expl_rect.make;

class constellation_psk_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::constellation_psk)> 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::constellation_psk)> self) -> constellation_psk_sptr
        __init__(boost::shared_ptr<(gr::digital::constellation_psk)> self, constellation_psk p) -> constellation_psk_sptr
        """
        this = _gfdm_swig.new_constellation_psk_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(constellation_psk_sptr self) -> constellation_psk"""
        return _gfdm_swig.constellation_psk_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_constellation_psk_sptr
    __del__ = lambda self: None

    def make(self, constell, pre_diff_code, n_sectors):
        """make(constellation_psk_sptr self, pmt_vector_cfloat constell, std::vector< int,std::allocator< int > > pre_diff_code, unsigned int n_sectors) -> constellation_psk_sptr"""
        return _gfdm_swig.constellation_psk_sptr_make(self, constell, pre_diff_code, n_sectors)


    def map_to_points(self, value, points):
        """map_to_points(constellation_psk_sptr self, unsigned int value, gr_complex * points)"""
        return _gfdm_swig.constellation_psk_sptr_map_to_points(self, value, points)


    def map_to_points_v(self, value):
        """map_to_points_v(constellation_psk_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_psk_sptr_map_to_points_v(self, value)


    def decision_maker(self, sample):
        """decision_maker(constellation_psk_sptr self, gr_complex const * sample) -> unsigned int"""
        return _gfdm_swig.constellation_psk_sptr_decision_maker(self, sample)


    def decision_maker_v(self, sample):
        """decision_maker_v(constellation_psk_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _gfdm_swig.constellation_psk_sptr_decision_maker_v(self, sample)


    def decision_maker_pe(self, sample, phase_error):
        """decision_maker_pe(constellation_psk_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _gfdm_swig.constellation_psk_sptr_decision_maker_pe(self, sample, phase_error)


    def calc_metric(self, sample, metric, type):
        """calc_metric(constellation_psk_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _gfdm_swig.constellation_psk_sptr_calc_metric(self, sample, metric, type)


    def calc_euclidean_metric(self, sample, metric):
        """calc_euclidean_metric(constellation_psk_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_psk_sptr_calc_euclidean_metric(self, sample, metric)


    def calc_hard_symbol_metric(self, sample, metric):
        """calc_hard_symbol_metric(constellation_psk_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_psk_sptr_calc_hard_symbol_metric(self, sample, metric)


    def points(self):
        """points(constellation_psk_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_psk_sptr_points(self)


    def s_points(self):
        """s_points(constellation_psk_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_psk_sptr_s_points(self)


    def v_points(self):
        """v_points(constellation_psk_sptr self) -> gr_vector_vector_complexf"""
        return _gfdm_swig.constellation_psk_sptr_v_points(self)


    def apply_pre_diff_code(self):
        """apply_pre_diff_code(constellation_psk_sptr self) -> bool"""
        return _gfdm_swig.constellation_psk_sptr_apply_pre_diff_code(self)


    def set_pre_diff_code(self, a):
        """set_pre_diff_code(constellation_psk_sptr self, bool a)"""
        return _gfdm_swig.constellation_psk_sptr_set_pre_diff_code(self, a)


    def pre_diff_code(self):
        """pre_diff_code(constellation_psk_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.constellation_psk_sptr_pre_diff_code(self)


    def rotational_symmetry(self):
        """rotational_symmetry(constellation_psk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_psk_sptr_rotational_symmetry(self)


    def dimensionality(self):
        """dimensionality(constellation_psk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_psk_sptr_dimensionality(self)


    def bits_per_symbol(self):
        """bits_per_symbol(constellation_psk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_psk_sptr_bits_per_symbol(self)


    def arity(self):
        """arity(constellation_psk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_psk_sptr_arity(self)


    def base(self):
        """base(constellation_psk_sptr self) -> constellation_sptr"""
        return _gfdm_swig.constellation_psk_sptr_base(self)


    def as_pmt(self):
        """as_pmt(constellation_psk_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.constellation_psk_sptr_as_pmt(self)


    def gen_soft_dec_lut(self, precision, npwr=1.0):
        """gen_soft_dec_lut(constellation_psk_sptr self, int precision, float npwr=1.0)"""
        return _gfdm_swig.constellation_psk_sptr_gen_soft_dec_lut(self, precision, npwr)


    def calc_soft_dec(self, sample, npwr=1.0):
        """calc_soft_dec(constellation_psk_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _gfdm_swig.constellation_psk_sptr_calc_soft_dec(self, sample, npwr)


    def set_soft_dec_lut(self, soft_dec_lut, precision):
        """set_soft_dec_lut(constellation_psk_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _gfdm_swig.constellation_psk_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)


    def has_soft_dec_lut(self):
        """has_soft_dec_lut(constellation_psk_sptr self) -> bool"""
        return _gfdm_swig.constellation_psk_sptr_has_soft_dec_lut(self)


    def soft_dec_lut(self):
        """soft_dec_lut(constellation_psk_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _gfdm_swig.constellation_psk_sptr_soft_dec_lut(self)


    def soft_decision_maker(self, sample):
        """soft_decision_maker(constellation_psk_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _gfdm_swig.constellation_psk_sptr_soft_decision_maker(self, sample)

constellation_psk_sptr_swigregister = _gfdm_swig.constellation_psk_sptr_swigregister
constellation_psk_sptr_swigregister(constellation_psk_sptr)


constellation_psk_sptr.__repr__ = lambda self: "<constellation PSK (m=%d)>" % (len(self.points()))
constellation_psk = constellation_psk.make;

class constellation_bpsk_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::constellation_bpsk)> 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::constellation_bpsk)> self) -> constellation_bpsk_sptr
        __init__(boost::shared_ptr<(gr::digital::constellation_bpsk)> self, constellation_bpsk p) -> constellation_bpsk_sptr
        """
        this = _gfdm_swig.new_constellation_bpsk_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(constellation_bpsk_sptr self) -> constellation_bpsk"""
        return _gfdm_swig.constellation_bpsk_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_constellation_bpsk_sptr
    __del__ = lambda self: None

    def make(self):
        """make(constellation_bpsk_sptr self) -> constellation_bpsk_sptr"""
        return _gfdm_swig.constellation_bpsk_sptr_make(self)


    def map_to_points(self, value, points):
        """map_to_points(constellation_bpsk_sptr self, unsigned int value, gr_complex * points)"""
        return _gfdm_swig.constellation_bpsk_sptr_map_to_points(self, value, points)


    def map_to_points_v(self, value):
        """map_to_points_v(constellation_bpsk_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_bpsk_sptr_map_to_points_v(self, value)


    def decision_maker(self, sample):
        """decision_maker(constellation_bpsk_sptr self, gr_complex const * sample) -> unsigned int"""
        return _gfdm_swig.constellation_bpsk_sptr_decision_maker(self, sample)


    def decision_maker_v(self, sample):
        """decision_maker_v(constellation_bpsk_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _gfdm_swig.constellation_bpsk_sptr_decision_maker_v(self, sample)


    def decision_maker_pe(self, sample, phase_error):
        """decision_maker_pe(constellation_bpsk_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _gfdm_swig.constellation_bpsk_sptr_decision_maker_pe(self, sample, phase_error)


    def calc_metric(self, sample, metric, type):
        """calc_metric(constellation_bpsk_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _gfdm_swig.constellation_bpsk_sptr_calc_metric(self, sample, metric, type)


    def calc_euclidean_metric(self, sample, metric):
        """calc_euclidean_metric(constellation_bpsk_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_bpsk_sptr_calc_euclidean_metric(self, sample, metric)


    def calc_hard_symbol_metric(self, sample, metric):
        """calc_hard_symbol_metric(constellation_bpsk_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_bpsk_sptr_calc_hard_symbol_metric(self, sample, metric)


    def points(self):
        """points(constellation_bpsk_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_bpsk_sptr_points(self)


    def s_points(self):
        """s_points(constellation_bpsk_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_bpsk_sptr_s_points(self)


    def v_points(self):
        """v_points(constellation_bpsk_sptr self) -> gr_vector_vector_complexf"""
        return _gfdm_swig.constellation_bpsk_sptr_v_points(self)


    def apply_pre_diff_code(self):
        """apply_pre_diff_code(constellation_bpsk_sptr self) -> bool"""
        return _gfdm_swig.constellation_bpsk_sptr_apply_pre_diff_code(self)


    def set_pre_diff_code(self, a):
        """set_pre_diff_code(constellation_bpsk_sptr self, bool a)"""
        return _gfdm_swig.constellation_bpsk_sptr_set_pre_diff_code(self, a)


    def pre_diff_code(self):
        """pre_diff_code(constellation_bpsk_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.constellation_bpsk_sptr_pre_diff_code(self)


    def rotational_symmetry(self):
        """rotational_symmetry(constellation_bpsk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_bpsk_sptr_rotational_symmetry(self)


    def dimensionality(self):
        """dimensionality(constellation_bpsk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_bpsk_sptr_dimensionality(self)


    def bits_per_symbol(self):
        """bits_per_symbol(constellation_bpsk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_bpsk_sptr_bits_per_symbol(self)


    def arity(self):
        """arity(constellation_bpsk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_bpsk_sptr_arity(self)


    def base(self):
        """base(constellation_bpsk_sptr self) -> constellation_sptr"""
        return _gfdm_swig.constellation_bpsk_sptr_base(self)


    def as_pmt(self):
        """as_pmt(constellation_bpsk_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.constellation_bpsk_sptr_as_pmt(self)


    def gen_soft_dec_lut(self, precision, npwr=1.0):
        """gen_soft_dec_lut(constellation_bpsk_sptr self, int precision, float npwr=1.0)"""
        return _gfdm_swig.constellation_bpsk_sptr_gen_soft_dec_lut(self, precision, npwr)


    def calc_soft_dec(self, sample, npwr=1.0):
        """calc_soft_dec(constellation_bpsk_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _gfdm_swig.constellation_bpsk_sptr_calc_soft_dec(self, sample, npwr)


    def set_soft_dec_lut(self, soft_dec_lut, precision):
        """set_soft_dec_lut(constellation_bpsk_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _gfdm_swig.constellation_bpsk_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)


    def has_soft_dec_lut(self):
        """has_soft_dec_lut(constellation_bpsk_sptr self) -> bool"""
        return _gfdm_swig.constellation_bpsk_sptr_has_soft_dec_lut(self)


    def soft_dec_lut(self):
        """soft_dec_lut(constellation_bpsk_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _gfdm_swig.constellation_bpsk_sptr_soft_dec_lut(self)


    def soft_decision_maker(self, sample):
        """soft_decision_maker(constellation_bpsk_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _gfdm_swig.constellation_bpsk_sptr_soft_decision_maker(self, sample)

constellation_bpsk_sptr_swigregister = _gfdm_swig.constellation_bpsk_sptr_swigregister
constellation_bpsk_sptr_swigregister(constellation_bpsk_sptr)


constellation_bpsk_sptr.__repr__ = lambda self: "<constellation BPSK>"
constellation_bpsk = constellation_bpsk.make;

class constellation_qpsk_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::constellation_qpsk)> 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::constellation_qpsk)> self) -> constellation_qpsk_sptr
        __init__(boost::shared_ptr<(gr::digital::constellation_qpsk)> self, constellation_qpsk p) -> constellation_qpsk_sptr
        """
        this = _gfdm_swig.new_constellation_qpsk_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(constellation_qpsk_sptr self) -> constellation_qpsk"""
        return _gfdm_swig.constellation_qpsk_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_constellation_qpsk_sptr
    __del__ = lambda self: None

    def make(self):
        """make(constellation_qpsk_sptr self) -> constellation_qpsk_sptr"""
        return _gfdm_swig.constellation_qpsk_sptr_make(self)


    def map_to_points(self, value, points):
        """map_to_points(constellation_qpsk_sptr self, unsigned int value, gr_complex * points)"""
        return _gfdm_swig.constellation_qpsk_sptr_map_to_points(self, value, points)


    def map_to_points_v(self, value):
        """map_to_points_v(constellation_qpsk_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_qpsk_sptr_map_to_points_v(self, value)


    def decision_maker(self, sample):
        """decision_maker(constellation_qpsk_sptr self, gr_complex const * sample) -> unsigned int"""
        return _gfdm_swig.constellation_qpsk_sptr_decision_maker(self, sample)


    def decision_maker_v(self, sample):
        """decision_maker_v(constellation_qpsk_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _gfdm_swig.constellation_qpsk_sptr_decision_maker_v(self, sample)


    def decision_maker_pe(self, sample, phase_error):
        """decision_maker_pe(constellation_qpsk_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _gfdm_swig.constellation_qpsk_sptr_decision_maker_pe(self, sample, phase_error)


    def calc_metric(self, sample, metric, type):
        """calc_metric(constellation_qpsk_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _gfdm_swig.constellation_qpsk_sptr_calc_metric(self, sample, metric, type)


    def calc_euclidean_metric(self, sample, metric):
        """calc_euclidean_metric(constellation_qpsk_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_qpsk_sptr_calc_euclidean_metric(self, sample, metric)


    def calc_hard_symbol_metric(self, sample, metric):
        """calc_hard_symbol_metric(constellation_qpsk_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_qpsk_sptr_calc_hard_symbol_metric(self, sample, metric)


    def points(self):
        """points(constellation_qpsk_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_qpsk_sptr_points(self)


    def s_points(self):
        """s_points(constellation_qpsk_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_qpsk_sptr_s_points(self)


    def v_points(self):
        """v_points(constellation_qpsk_sptr self) -> gr_vector_vector_complexf"""
        return _gfdm_swig.constellation_qpsk_sptr_v_points(self)


    def apply_pre_diff_code(self):
        """apply_pre_diff_code(constellation_qpsk_sptr self) -> bool"""
        return _gfdm_swig.constellation_qpsk_sptr_apply_pre_diff_code(self)


    def set_pre_diff_code(self, a):
        """set_pre_diff_code(constellation_qpsk_sptr self, bool a)"""
        return _gfdm_swig.constellation_qpsk_sptr_set_pre_diff_code(self, a)


    def pre_diff_code(self):
        """pre_diff_code(constellation_qpsk_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.constellation_qpsk_sptr_pre_diff_code(self)


    def rotational_symmetry(self):
        """rotational_symmetry(constellation_qpsk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_qpsk_sptr_rotational_symmetry(self)


    def dimensionality(self):
        """dimensionality(constellation_qpsk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_qpsk_sptr_dimensionality(self)


    def bits_per_symbol(self):
        """bits_per_symbol(constellation_qpsk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_qpsk_sptr_bits_per_symbol(self)


    def arity(self):
        """arity(constellation_qpsk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_qpsk_sptr_arity(self)


    def base(self):
        """base(constellation_qpsk_sptr self) -> constellation_sptr"""
        return _gfdm_swig.constellation_qpsk_sptr_base(self)


    def as_pmt(self):
        """as_pmt(constellation_qpsk_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.constellation_qpsk_sptr_as_pmt(self)


    def gen_soft_dec_lut(self, precision, npwr=1.0):
        """gen_soft_dec_lut(constellation_qpsk_sptr self, int precision, float npwr=1.0)"""
        return _gfdm_swig.constellation_qpsk_sptr_gen_soft_dec_lut(self, precision, npwr)


    def calc_soft_dec(self, sample, npwr=1.0):
        """calc_soft_dec(constellation_qpsk_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _gfdm_swig.constellation_qpsk_sptr_calc_soft_dec(self, sample, npwr)


    def set_soft_dec_lut(self, soft_dec_lut, precision):
        """set_soft_dec_lut(constellation_qpsk_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _gfdm_swig.constellation_qpsk_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)


    def has_soft_dec_lut(self):
        """has_soft_dec_lut(constellation_qpsk_sptr self) -> bool"""
        return _gfdm_swig.constellation_qpsk_sptr_has_soft_dec_lut(self)


    def soft_dec_lut(self):
        """soft_dec_lut(constellation_qpsk_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _gfdm_swig.constellation_qpsk_sptr_soft_dec_lut(self)


    def soft_decision_maker(self, sample):
        """soft_decision_maker(constellation_qpsk_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _gfdm_swig.constellation_qpsk_sptr_soft_decision_maker(self, sample)

constellation_qpsk_sptr_swigregister = _gfdm_swig.constellation_qpsk_sptr_swigregister
constellation_qpsk_sptr_swigregister(constellation_qpsk_sptr)


constellation_qpsk_sptr.__repr__ = lambda self: "<constellation QPSK>"
constellation_qpsk = constellation_qpsk.make;

class constellation_dqpsk_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::constellation_dqpsk)> 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::constellation_dqpsk)> self) -> constellation_dqpsk_sptr
        __init__(boost::shared_ptr<(gr::digital::constellation_dqpsk)> self, constellation_dqpsk p) -> constellation_dqpsk_sptr
        """
        this = _gfdm_swig.new_constellation_dqpsk_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(constellation_dqpsk_sptr self) -> constellation_dqpsk"""
        return _gfdm_swig.constellation_dqpsk_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_constellation_dqpsk_sptr
    __del__ = lambda self: None

    def make(self):
        """make(constellation_dqpsk_sptr self) -> constellation_dqpsk_sptr"""
        return _gfdm_swig.constellation_dqpsk_sptr_make(self)


    def map_to_points(self, value, points):
        """map_to_points(constellation_dqpsk_sptr self, unsigned int value, gr_complex * points)"""
        return _gfdm_swig.constellation_dqpsk_sptr_map_to_points(self, value, points)


    def map_to_points_v(self, value):
        """map_to_points_v(constellation_dqpsk_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_dqpsk_sptr_map_to_points_v(self, value)


    def decision_maker(self, sample):
        """decision_maker(constellation_dqpsk_sptr self, gr_complex const * sample) -> unsigned int"""
        return _gfdm_swig.constellation_dqpsk_sptr_decision_maker(self, sample)


    def decision_maker_v(self, sample):
        """decision_maker_v(constellation_dqpsk_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _gfdm_swig.constellation_dqpsk_sptr_decision_maker_v(self, sample)


    def decision_maker_pe(self, sample, phase_error):
        """decision_maker_pe(constellation_dqpsk_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _gfdm_swig.constellation_dqpsk_sptr_decision_maker_pe(self, sample, phase_error)


    def calc_metric(self, sample, metric, type):
        """calc_metric(constellation_dqpsk_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _gfdm_swig.constellation_dqpsk_sptr_calc_metric(self, sample, metric, type)


    def calc_euclidean_metric(self, sample, metric):
        """calc_euclidean_metric(constellation_dqpsk_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_dqpsk_sptr_calc_euclidean_metric(self, sample, metric)


    def calc_hard_symbol_metric(self, sample, metric):
        """calc_hard_symbol_metric(constellation_dqpsk_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_dqpsk_sptr_calc_hard_symbol_metric(self, sample, metric)


    def points(self):
        """points(constellation_dqpsk_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_dqpsk_sptr_points(self)


    def s_points(self):
        """s_points(constellation_dqpsk_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_dqpsk_sptr_s_points(self)


    def v_points(self):
        """v_points(constellation_dqpsk_sptr self) -> gr_vector_vector_complexf"""
        return _gfdm_swig.constellation_dqpsk_sptr_v_points(self)


    def apply_pre_diff_code(self):
        """apply_pre_diff_code(constellation_dqpsk_sptr self) -> bool"""
        return _gfdm_swig.constellation_dqpsk_sptr_apply_pre_diff_code(self)


    def set_pre_diff_code(self, a):
        """set_pre_diff_code(constellation_dqpsk_sptr self, bool a)"""
        return _gfdm_swig.constellation_dqpsk_sptr_set_pre_diff_code(self, a)


    def pre_diff_code(self):
        """pre_diff_code(constellation_dqpsk_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.constellation_dqpsk_sptr_pre_diff_code(self)


    def rotational_symmetry(self):
        """rotational_symmetry(constellation_dqpsk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_dqpsk_sptr_rotational_symmetry(self)


    def dimensionality(self):
        """dimensionality(constellation_dqpsk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_dqpsk_sptr_dimensionality(self)


    def bits_per_symbol(self):
        """bits_per_symbol(constellation_dqpsk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_dqpsk_sptr_bits_per_symbol(self)


    def arity(self):
        """arity(constellation_dqpsk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_dqpsk_sptr_arity(self)


    def base(self):
        """base(constellation_dqpsk_sptr self) -> constellation_sptr"""
        return _gfdm_swig.constellation_dqpsk_sptr_base(self)


    def as_pmt(self):
        """as_pmt(constellation_dqpsk_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.constellation_dqpsk_sptr_as_pmt(self)


    def gen_soft_dec_lut(self, precision, npwr=1.0):
        """gen_soft_dec_lut(constellation_dqpsk_sptr self, int precision, float npwr=1.0)"""
        return _gfdm_swig.constellation_dqpsk_sptr_gen_soft_dec_lut(self, precision, npwr)


    def calc_soft_dec(self, sample, npwr=1.0):
        """calc_soft_dec(constellation_dqpsk_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _gfdm_swig.constellation_dqpsk_sptr_calc_soft_dec(self, sample, npwr)


    def set_soft_dec_lut(self, soft_dec_lut, precision):
        """set_soft_dec_lut(constellation_dqpsk_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _gfdm_swig.constellation_dqpsk_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)


    def has_soft_dec_lut(self):
        """has_soft_dec_lut(constellation_dqpsk_sptr self) -> bool"""
        return _gfdm_swig.constellation_dqpsk_sptr_has_soft_dec_lut(self)


    def soft_dec_lut(self):
        """soft_dec_lut(constellation_dqpsk_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _gfdm_swig.constellation_dqpsk_sptr_soft_dec_lut(self)


    def soft_decision_maker(self, sample):
        """soft_decision_maker(constellation_dqpsk_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _gfdm_swig.constellation_dqpsk_sptr_soft_decision_maker(self, sample)

constellation_dqpsk_sptr_swigregister = _gfdm_swig.constellation_dqpsk_sptr_swigregister
constellation_dqpsk_sptr_swigregister(constellation_dqpsk_sptr)


constellation_dqpsk_sptr.__repr__ = lambda self: "<constellation DQPSK>"
constellation_dqpsk = constellation_dqpsk.make;

class constellation_8psk_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::constellation_8psk)> 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::constellation_8psk)> self) -> constellation_8psk_sptr
        __init__(boost::shared_ptr<(gr::digital::constellation_8psk)> self, constellation_8psk p) -> constellation_8psk_sptr
        """
        this = _gfdm_swig.new_constellation_8psk_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(constellation_8psk_sptr self) -> constellation_8psk"""
        return _gfdm_swig.constellation_8psk_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_constellation_8psk_sptr
    __del__ = lambda self: None

    def make(self):
        """make(constellation_8psk_sptr self) -> constellation_8psk_sptr"""
        return _gfdm_swig.constellation_8psk_sptr_make(self)


    def map_to_points(self, value, points):
        """map_to_points(constellation_8psk_sptr self, unsigned int value, gr_complex * points)"""
        return _gfdm_swig.constellation_8psk_sptr_map_to_points(self, value, points)


    def map_to_points_v(self, value):
        """map_to_points_v(constellation_8psk_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_8psk_sptr_map_to_points_v(self, value)


    def decision_maker(self, sample):
        """decision_maker(constellation_8psk_sptr self, gr_complex const * sample) -> unsigned int"""
        return _gfdm_swig.constellation_8psk_sptr_decision_maker(self, sample)


    def decision_maker_v(self, sample):
        """decision_maker_v(constellation_8psk_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _gfdm_swig.constellation_8psk_sptr_decision_maker_v(self, sample)


    def decision_maker_pe(self, sample, phase_error):
        """decision_maker_pe(constellation_8psk_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _gfdm_swig.constellation_8psk_sptr_decision_maker_pe(self, sample, phase_error)


    def calc_metric(self, sample, metric, type):
        """calc_metric(constellation_8psk_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _gfdm_swig.constellation_8psk_sptr_calc_metric(self, sample, metric, type)


    def calc_euclidean_metric(self, sample, metric):
        """calc_euclidean_metric(constellation_8psk_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_8psk_sptr_calc_euclidean_metric(self, sample, metric)


    def calc_hard_symbol_metric(self, sample, metric):
        """calc_hard_symbol_metric(constellation_8psk_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_8psk_sptr_calc_hard_symbol_metric(self, sample, metric)


    def points(self):
        """points(constellation_8psk_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_8psk_sptr_points(self)


    def s_points(self):
        """s_points(constellation_8psk_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_8psk_sptr_s_points(self)


    def v_points(self):
        """v_points(constellation_8psk_sptr self) -> gr_vector_vector_complexf"""
        return _gfdm_swig.constellation_8psk_sptr_v_points(self)


    def apply_pre_diff_code(self):
        """apply_pre_diff_code(constellation_8psk_sptr self) -> bool"""
        return _gfdm_swig.constellation_8psk_sptr_apply_pre_diff_code(self)


    def set_pre_diff_code(self, a):
        """set_pre_diff_code(constellation_8psk_sptr self, bool a)"""
        return _gfdm_swig.constellation_8psk_sptr_set_pre_diff_code(self, a)


    def pre_diff_code(self):
        """pre_diff_code(constellation_8psk_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.constellation_8psk_sptr_pre_diff_code(self)


    def rotational_symmetry(self):
        """rotational_symmetry(constellation_8psk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_8psk_sptr_rotational_symmetry(self)


    def dimensionality(self):
        """dimensionality(constellation_8psk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_8psk_sptr_dimensionality(self)


    def bits_per_symbol(self):
        """bits_per_symbol(constellation_8psk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_8psk_sptr_bits_per_symbol(self)


    def arity(self):
        """arity(constellation_8psk_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_8psk_sptr_arity(self)


    def base(self):
        """base(constellation_8psk_sptr self) -> constellation_sptr"""
        return _gfdm_swig.constellation_8psk_sptr_base(self)


    def as_pmt(self):
        """as_pmt(constellation_8psk_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.constellation_8psk_sptr_as_pmt(self)


    def gen_soft_dec_lut(self, precision, npwr=1.0):
        """gen_soft_dec_lut(constellation_8psk_sptr self, int precision, float npwr=1.0)"""
        return _gfdm_swig.constellation_8psk_sptr_gen_soft_dec_lut(self, precision, npwr)


    def calc_soft_dec(self, sample, npwr=1.0):
        """calc_soft_dec(constellation_8psk_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _gfdm_swig.constellation_8psk_sptr_calc_soft_dec(self, sample, npwr)


    def set_soft_dec_lut(self, soft_dec_lut, precision):
        """set_soft_dec_lut(constellation_8psk_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _gfdm_swig.constellation_8psk_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)


    def has_soft_dec_lut(self):
        """has_soft_dec_lut(constellation_8psk_sptr self) -> bool"""
        return _gfdm_swig.constellation_8psk_sptr_has_soft_dec_lut(self)


    def soft_dec_lut(self):
        """soft_dec_lut(constellation_8psk_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _gfdm_swig.constellation_8psk_sptr_soft_dec_lut(self)


    def soft_decision_maker(self, sample):
        """soft_decision_maker(constellation_8psk_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _gfdm_swig.constellation_8psk_sptr_soft_decision_maker(self, sample)

constellation_8psk_sptr_swigregister = _gfdm_swig.constellation_8psk_sptr_swigregister
constellation_8psk_sptr_swigregister(constellation_8psk_sptr)


constellation_8psk_sptr.__repr__ = lambda self: "<constellation 8PSK>"
constellation_8psk = constellation_8psk.make;

class constellation_8psk_natural_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::constellation_8psk_natural)> 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::constellation_8psk_natural)> self) -> constellation_8psk_natural_sptr
        __init__(boost::shared_ptr<(gr::digital::constellation_8psk_natural)> self, constellation_8psk_natural p) -> constellation_8psk_natural_sptr
        """
        this = _gfdm_swig.new_constellation_8psk_natural_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(constellation_8psk_natural_sptr self) -> constellation_8psk_natural"""
        return _gfdm_swig.constellation_8psk_natural_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_constellation_8psk_natural_sptr
    __del__ = lambda self: None

    def make(self):
        """make(constellation_8psk_natural_sptr self) -> constellation_8psk_natural_sptr"""
        return _gfdm_swig.constellation_8psk_natural_sptr_make(self)


    def map_to_points(self, value, points):
        """map_to_points(constellation_8psk_natural_sptr self, unsigned int value, gr_complex * points)"""
        return _gfdm_swig.constellation_8psk_natural_sptr_map_to_points(self, value, points)


    def map_to_points_v(self, value):
        """map_to_points_v(constellation_8psk_natural_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_8psk_natural_sptr_map_to_points_v(self, value)


    def decision_maker(self, sample):
        """decision_maker(constellation_8psk_natural_sptr self, gr_complex const * sample) -> unsigned int"""
        return _gfdm_swig.constellation_8psk_natural_sptr_decision_maker(self, sample)


    def decision_maker_v(self, sample):
        """decision_maker_v(constellation_8psk_natural_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _gfdm_swig.constellation_8psk_natural_sptr_decision_maker_v(self, sample)


    def decision_maker_pe(self, sample, phase_error):
        """decision_maker_pe(constellation_8psk_natural_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _gfdm_swig.constellation_8psk_natural_sptr_decision_maker_pe(self, sample, phase_error)


    def calc_metric(self, sample, metric, type):
        """calc_metric(constellation_8psk_natural_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _gfdm_swig.constellation_8psk_natural_sptr_calc_metric(self, sample, metric, type)


    def calc_euclidean_metric(self, sample, metric):
        """calc_euclidean_metric(constellation_8psk_natural_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_8psk_natural_sptr_calc_euclidean_metric(self, sample, metric)


    def calc_hard_symbol_metric(self, sample, metric):
        """calc_hard_symbol_metric(constellation_8psk_natural_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_8psk_natural_sptr_calc_hard_symbol_metric(self, sample, metric)


    def points(self):
        """points(constellation_8psk_natural_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_8psk_natural_sptr_points(self)


    def s_points(self):
        """s_points(constellation_8psk_natural_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_8psk_natural_sptr_s_points(self)


    def v_points(self):
        """v_points(constellation_8psk_natural_sptr self) -> gr_vector_vector_complexf"""
        return _gfdm_swig.constellation_8psk_natural_sptr_v_points(self)


    def apply_pre_diff_code(self):
        """apply_pre_diff_code(constellation_8psk_natural_sptr self) -> bool"""
        return _gfdm_swig.constellation_8psk_natural_sptr_apply_pre_diff_code(self)


    def set_pre_diff_code(self, a):
        """set_pre_diff_code(constellation_8psk_natural_sptr self, bool a)"""
        return _gfdm_swig.constellation_8psk_natural_sptr_set_pre_diff_code(self, a)


    def pre_diff_code(self):
        """pre_diff_code(constellation_8psk_natural_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.constellation_8psk_natural_sptr_pre_diff_code(self)


    def rotational_symmetry(self):
        """rotational_symmetry(constellation_8psk_natural_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_8psk_natural_sptr_rotational_symmetry(self)


    def dimensionality(self):
        """dimensionality(constellation_8psk_natural_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_8psk_natural_sptr_dimensionality(self)


    def bits_per_symbol(self):
        """bits_per_symbol(constellation_8psk_natural_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_8psk_natural_sptr_bits_per_symbol(self)


    def arity(self):
        """arity(constellation_8psk_natural_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_8psk_natural_sptr_arity(self)


    def base(self):
        """base(constellation_8psk_natural_sptr self) -> constellation_sptr"""
        return _gfdm_swig.constellation_8psk_natural_sptr_base(self)


    def as_pmt(self):
        """as_pmt(constellation_8psk_natural_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.constellation_8psk_natural_sptr_as_pmt(self)


    def gen_soft_dec_lut(self, precision, npwr=1.0):
        """gen_soft_dec_lut(constellation_8psk_natural_sptr self, int precision, float npwr=1.0)"""
        return _gfdm_swig.constellation_8psk_natural_sptr_gen_soft_dec_lut(self, precision, npwr)


    def calc_soft_dec(self, sample, npwr=1.0):
        """calc_soft_dec(constellation_8psk_natural_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _gfdm_swig.constellation_8psk_natural_sptr_calc_soft_dec(self, sample, npwr)


    def set_soft_dec_lut(self, soft_dec_lut, precision):
        """set_soft_dec_lut(constellation_8psk_natural_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _gfdm_swig.constellation_8psk_natural_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)


    def has_soft_dec_lut(self):
        """has_soft_dec_lut(constellation_8psk_natural_sptr self) -> bool"""
        return _gfdm_swig.constellation_8psk_natural_sptr_has_soft_dec_lut(self)


    def soft_dec_lut(self):
        """soft_dec_lut(constellation_8psk_natural_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _gfdm_swig.constellation_8psk_natural_sptr_soft_dec_lut(self)


    def soft_decision_maker(self, sample):
        """soft_decision_maker(constellation_8psk_natural_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _gfdm_swig.constellation_8psk_natural_sptr_soft_decision_maker(self, sample)

constellation_8psk_natural_sptr_swigregister = _gfdm_swig.constellation_8psk_natural_sptr_swigregister
constellation_8psk_natural_sptr_swigregister(constellation_8psk_natural_sptr)


constellation_8psk_natural_sptr.__repr__ = lambda self: "<constellation 8PSK_natural>"
constellation_8psk_natural = constellation_8psk_natural.make;

class constellation_16qam_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::digital::constellation_16qam)> 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::constellation_16qam)> self) -> constellation_16qam_sptr
        __init__(boost::shared_ptr<(gr::digital::constellation_16qam)> self, constellation_16qam p) -> constellation_16qam_sptr
        """
        this = _gfdm_swig.new_constellation_16qam_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(constellation_16qam_sptr self) -> constellation_16qam"""
        return _gfdm_swig.constellation_16qam_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_constellation_16qam_sptr
    __del__ = lambda self: None

    def make(self):
        """make(constellation_16qam_sptr self) -> constellation_16qam_sptr"""
        return _gfdm_swig.constellation_16qam_sptr_make(self)


    def map_to_points(self, value, points):
        """map_to_points(constellation_16qam_sptr self, unsigned int value, gr_complex * points)"""
        return _gfdm_swig.constellation_16qam_sptr_map_to_points(self, value, points)


    def map_to_points_v(self, value):
        """map_to_points_v(constellation_16qam_sptr self, unsigned int value) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_16qam_sptr_map_to_points_v(self, value)


    def decision_maker(self, sample):
        """decision_maker(constellation_16qam_sptr self, gr_complex const * sample) -> unsigned int"""
        return _gfdm_swig.constellation_16qam_sptr_decision_maker(self, sample)


    def decision_maker_v(self, sample):
        """decision_maker_v(constellation_16qam_sptr self, pmt_vector_cfloat sample) -> unsigned int"""
        return _gfdm_swig.constellation_16qam_sptr_decision_maker_v(self, sample)


    def decision_maker_pe(self, sample, phase_error):
        """decision_maker_pe(constellation_16qam_sptr self, gr_complex const * sample, float * phase_error) -> unsigned int"""
        return _gfdm_swig.constellation_16qam_sptr_decision_maker_pe(self, sample, phase_error)


    def calc_metric(self, sample, metric, type):
        """calc_metric(constellation_16qam_sptr self, gr_complex const * sample, float * metric, gr::digital::trellis_metric_type_t type)"""
        return _gfdm_swig.constellation_16qam_sptr_calc_metric(self, sample, metric, type)


    def calc_euclidean_metric(self, sample, metric):
        """calc_euclidean_metric(constellation_16qam_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_16qam_sptr_calc_euclidean_metric(self, sample, metric)


    def calc_hard_symbol_metric(self, sample, metric):
        """calc_hard_symbol_metric(constellation_16qam_sptr self, gr_complex const * sample, float * metric)"""
        return _gfdm_swig.constellation_16qam_sptr_calc_hard_symbol_metric(self, sample, metric)


    def points(self):
        """points(constellation_16qam_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_16qam_sptr_points(self)


    def s_points(self):
        """s_points(constellation_16qam_sptr self) -> pmt_vector_cfloat"""
        return _gfdm_swig.constellation_16qam_sptr_s_points(self)


    def v_points(self):
        """v_points(constellation_16qam_sptr self) -> gr_vector_vector_complexf"""
        return _gfdm_swig.constellation_16qam_sptr_v_points(self)


    def apply_pre_diff_code(self):
        """apply_pre_diff_code(constellation_16qam_sptr self) -> bool"""
        return _gfdm_swig.constellation_16qam_sptr_apply_pre_diff_code(self)


    def set_pre_diff_code(self, a):
        """set_pre_diff_code(constellation_16qam_sptr self, bool a)"""
        return _gfdm_swig.constellation_16qam_sptr_set_pre_diff_code(self, a)


    def pre_diff_code(self):
        """pre_diff_code(constellation_16qam_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.constellation_16qam_sptr_pre_diff_code(self)


    def rotational_symmetry(self):
        """rotational_symmetry(constellation_16qam_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_16qam_sptr_rotational_symmetry(self)


    def dimensionality(self):
        """dimensionality(constellation_16qam_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_16qam_sptr_dimensionality(self)


    def bits_per_symbol(self):
        """bits_per_symbol(constellation_16qam_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_16qam_sptr_bits_per_symbol(self)


    def arity(self):
        """arity(constellation_16qam_sptr self) -> unsigned int"""
        return _gfdm_swig.constellation_16qam_sptr_arity(self)


    def base(self):
        """base(constellation_16qam_sptr self) -> constellation_sptr"""
        return _gfdm_swig.constellation_16qam_sptr_base(self)


    def as_pmt(self):
        """as_pmt(constellation_16qam_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.constellation_16qam_sptr_as_pmt(self)


    def gen_soft_dec_lut(self, precision, npwr=1.0):
        """gen_soft_dec_lut(constellation_16qam_sptr self, int precision, float npwr=1.0)"""
        return _gfdm_swig.constellation_16qam_sptr_gen_soft_dec_lut(self, precision, npwr)


    def calc_soft_dec(self, sample, npwr=1.0):
        """calc_soft_dec(constellation_16qam_sptr self, gr_complex sample, float npwr=1.0) -> pmt_vector_float"""
        return _gfdm_swig.constellation_16qam_sptr_calc_soft_dec(self, sample, npwr)


    def set_soft_dec_lut(self, soft_dec_lut, precision):
        """set_soft_dec_lut(constellation_16qam_sptr self, std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > > const & soft_dec_lut, int precision)"""
        return _gfdm_swig.constellation_16qam_sptr_set_soft_dec_lut(self, soft_dec_lut, precision)


    def has_soft_dec_lut(self):
        """has_soft_dec_lut(constellation_16qam_sptr self) -> bool"""
        return _gfdm_swig.constellation_16qam_sptr_has_soft_dec_lut(self)


    def soft_dec_lut(self):
        """soft_dec_lut(constellation_16qam_sptr self) -> std::vector< std::vector< float,std::allocator< float > >,std::allocator< std::vector< float,std::allocator< float > > > >"""
        return _gfdm_swig.constellation_16qam_sptr_soft_dec_lut(self)


    def soft_decision_maker(self, sample):
        """soft_decision_maker(constellation_16qam_sptr self, gr_complex sample) -> pmt_vector_float"""
        return _gfdm_swig.constellation_16qam_sptr_soft_decision_maker(self, sample)

constellation_16qam_sptr_swigregister = _gfdm_swig.constellation_16qam_sptr_swigregister
constellation_16qam_sptr_swigregister(constellation_16qam_sptr)


constellation_16qam_sptr.__repr__ = lambda self: "<constellation 16qam>"
constellation_16qam = constellation_16qam.make;

class sync_cc(object):
    """<+description of block+>"""

    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, **kwargs):
        """
        make(int n_subcarriers, int cp_length, int frame_len, pmt_vector_cfloat preamble, std::string const & gfdm_tag_key) -> sync_cc_sptr

        Return a shared_ptr to a new instance of gfdm::sync_cc.

        To avoid accidental use of raw pointers, gfdm::sync_cc's constructor is in a private implementation class. gfdm::sync_cc::make is the public interface for creating new instances.

        Params: (n_subcarriers, cp_length, frame_len, preamble, gfdm_tag_key)
        """
        return _gfdm_swig.sync_cc_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_sync_cc
    __del__ = lambda self: None
sync_cc_swigregister = _gfdm_swig.sync_cc_swigregister
sync_cc_swigregister(sync_cc)

def sync_cc_make(*args, **kwargs):
    """
    sync_cc_make(int n_subcarriers, int cp_length, int frame_len, pmt_vector_cfloat preamble, std::string const & gfdm_tag_key) -> sync_cc_sptr

    Return a shared_ptr to a new instance of gfdm::sync_cc.

    To avoid accidental use of raw pointers, gfdm::sync_cc's constructor is in a private implementation class. gfdm::sync_cc::make is the public interface for creating new instances.

    Params: (n_subcarriers, cp_length, frame_len, preamble, gfdm_tag_key)
    """
    return _gfdm_swig.sync_cc_make(*args, **kwargs)

class sync_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::gfdm::sync_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::gfdm::sync_cc)> self) -> sync_cc_sptr
        __init__(boost::shared_ptr<(gr::gfdm::sync_cc)> self, sync_cc p) -> sync_cc_sptr
        """
        this = _gfdm_swig.new_sync_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(sync_cc_sptr self) -> sync_cc"""
        return _gfdm_swig.sync_cc_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_sync_cc_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """
        make(sync_cc_sptr self, int n_subcarriers, int cp_length, int frame_len, pmt_vector_cfloat preamble, std::string const & gfdm_tag_key) -> sync_cc_sptr

        Return a shared_ptr to a new instance of gfdm::sync_cc.

        To avoid accidental use of raw pointers, gfdm::sync_cc's constructor is in a private implementation class. gfdm::sync_cc::make is the public interface for creating new instances.

        Params: (n_subcarriers, cp_length, frame_len, preamble, gfdm_tag_key)
        """
        return _gfdm_swig.sync_cc_sptr_make(self, *args, **kwargs)


    def history(self):
        """history(sync_cc_sptr self) -> unsigned int"""
        return _gfdm_swig.sync_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(sync_cc_sptr self, int which, int delay)
        declare_sample_delay(sync_cc_sptr self, unsigned int delay)
        """
        return _gfdm_swig.sync_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(sync_cc_sptr self, int which) -> unsigned int"""
        return _gfdm_swig.sync_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(sync_cc_sptr self) -> int"""
        return _gfdm_swig.sync_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(sync_cc_sptr self) -> double"""
        return _gfdm_swig.sync_cc_sptr_relative_rate(self)


    def start(self):
        """start(sync_cc_sptr self) -> bool"""
        return _gfdm_swig.sync_cc_sptr_start(self)


    def stop(self):
        """stop(sync_cc_sptr self) -> bool"""
        return _gfdm_swig.sync_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(sync_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _gfdm_swig.sync_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(sync_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _gfdm_swig.sync_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(sync_cc_sptr self) -> int"""
        return _gfdm_swig.sync_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(sync_cc_sptr self, int m)"""
        return _gfdm_swig.sync_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(sync_cc_sptr self)"""
        return _gfdm_swig.sync_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(sync_cc_sptr self) -> bool"""
        return _gfdm_swig.sync_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(sync_cc_sptr self, int m)"""
        return _gfdm_swig.sync_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(sync_cc_sptr self) -> int"""
        return _gfdm_swig.sync_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(sync_cc_sptr self, int i) -> long"""
        return _gfdm_swig.sync_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(sync_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(sync_cc_sptr self, int port, long max_output_buffer)
        """
        return _gfdm_swig.sync_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(sync_cc_sptr self, int i) -> long"""
        return _gfdm_swig.sync_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(sync_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(sync_cc_sptr self, int port, long min_output_buffer)
        """
        return _gfdm_swig.sync_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(sync_cc_sptr self) -> float"""
        return _gfdm_swig.sync_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(sync_cc_sptr self) -> float"""
        return _gfdm_swig.sync_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(sync_cc_sptr self) -> float"""
        return _gfdm_swig.sync_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(sync_cc_sptr self) -> float"""
        return _gfdm_swig.sync_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(sync_cc_sptr self) -> float"""
        return _gfdm_swig.sync_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(sync_cc_sptr self) -> float"""
        return _gfdm_swig.sync_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(sync_cc_sptr self, int which) -> float
        pc_input_buffers_full(sync_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.sync_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(sync_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(sync_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.sync_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(sync_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(sync_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.sync_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(sync_cc_sptr self, int which) -> float
        pc_output_buffers_full(sync_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.sync_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(sync_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(sync_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.sync_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(sync_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(sync_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.sync_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(sync_cc_sptr self) -> float"""
        return _gfdm_swig.sync_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(sync_cc_sptr self) -> float"""
        return _gfdm_swig.sync_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(sync_cc_sptr self) -> float"""
        return _gfdm_swig.sync_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(sync_cc_sptr self) -> float"""
        return _gfdm_swig.sync_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(sync_cc_sptr self) -> float"""
        return _gfdm_swig.sync_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(sync_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _gfdm_swig.sync_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(sync_cc_sptr self)"""
        return _gfdm_swig.sync_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(sync_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.sync_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(sync_cc_sptr self) -> int"""
        return _gfdm_swig.sync_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(sync_cc_sptr self) -> int"""
        return _gfdm_swig.sync_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(sync_cc_sptr self, int priority) -> int"""
        return _gfdm_swig.sync_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(sync_cc_sptr self) -> std::string"""
        return _gfdm_swig.sync_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(sync_cc_sptr self) -> std::string"""
        return _gfdm_swig.sync_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(sync_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.sync_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(sync_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.sync_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(sync_cc_sptr self) -> long"""
        return _gfdm_swig.sync_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(sync_cc_sptr self) -> basic_block_sptr"""
        return _gfdm_swig.sync_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(sync_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _gfdm_swig.sync_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(sync_cc_sptr self) -> std::string"""
        return _gfdm_swig.sync_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(sync_cc_sptr self, std::string name)"""
        return _gfdm_swig.sync_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(sync_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _gfdm_swig.sync_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(sync_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.sync_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(sync_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.sync_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(sync_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _gfdm_swig.sync_cc_sptr_message_subscribers(self, which_port)

sync_cc_sptr_swigregister = _gfdm_swig.sync_cc_sptr_swigregister
sync_cc_sptr_swigregister(sync_cc_sptr)


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

class cyclic_prefixer_cc(object):
    """Add Cyclic Prefix to GFDM block and apply block pinching (W-GFDM)."""

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

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

    def make(block_len, cp_len, cs_len, ramp_len, window_taps):
        """
        make(int block_len, int cp_len, int cs_len, int ramp_len, pmt_vector_cfloat window_taps) -> cyclic_prefixer_cc_sptr

        Return a shared_ptr to a new instance of gfdm::cyclic_prefixer_cc.

        To avoid accidental use of raw pointers, gfdm::cyclic_prefixer_cc's constructor is in a private implementation class. gfdm::cyclic_prefixer_cc::make is the public interface for creating new instances.

        Params: (block_len, cp_len, cs_len, ramp_len, window_taps)
        """
        return _gfdm_swig.cyclic_prefixer_cc_make(block_len, cp_len, cs_len, ramp_len, window_taps)

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_cyclic_prefixer_cc
    __del__ = lambda self: None
cyclic_prefixer_cc_swigregister = _gfdm_swig.cyclic_prefixer_cc_swigregister
cyclic_prefixer_cc_swigregister(cyclic_prefixer_cc)

def cyclic_prefixer_cc_make(block_len, cp_len, cs_len, ramp_len, window_taps):
    """
    cyclic_prefixer_cc_make(int block_len, int cp_len, int cs_len, int ramp_len, pmt_vector_cfloat window_taps) -> cyclic_prefixer_cc_sptr

    Return a shared_ptr to a new instance of gfdm::cyclic_prefixer_cc.

    To avoid accidental use of raw pointers, gfdm::cyclic_prefixer_cc's constructor is in a private implementation class. gfdm::cyclic_prefixer_cc::make is the public interface for creating new instances.

    Params: (block_len, cp_len, cs_len, ramp_len, window_taps)
    """
    return _gfdm_swig.cyclic_prefixer_cc_make(block_len, cp_len, cs_len, ramp_len, window_taps)

class cyclic_prefixer_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::gfdm::cyclic_prefixer_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::gfdm::cyclic_prefixer_cc)> self) -> cyclic_prefixer_cc_sptr
        __init__(boost::shared_ptr<(gr::gfdm::cyclic_prefixer_cc)> self, cyclic_prefixer_cc p) -> cyclic_prefixer_cc_sptr
        """
        this = _gfdm_swig.new_cyclic_prefixer_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(cyclic_prefixer_cc_sptr self) -> cyclic_prefixer_cc"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_cyclic_prefixer_cc_sptr
    __del__ = lambda self: None

    def make(self, block_len, cp_len, cs_len, ramp_len, window_taps):
        """
        make(cyclic_prefixer_cc_sptr self, int block_len, int cp_len, int cs_len, int ramp_len, pmt_vector_cfloat window_taps) -> cyclic_prefixer_cc_sptr

        Return a shared_ptr to a new instance of gfdm::cyclic_prefixer_cc.

        To avoid accidental use of raw pointers, gfdm::cyclic_prefixer_cc's constructor is in a private implementation class. gfdm::cyclic_prefixer_cc::make is the public interface for creating new instances.

        Params: (block_len, cp_len, cs_len, ramp_len, window_taps)
        """
        return _gfdm_swig.cyclic_prefixer_cc_sptr_make(self, block_len, cp_len, cs_len, ramp_len, window_taps)


    def history(self):
        """history(cyclic_prefixer_cc_sptr self) -> unsigned int"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(cyclic_prefixer_cc_sptr self, int which, int delay)
        declare_sample_delay(cyclic_prefixer_cc_sptr self, unsigned int delay)
        """
        return _gfdm_swig.cyclic_prefixer_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(cyclic_prefixer_cc_sptr self, int which) -> unsigned int"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(cyclic_prefixer_cc_sptr self) -> int"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(cyclic_prefixer_cc_sptr self) -> double"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_relative_rate(self)


    def start(self):
        """start(cyclic_prefixer_cc_sptr self) -> bool"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_start(self)


    def stop(self):
        """stop(cyclic_prefixer_cc_sptr self) -> bool"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(cyclic_prefixer_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(cyclic_prefixer_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(cyclic_prefixer_cc_sptr self) -> int"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(cyclic_prefixer_cc_sptr self, int m)"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(cyclic_prefixer_cc_sptr self)"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(cyclic_prefixer_cc_sptr self) -> bool"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(cyclic_prefixer_cc_sptr self, int m)"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(cyclic_prefixer_cc_sptr self) -> int"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(cyclic_prefixer_cc_sptr self, int i) -> long"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(cyclic_prefixer_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(cyclic_prefixer_cc_sptr self, int port, long max_output_buffer)
        """
        return _gfdm_swig.cyclic_prefixer_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(cyclic_prefixer_cc_sptr self, int i) -> long"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(cyclic_prefixer_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(cyclic_prefixer_cc_sptr self, int port, long min_output_buffer)
        """
        return _gfdm_swig.cyclic_prefixer_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(cyclic_prefixer_cc_sptr self) -> float"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(cyclic_prefixer_cc_sptr self) -> float"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(cyclic_prefixer_cc_sptr self) -> float"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(cyclic_prefixer_cc_sptr self) -> float"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(cyclic_prefixer_cc_sptr self) -> float"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(cyclic_prefixer_cc_sptr self) -> float"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(cyclic_prefixer_cc_sptr self, int which) -> float
        pc_input_buffers_full(cyclic_prefixer_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.cyclic_prefixer_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(cyclic_prefixer_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(cyclic_prefixer_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.cyclic_prefixer_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(cyclic_prefixer_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(cyclic_prefixer_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.cyclic_prefixer_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(cyclic_prefixer_cc_sptr self, int which) -> float
        pc_output_buffers_full(cyclic_prefixer_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.cyclic_prefixer_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(cyclic_prefixer_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(cyclic_prefixer_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.cyclic_prefixer_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(cyclic_prefixer_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(cyclic_prefixer_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.cyclic_prefixer_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(cyclic_prefixer_cc_sptr self) -> float"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(cyclic_prefixer_cc_sptr self) -> float"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(cyclic_prefixer_cc_sptr self) -> float"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(cyclic_prefixer_cc_sptr self) -> float"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(cyclic_prefixer_cc_sptr self) -> float"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(cyclic_prefixer_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(cyclic_prefixer_cc_sptr self)"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(cyclic_prefixer_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(cyclic_prefixer_cc_sptr self) -> int"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(cyclic_prefixer_cc_sptr self) -> int"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(cyclic_prefixer_cc_sptr self, int priority) -> int"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(cyclic_prefixer_cc_sptr self) -> std::string"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(cyclic_prefixer_cc_sptr self) -> std::string"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(cyclic_prefixer_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(cyclic_prefixer_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(cyclic_prefixer_cc_sptr self) -> long"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(cyclic_prefixer_cc_sptr self) -> basic_block_sptr"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(cyclic_prefixer_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(cyclic_prefixer_cc_sptr self) -> std::string"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(cyclic_prefixer_cc_sptr self, std::string name)"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(cyclic_prefixer_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(cyclic_prefixer_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(cyclic_prefixer_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(cyclic_prefixer_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _gfdm_swig.cyclic_prefixer_cc_sptr_message_subscribers(self, which_port)

cyclic_prefixer_cc_sptr_swigregister = _gfdm_swig.cyclic_prefixer_cc_sptr_swigregister
cyclic_prefixer_cc_sptr_swigregister(cyclic_prefixer_cc_sptr)


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

class preamble_generator(object):
    """Proxy of C++ gr::gfdm::preamble_generator 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, nsubcarrier, filter_alpha, sync_fft_len):
        """
        __init__(gr::gfdm::preamble_generator self, int nsubcarrier, double filter_alpha, int sync_fft_len) -> preamble_generator



        Params: (nsubcarrier, filter_alpha, sync_fft_len)
        """
        this = _gfdm_swig.new_preamble_generator(nsubcarrier, filter_alpha, sync_fft_len)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gfdm_swig.delete_preamble_generator
    __del__ = lambda self: None

    def get_preamble(self):
        """
        get_preamble(preamble_generator self) -> pmt_vector_cfloat



        Params: (NONE)
        """
        return _gfdm_swig.preamble_generator_get_preamble(self)


    def get_symbol_seq(self):
        """
        get_symbol_seq(preamble_generator self) -> pmt_vector_cfloat



        Params: (NONE)
        """
        return _gfdm_swig.preamble_generator_get_symbol_seq(self)


    def base(self):
        """
        base(preamble_generator self) -> preamble_generator_sptr



        Params: (NONE)
        """
        return _gfdm_swig.preamble_generator_base(self)


    def get_preamble_len(self):
        """
        get_preamble_len(preamble_generator self) -> int



        Params: (NONE)
        """
        return _gfdm_swig.preamble_generator_get_preamble_len(self)


    def make(nsubcarrier, filter_alpha, sync_fft_len):
        """
        make(int nsubcarrier, double filter_alpha, int sync_fft_len) -> preamble_generator_sptr



        Params: (nsubcarrier, filter_alpha, sync_fft_len)
        """
        return _gfdm_swig.preamble_generator_make(nsubcarrier, filter_alpha, sync_fft_len)

    make = staticmethod(make)
preamble_generator_swigregister = _gfdm_swig.preamble_generator_swigregister
preamble_generator_swigregister(preamble_generator)

def preamble_generator_make(nsubcarrier, filter_alpha, sync_fft_len):
    """
    preamble_generator_make(int nsubcarrier, double filter_alpha, int sync_fft_len) -> preamble_generator_sptr



    Params: (nsubcarrier, filter_alpha, sync_fft_len)
    """
    return _gfdm_swig.preamble_generator_make(nsubcarrier, filter_alpha, sync_fft_len)

class preamble_generator_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::gfdm::preamble_generator)> 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::gfdm::preamble_generator)> self) -> preamble_generator_sptr
        __init__(boost::shared_ptr<(gr::gfdm::preamble_generator)> self, preamble_generator p) -> preamble_generator_sptr
        """
        this = _gfdm_swig.new_preamble_generator_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(preamble_generator_sptr self) -> preamble_generator"""
        return _gfdm_swig.preamble_generator_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_preamble_generator_sptr
    __del__ = lambda self: None

    def get_preamble(self):
        """
        get_preamble(preamble_generator_sptr self) -> pmt_vector_cfloat



        Params: (NONE)
        """
        return _gfdm_swig.preamble_generator_sptr_get_preamble(self)


    def get_symbol_seq(self):
        """
        get_symbol_seq(preamble_generator_sptr self) -> pmt_vector_cfloat



        Params: (NONE)
        """
        return _gfdm_swig.preamble_generator_sptr_get_symbol_seq(self)


    def base(self):
        """
        base(preamble_generator_sptr self) -> preamble_generator_sptr



        Params: (NONE)
        """
        return _gfdm_swig.preamble_generator_sptr_base(self)


    def get_preamble_len(self):
        """
        get_preamble_len(preamble_generator_sptr self) -> int



        Params: (NONE)
        """
        return _gfdm_swig.preamble_generator_sptr_get_preamble_len(self)


    def make(self, nsubcarrier, filter_alpha, sync_fft_len):
        """
        make(preamble_generator_sptr self, int nsubcarrier, double filter_alpha, int sync_fft_len) -> preamble_generator_sptr



        Params: (nsubcarrier, filter_alpha, sync_fft_len)
        """
        return _gfdm_swig.preamble_generator_sptr_make(self, nsubcarrier, filter_alpha, sync_fft_len)

preamble_generator_sptr_swigregister = _gfdm_swig.preamble_generator_sptr_swigregister
preamble_generator_sptr_swigregister(preamble_generator_sptr)


preamble_generator_sptr.__repr__ = lambda self: "<preamble generator>"
preamble_generator = preamble_generator.make;

class remove_prefix_cc(object):
    """extract block_len items from frame_len chunks of items, marked with a tag plus offset"""

    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(frame_len, block_len, offset, gfdm_sync_tag_key):
        """
        make(int frame_len, int block_len, int offset, std::string const & gfdm_sync_tag_key) -> remove_prefix_cc_sptr

        Return a shared_ptr to a new instance of gfdm::remove_prefix_cc.

        To avoid accidental use of raw pointers, gfdm::remove_prefix_cc' constructor is in a private implementation class. gfdm::remove_prefix_cc::make is the public interface for creating new instances.

        Params: (frame_len, block_len, offset, gfdm_sync_tag_key)
        """
        return _gfdm_swig.remove_prefix_cc_make(frame_len, block_len, offset, gfdm_sync_tag_key)

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_remove_prefix_cc
    __del__ = lambda self: None
remove_prefix_cc_swigregister = _gfdm_swig.remove_prefix_cc_swigregister
remove_prefix_cc_swigregister(remove_prefix_cc)

def remove_prefix_cc_make(frame_len, block_len, offset, gfdm_sync_tag_key):
    """
    remove_prefix_cc_make(int frame_len, int block_len, int offset, std::string const & gfdm_sync_tag_key) -> remove_prefix_cc_sptr

    Return a shared_ptr to a new instance of gfdm::remove_prefix_cc.

    To avoid accidental use of raw pointers, gfdm::remove_prefix_cc' constructor is in a private implementation class. gfdm::remove_prefix_cc::make is the public interface for creating new instances.

    Params: (frame_len, block_len, offset, gfdm_sync_tag_key)
    """
    return _gfdm_swig.remove_prefix_cc_make(frame_len, block_len, offset, gfdm_sync_tag_key)

class remove_prefix_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::gfdm::remove_prefix_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::gfdm::remove_prefix_cc)> self) -> remove_prefix_cc_sptr
        __init__(boost::shared_ptr<(gr::gfdm::remove_prefix_cc)> self, remove_prefix_cc p) -> remove_prefix_cc_sptr
        """
        this = _gfdm_swig.new_remove_prefix_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(remove_prefix_cc_sptr self) -> remove_prefix_cc"""
        return _gfdm_swig.remove_prefix_cc_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_remove_prefix_cc_sptr
    __del__ = lambda self: None

    def make(self, frame_len, block_len, offset, gfdm_sync_tag_key):
        """
        make(remove_prefix_cc_sptr self, int frame_len, int block_len, int offset, std::string const & gfdm_sync_tag_key) -> remove_prefix_cc_sptr

        Return a shared_ptr to a new instance of gfdm::remove_prefix_cc.

        To avoid accidental use of raw pointers, gfdm::remove_prefix_cc' constructor is in a private implementation class. gfdm::remove_prefix_cc::make is the public interface for creating new instances.

        Params: (frame_len, block_len, offset, gfdm_sync_tag_key)
        """
        return _gfdm_swig.remove_prefix_cc_sptr_make(self, frame_len, block_len, offset, gfdm_sync_tag_key)


    def history(self):
        """history(remove_prefix_cc_sptr self) -> unsigned int"""
        return _gfdm_swig.remove_prefix_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(remove_prefix_cc_sptr self, int which, int delay)
        declare_sample_delay(remove_prefix_cc_sptr self, unsigned int delay)
        """
        return _gfdm_swig.remove_prefix_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(remove_prefix_cc_sptr self, int which) -> unsigned int"""
        return _gfdm_swig.remove_prefix_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(remove_prefix_cc_sptr self) -> int"""
        return _gfdm_swig.remove_prefix_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(remove_prefix_cc_sptr self) -> double"""
        return _gfdm_swig.remove_prefix_cc_sptr_relative_rate(self)


    def start(self):
        """start(remove_prefix_cc_sptr self) -> bool"""
        return _gfdm_swig.remove_prefix_cc_sptr_start(self)


    def stop(self):
        """stop(remove_prefix_cc_sptr self) -> bool"""
        return _gfdm_swig.remove_prefix_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(remove_prefix_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _gfdm_swig.remove_prefix_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(remove_prefix_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _gfdm_swig.remove_prefix_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(remove_prefix_cc_sptr self) -> int"""
        return _gfdm_swig.remove_prefix_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(remove_prefix_cc_sptr self, int m)"""
        return _gfdm_swig.remove_prefix_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(remove_prefix_cc_sptr self)"""
        return _gfdm_swig.remove_prefix_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(remove_prefix_cc_sptr self) -> bool"""
        return _gfdm_swig.remove_prefix_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(remove_prefix_cc_sptr self, int m)"""
        return _gfdm_swig.remove_prefix_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(remove_prefix_cc_sptr self) -> int"""
        return _gfdm_swig.remove_prefix_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(remove_prefix_cc_sptr self, int i) -> long"""
        return _gfdm_swig.remove_prefix_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(remove_prefix_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(remove_prefix_cc_sptr self, int port, long max_output_buffer)
        """
        return _gfdm_swig.remove_prefix_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(remove_prefix_cc_sptr self, int i) -> long"""
        return _gfdm_swig.remove_prefix_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(remove_prefix_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(remove_prefix_cc_sptr self, int port, long min_output_buffer)
        """
        return _gfdm_swig.remove_prefix_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(remove_prefix_cc_sptr self) -> float"""
        return _gfdm_swig.remove_prefix_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(remove_prefix_cc_sptr self) -> float"""
        return _gfdm_swig.remove_prefix_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(remove_prefix_cc_sptr self) -> float"""
        return _gfdm_swig.remove_prefix_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(remove_prefix_cc_sptr self) -> float"""
        return _gfdm_swig.remove_prefix_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(remove_prefix_cc_sptr self) -> float"""
        return _gfdm_swig.remove_prefix_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(remove_prefix_cc_sptr self) -> float"""
        return _gfdm_swig.remove_prefix_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(remove_prefix_cc_sptr self, int which) -> float
        pc_input_buffers_full(remove_prefix_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.remove_prefix_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(remove_prefix_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(remove_prefix_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.remove_prefix_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(remove_prefix_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(remove_prefix_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.remove_prefix_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(remove_prefix_cc_sptr self, int which) -> float
        pc_output_buffers_full(remove_prefix_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.remove_prefix_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(remove_prefix_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(remove_prefix_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.remove_prefix_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(remove_prefix_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(remove_prefix_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.remove_prefix_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(remove_prefix_cc_sptr self) -> float"""
        return _gfdm_swig.remove_prefix_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(remove_prefix_cc_sptr self) -> float"""
        return _gfdm_swig.remove_prefix_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(remove_prefix_cc_sptr self) -> float"""
        return _gfdm_swig.remove_prefix_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(remove_prefix_cc_sptr self) -> float"""
        return _gfdm_swig.remove_prefix_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(remove_prefix_cc_sptr self) -> float"""
        return _gfdm_swig.remove_prefix_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(remove_prefix_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _gfdm_swig.remove_prefix_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(remove_prefix_cc_sptr self)"""
        return _gfdm_swig.remove_prefix_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(remove_prefix_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.remove_prefix_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(remove_prefix_cc_sptr self) -> int"""
        return _gfdm_swig.remove_prefix_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(remove_prefix_cc_sptr self) -> int"""
        return _gfdm_swig.remove_prefix_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(remove_prefix_cc_sptr self, int priority) -> int"""
        return _gfdm_swig.remove_prefix_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(remove_prefix_cc_sptr self) -> std::string"""
        return _gfdm_swig.remove_prefix_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(remove_prefix_cc_sptr self) -> std::string"""
        return _gfdm_swig.remove_prefix_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(remove_prefix_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.remove_prefix_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(remove_prefix_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.remove_prefix_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(remove_prefix_cc_sptr self) -> long"""
        return _gfdm_swig.remove_prefix_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(remove_prefix_cc_sptr self) -> basic_block_sptr"""
        return _gfdm_swig.remove_prefix_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(remove_prefix_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _gfdm_swig.remove_prefix_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(remove_prefix_cc_sptr self) -> std::string"""
        return _gfdm_swig.remove_prefix_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(remove_prefix_cc_sptr self, std::string name)"""
        return _gfdm_swig.remove_prefix_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(remove_prefix_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _gfdm_swig.remove_prefix_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(remove_prefix_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.remove_prefix_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(remove_prefix_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.remove_prefix_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(remove_prefix_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _gfdm_swig.remove_prefix_cc_sptr_message_subscribers(self, which_port)

remove_prefix_cc_sptr_swigregister = _gfdm_swig.remove_prefix_cc_sptr_swigregister
remove_prefix_cc_sptr_swigregister(remove_prefix_cc_sptr)


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

class simple_modulator_cc(object):
    """<+description of block+>"""

    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(n_timeslots, n_subcarriers, overlap, frequency_taps):
        """
        make(int n_timeslots, int n_subcarriers, int overlap, pmt_vector_cfloat frequency_taps) -> simple_modulator_cc_sptr

        Return a shared_ptr to a new instance of gfdm::simple_modulator_cc.

        To avoid accidental use of raw pointers, gfdm::simple_modulator_cc's constructor is in a private implementation class. gfdm::simple_modulator_cc::make is the public interface for creating new instances.

        Params: (n_timeslots, n_subcarriers, overlap, frequency_taps)
        """
        return _gfdm_swig.simple_modulator_cc_make(n_timeslots, n_subcarriers, overlap, frequency_taps)

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_simple_modulator_cc
    __del__ = lambda self: None
simple_modulator_cc_swigregister = _gfdm_swig.simple_modulator_cc_swigregister
simple_modulator_cc_swigregister(simple_modulator_cc)

def simple_modulator_cc_make(n_timeslots, n_subcarriers, overlap, frequency_taps):
    """
    simple_modulator_cc_make(int n_timeslots, int n_subcarriers, int overlap, pmt_vector_cfloat frequency_taps) -> simple_modulator_cc_sptr

    Return a shared_ptr to a new instance of gfdm::simple_modulator_cc.

    To avoid accidental use of raw pointers, gfdm::simple_modulator_cc's constructor is in a private implementation class. gfdm::simple_modulator_cc::make is the public interface for creating new instances.

    Params: (n_timeslots, n_subcarriers, overlap, frequency_taps)
    """
    return _gfdm_swig.simple_modulator_cc_make(n_timeslots, n_subcarriers, overlap, frequency_taps)

class simple_modulator_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::gfdm::simple_modulator_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::gfdm::simple_modulator_cc)> self) -> simple_modulator_cc_sptr
        __init__(boost::shared_ptr<(gr::gfdm::simple_modulator_cc)> self, simple_modulator_cc p) -> simple_modulator_cc_sptr
        """
        this = _gfdm_swig.new_simple_modulator_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(simple_modulator_cc_sptr self) -> simple_modulator_cc"""
        return _gfdm_swig.simple_modulator_cc_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_simple_modulator_cc_sptr
    __del__ = lambda self: None

    def make(self, n_timeslots, n_subcarriers, overlap, frequency_taps):
        """
        make(simple_modulator_cc_sptr self, int n_timeslots, int n_subcarriers, int overlap, pmt_vector_cfloat frequency_taps) -> simple_modulator_cc_sptr

        Return a shared_ptr to a new instance of gfdm::simple_modulator_cc.

        To avoid accidental use of raw pointers, gfdm::simple_modulator_cc's constructor is in a private implementation class. gfdm::simple_modulator_cc::make is the public interface for creating new instances.

        Params: (n_timeslots, n_subcarriers, overlap, frequency_taps)
        """
        return _gfdm_swig.simple_modulator_cc_sptr_make(self, n_timeslots, n_subcarriers, overlap, frequency_taps)


    def history(self):
        """history(simple_modulator_cc_sptr self) -> unsigned int"""
        return _gfdm_swig.simple_modulator_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(simple_modulator_cc_sptr self, int which, int delay)
        declare_sample_delay(simple_modulator_cc_sptr self, unsigned int delay)
        """
        return _gfdm_swig.simple_modulator_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(simple_modulator_cc_sptr self, int which) -> unsigned int"""
        return _gfdm_swig.simple_modulator_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(simple_modulator_cc_sptr self) -> int"""
        return _gfdm_swig.simple_modulator_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(simple_modulator_cc_sptr self) -> double"""
        return _gfdm_swig.simple_modulator_cc_sptr_relative_rate(self)


    def start(self):
        """start(simple_modulator_cc_sptr self) -> bool"""
        return _gfdm_swig.simple_modulator_cc_sptr_start(self)


    def stop(self):
        """stop(simple_modulator_cc_sptr self) -> bool"""
        return _gfdm_swig.simple_modulator_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(simple_modulator_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _gfdm_swig.simple_modulator_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(simple_modulator_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _gfdm_swig.simple_modulator_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(simple_modulator_cc_sptr self) -> int"""
        return _gfdm_swig.simple_modulator_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(simple_modulator_cc_sptr self, int m)"""
        return _gfdm_swig.simple_modulator_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(simple_modulator_cc_sptr self)"""
        return _gfdm_swig.simple_modulator_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(simple_modulator_cc_sptr self) -> bool"""
        return _gfdm_swig.simple_modulator_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(simple_modulator_cc_sptr self, int m)"""
        return _gfdm_swig.simple_modulator_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(simple_modulator_cc_sptr self) -> int"""
        return _gfdm_swig.simple_modulator_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(simple_modulator_cc_sptr self, int i) -> long"""
        return _gfdm_swig.simple_modulator_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(simple_modulator_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(simple_modulator_cc_sptr self, int port, long max_output_buffer)
        """
        return _gfdm_swig.simple_modulator_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(simple_modulator_cc_sptr self, int i) -> long"""
        return _gfdm_swig.simple_modulator_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(simple_modulator_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(simple_modulator_cc_sptr self, int port, long min_output_buffer)
        """
        return _gfdm_swig.simple_modulator_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(simple_modulator_cc_sptr self) -> float"""
        return _gfdm_swig.simple_modulator_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(simple_modulator_cc_sptr self) -> float"""
        return _gfdm_swig.simple_modulator_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(simple_modulator_cc_sptr self) -> float"""
        return _gfdm_swig.simple_modulator_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(simple_modulator_cc_sptr self) -> float"""
        return _gfdm_swig.simple_modulator_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(simple_modulator_cc_sptr self) -> float"""
        return _gfdm_swig.simple_modulator_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(simple_modulator_cc_sptr self) -> float"""
        return _gfdm_swig.simple_modulator_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(simple_modulator_cc_sptr self, int which) -> float
        pc_input_buffers_full(simple_modulator_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.simple_modulator_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(simple_modulator_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(simple_modulator_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.simple_modulator_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(simple_modulator_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(simple_modulator_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.simple_modulator_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(simple_modulator_cc_sptr self, int which) -> float
        pc_output_buffers_full(simple_modulator_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.simple_modulator_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(simple_modulator_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(simple_modulator_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.simple_modulator_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(simple_modulator_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(simple_modulator_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.simple_modulator_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(simple_modulator_cc_sptr self) -> float"""
        return _gfdm_swig.simple_modulator_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(simple_modulator_cc_sptr self) -> float"""
        return _gfdm_swig.simple_modulator_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(simple_modulator_cc_sptr self) -> float"""
        return _gfdm_swig.simple_modulator_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(simple_modulator_cc_sptr self) -> float"""
        return _gfdm_swig.simple_modulator_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(simple_modulator_cc_sptr self) -> float"""
        return _gfdm_swig.simple_modulator_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(simple_modulator_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _gfdm_swig.simple_modulator_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(simple_modulator_cc_sptr self)"""
        return _gfdm_swig.simple_modulator_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(simple_modulator_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.simple_modulator_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(simple_modulator_cc_sptr self) -> int"""
        return _gfdm_swig.simple_modulator_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(simple_modulator_cc_sptr self) -> int"""
        return _gfdm_swig.simple_modulator_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(simple_modulator_cc_sptr self, int priority) -> int"""
        return _gfdm_swig.simple_modulator_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(simple_modulator_cc_sptr self) -> std::string"""
        return _gfdm_swig.simple_modulator_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(simple_modulator_cc_sptr self) -> std::string"""
        return _gfdm_swig.simple_modulator_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(simple_modulator_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.simple_modulator_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(simple_modulator_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.simple_modulator_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(simple_modulator_cc_sptr self) -> long"""
        return _gfdm_swig.simple_modulator_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(simple_modulator_cc_sptr self) -> basic_block_sptr"""
        return _gfdm_swig.simple_modulator_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(simple_modulator_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _gfdm_swig.simple_modulator_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(simple_modulator_cc_sptr self) -> std::string"""
        return _gfdm_swig.simple_modulator_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(simple_modulator_cc_sptr self, std::string name)"""
        return _gfdm_swig.simple_modulator_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(simple_modulator_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _gfdm_swig.simple_modulator_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(simple_modulator_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.simple_modulator_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(simple_modulator_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.simple_modulator_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(simple_modulator_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _gfdm_swig.simple_modulator_cc_sptr_message_subscribers(self, which_port)

simple_modulator_cc_sptr_swigregister = _gfdm_swig.simple_modulator_cc_sptr_swigregister
simple_modulator_cc_sptr_swigregister(simple_modulator_cc_sptr)


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

class simple_receiver_cc(object):
    """<+description of block+>"""

    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(n_timeslots, n_subcarriers, overlap, frequency_taps):
        """
        make(int n_timeslots, int n_subcarriers, int overlap, pmt_vector_cfloat frequency_taps) -> simple_receiver_cc_sptr

        Return a shared_ptr to a new instance of gfdm::simple_receiver_cc.

        To avoid accidental use of raw pointers, gfdm::simple_receiver_cc's constructor is in a private implementation class. gfdm::simple_receiver_cc::make is the public interface for creating new instances.

        Params: (n_timeslots, n_subcarriers, overlap, frequency_taps)
        """
        return _gfdm_swig.simple_receiver_cc_make(n_timeslots, n_subcarriers, overlap, frequency_taps)

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_simple_receiver_cc
    __del__ = lambda self: None
simple_receiver_cc_swigregister = _gfdm_swig.simple_receiver_cc_swigregister
simple_receiver_cc_swigregister(simple_receiver_cc)

def simple_receiver_cc_make(n_timeslots, n_subcarriers, overlap, frequency_taps):
    """
    simple_receiver_cc_make(int n_timeslots, int n_subcarriers, int overlap, pmt_vector_cfloat frequency_taps) -> simple_receiver_cc_sptr

    Return a shared_ptr to a new instance of gfdm::simple_receiver_cc.

    To avoid accidental use of raw pointers, gfdm::simple_receiver_cc's constructor is in a private implementation class. gfdm::simple_receiver_cc::make is the public interface for creating new instances.

    Params: (n_timeslots, n_subcarriers, overlap, frequency_taps)
    """
    return _gfdm_swig.simple_receiver_cc_make(n_timeslots, n_subcarriers, overlap, frequency_taps)

class simple_receiver_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::gfdm::simple_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::gfdm::simple_receiver_cc)> self) -> simple_receiver_cc_sptr
        __init__(boost::shared_ptr<(gr::gfdm::simple_receiver_cc)> self, simple_receiver_cc p) -> simple_receiver_cc_sptr
        """
        this = _gfdm_swig.new_simple_receiver_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(simple_receiver_cc_sptr self) -> simple_receiver_cc"""
        return _gfdm_swig.simple_receiver_cc_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_simple_receiver_cc_sptr
    __del__ = lambda self: None

    def make(self, n_timeslots, n_subcarriers, overlap, frequency_taps):
        """
        make(simple_receiver_cc_sptr self, int n_timeslots, int n_subcarriers, int overlap, pmt_vector_cfloat frequency_taps) -> simple_receiver_cc_sptr

        Return a shared_ptr to a new instance of gfdm::simple_receiver_cc.

        To avoid accidental use of raw pointers, gfdm::simple_receiver_cc's constructor is in a private implementation class. gfdm::simple_receiver_cc::make is the public interface for creating new instances.

        Params: (n_timeslots, n_subcarriers, overlap, frequency_taps)
        """
        return _gfdm_swig.simple_receiver_cc_sptr_make(self, n_timeslots, n_subcarriers, overlap, frequency_taps)


    def history(self):
        """history(simple_receiver_cc_sptr self) -> unsigned int"""
        return _gfdm_swig.simple_receiver_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(simple_receiver_cc_sptr self, int which, int delay)
        declare_sample_delay(simple_receiver_cc_sptr self, unsigned int delay)
        """
        return _gfdm_swig.simple_receiver_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(simple_receiver_cc_sptr self, int which) -> unsigned int"""
        return _gfdm_swig.simple_receiver_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(simple_receiver_cc_sptr self) -> int"""
        return _gfdm_swig.simple_receiver_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(simple_receiver_cc_sptr self) -> double"""
        return _gfdm_swig.simple_receiver_cc_sptr_relative_rate(self)


    def start(self):
        """start(simple_receiver_cc_sptr self) -> bool"""
        return _gfdm_swig.simple_receiver_cc_sptr_start(self)


    def stop(self):
        """stop(simple_receiver_cc_sptr self) -> bool"""
        return _gfdm_swig.simple_receiver_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(simple_receiver_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _gfdm_swig.simple_receiver_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(simple_receiver_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _gfdm_swig.simple_receiver_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(simple_receiver_cc_sptr self) -> int"""
        return _gfdm_swig.simple_receiver_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(simple_receiver_cc_sptr self, int m)"""
        return _gfdm_swig.simple_receiver_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(simple_receiver_cc_sptr self)"""
        return _gfdm_swig.simple_receiver_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(simple_receiver_cc_sptr self) -> bool"""
        return _gfdm_swig.simple_receiver_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(simple_receiver_cc_sptr self, int m)"""
        return _gfdm_swig.simple_receiver_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(simple_receiver_cc_sptr self) -> int"""
        return _gfdm_swig.simple_receiver_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(simple_receiver_cc_sptr self, int i) -> long"""
        return _gfdm_swig.simple_receiver_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(simple_receiver_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(simple_receiver_cc_sptr self, int port, long max_output_buffer)
        """
        return _gfdm_swig.simple_receiver_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(simple_receiver_cc_sptr self, int i) -> long"""
        return _gfdm_swig.simple_receiver_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(simple_receiver_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(simple_receiver_cc_sptr self, int port, long min_output_buffer)
        """
        return _gfdm_swig.simple_receiver_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(simple_receiver_cc_sptr self) -> float"""
        return _gfdm_swig.simple_receiver_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(simple_receiver_cc_sptr self) -> float"""
        return _gfdm_swig.simple_receiver_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(simple_receiver_cc_sptr self) -> float"""
        return _gfdm_swig.simple_receiver_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(simple_receiver_cc_sptr self) -> float"""
        return _gfdm_swig.simple_receiver_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(simple_receiver_cc_sptr self) -> float"""
        return _gfdm_swig.simple_receiver_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(simple_receiver_cc_sptr self) -> float"""
        return _gfdm_swig.simple_receiver_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(simple_receiver_cc_sptr self, int which) -> float
        pc_input_buffers_full(simple_receiver_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.simple_receiver_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(simple_receiver_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(simple_receiver_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.simple_receiver_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(simple_receiver_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(simple_receiver_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.simple_receiver_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(simple_receiver_cc_sptr self, int which) -> float
        pc_output_buffers_full(simple_receiver_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.simple_receiver_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(simple_receiver_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(simple_receiver_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.simple_receiver_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(simple_receiver_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(simple_receiver_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.simple_receiver_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(simple_receiver_cc_sptr self) -> float"""
        return _gfdm_swig.simple_receiver_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(simple_receiver_cc_sptr self) -> float"""
        return _gfdm_swig.simple_receiver_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(simple_receiver_cc_sptr self) -> float"""
        return _gfdm_swig.simple_receiver_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(simple_receiver_cc_sptr self) -> float"""
        return _gfdm_swig.simple_receiver_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(simple_receiver_cc_sptr self) -> float"""
        return _gfdm_swig.simple_receiver_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(simple_receiver_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _gfdm_swig.simple_receiver_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(simple_receiver_cc_sptr self)"""
        return _gfdm_swig.simple_receiver_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(simple_receiver_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.simple_receiver_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(simple_receiver_cc_sptr self) -> int"""
        return _gfdm_swig.simple_receiver_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(simple_receiver_cc_sptr self) -> int"""
        return _gfdm_swig.simple_receiver_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(simple_receiver_cc_sptr self, int priority) -> int"""
        return _gfdm_swig.simple_receiver_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(simple_receiver_cc_sptr self) -> std::string"""
        return _gfdm_swig.simple_receiver_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(simple_receiver_cc_sptr self) -> std::string"""
        return _gfdm_swig.simple_receiver_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(simple_receiver_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.simple_receiver_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(simple_receiver_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.simple_receiver_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(simple_receiver_cc_sptr self) -> long"""
        return _gfdm_swig.simple_receiver_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(simple_receiver_cc_sptr self) -> basic_block_sptr"""
        return _gfdm_swig.simple_receiver_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(simple_receiver_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _gfdm_swig.simple_receiver_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(simple_receiver_cc_sptr self) -> std::string"""
        return _gfdm_swig.simple_receiver_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(simple_receiver_cc_sptr self, std::string name)"""
        return _gfdm_swig.simple_receiver_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(simple_receiver_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _gfdm_swig.simple_receiver_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(simple_receiver_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.simple_receiver_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(simple_receiver_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.simple_receiver_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(simple_receiver_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _gfdm_swig.simple_receiver_cc_sptr_message_subscribers(self, which_port)

simple_receiver_cc_sptr_swigregister = _gfdm_swig.simple_receiver_cc_sptr_swigregister
simple_receiver_cc_sptr_swigregister(simple_receiver_cc_sptr)


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

class improved_sync_algorithm_kernel_cc(object):
    """Perform STO/CFO synchronization for multicarrier systems Compare: Awoseyila et. al. "Improved Preamble-Aided Timing Estimation for OFDM Systems"."""

    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, n_subcarriers, cp_len, preamble, max_ninput_size):
        """
        __init__(gr::gfdm::improved_sync_algorithm_kernel_cc self, int n_subcarriers, int cp_len, pmt_vector_cfloat preamble, int max_ninput_size) -> improved_sync_algorithm_kernel_cc



        Params: (n_subcarriers, cp_len, preamble, max_ninput_size)
        """
        this = _gfdm_swig.new_improved_sync_algorithm_kernel_cc(n_subcarriers, cp_len, preamble, max_ninput_size)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gfdm_swig.delete_improved_sync_algorithm_kernel_cc
    __del__ = lambda self: None

    def detect_frame_start(self, p_in, ninput_size):
        """
        detect_frame_start(improved_sync_algorithm_kernel_cc self, gr_complex const * p_in, int ninput_size) -> int



        Params: (p_in, ninput_size)
        """
        return _gfdm_swig.improved_sync_algorithm_kernel_cc_detect_frame_start(self, p_in, ninput_size)


    def max_ninput_size(self):
        """
        max_ninput_size(improved_sync_algorithm_kernel_cc self) -> int



        Params: (NONE)
        """
        return _gfdm_swig.improved_sync_algorithm_kernel_cc_max_ninput_size(self)


    def find_preamble(self, in_vec):
        """
        find_preamble(improved_sync_algorithm_kernel_cc self, pmt_vector_cfloat in_vec) -> int



        Params: (in_vec)
        """
        return _gfdm_swig.improved_sync_algorithm_kernel_cc_find_preamble(self, in_vec)


    def auto_correlate_preamble(self, in_vec):
        """
        auto_correlate_preamble(improved_sync_algorithm_kernel_cc self, pmt_vector_cfloat in_vec) -> pmt_vector_cfloat



        Params: (in_vec)
        """
        return _gfdm_swig.improved_sync_algorithm_kernel_cc_auto_correlate_preamble(self, in_vec)


    def abs_integrate_preamble(self, in_vec):
        """
        abs_integrate_preamble(improved_sync_algorithm_kernel_cc self, pmt_vector_cfloat in_vec) -> pmt_vector_float



        Params: (in_vec)
        """
        return _gfdm_swig.improved_sync_algorithm_kernel_cc_abs_integrate_preamble(self, in_vec)


    def find_peak_preamble(self, in_vec):
        """
        find_peak_preamble(improved_sync_algorithm_kernel_cc self, pmt_vector_float in_vec) -> int



        Params: (in_vec)
        """
        return _gfdm_swig.improved_sync_algorithm_kernel_cc_find_peak_preamble(self, in_vec)


    def calculate_normalized_cfo_preamble(self, val):
        """
        calculate_normalized_cfo_preamble(improved_sync_algorithm_kernel_cc self, gr_complex const val) -> float



        Params: (val)
        """
        return _gfdm_swig.improved_sync_algorithm_kernel_cc_calculate_normalized_cfo_preamble(self, val)


    def remove_cfo_preamble(self, in_vec, cfo):
        """
        remove_cfo_preamble(improved_sync_algorithm_kernel_cc self, pmt_vector_cfloat in_vec, float const cfo) -> pmt_vector_cfloat



        Params: (in_vec, cfo)
        """
        return _gfdm_swig.improved_sync_algorithm_kernel_cc_remove_cfo_preamble(self, in_vec, cfo)


    def cross_correlate_preamble(self, in_vec):
        """
        cross_correlate_preamble(improved_sync_algorithm_kernel_cc self, pmt_vector_cfloat in_vec) -> pmt_vector_cfloat



        Params: (in_vec)
        """
        return _gfdm_swig.improved_sync_algorithm_kernel_cc_cross_correlate_preamble(self, in_vec)


    def preamble(self):
        """
        preamble(improved_sync_algorithm_kernel_cc self) -> pmt_vector_cfloat



        Params: (NONE)
        """
        return _gfdm_swig.improved_sync_algorithm_kernel_cc_preamble(self)


    def set_false_alarm_probability(self, false_alarm_prob, ninput_size):
        """
        set_false_alarm_probability(improved_sync_algorithm_kernel_cc self, float false_alarm_prob, int ninput_size)



        Params: (false_alarm_prob, ninput_size)
        """
        return _gfdm_swig.improved_sync_algorithm_kernel_cc_set_false_alarm_probability(self, false_alarm_prob, ninput_size)


    def input_buffer(self):
        """
        input_buffer(improved_sync_algorithm_kernel_cc self) -> pmt_vector_cfloat



        Params: (NONE)
        """
        return _gfdm_swig.improved_sync_algorithm_kernel_cc_input_buffer(self)


    def auto_corr_buffer(self):
        """
        auto_corr_buffer(improved_sync_algorithm_kernel_cc self) -> pmt_vector_cfloat



        Params: (NONE)
        """
        return _gfdm_swig.improved_sync_algorithm_kernel_cc_auto_corr_buffer(self)


    def integration_buffer(self):
        """
        integration_buffer(improved_sync_algorithm_kernel_cc self) -> pmt_vector_float



        Params: (NONE)
        """
        return _gfdm_swig.improved_sync_algorithm_kernel_cc_integration_buffer(self)


    def auto_corr_integrate(self, in_vec):
        """
        auto_corr_integrate(improved_sync_algorithm_kernel_cc self, pmt_vector_cfloat in_vec) -> pmt_vector_float



        Params: (in_vec)
        """
        return _gfdm_swig.improved_sync_algorithm_kernel_cc_auto_corr_integrate(self, in_vec)

improved_sync_algorithm_kernel_cc_swigregister = _gfdm_swig.improved_sync_algorithm_kernel_cc_swigregister
improved_sync_algorithm_kernel_cc_swigregister(improved_sync_algorithm_kernel_cc)

class advanced_receiver_sb_cc(object):
    """advanced receiver working as sync block"""

    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(n_timeslots, n_subcarriers, overlap, ic_iter, frequency_taps, constellation, subcarrier_map, do_phase_compensation):
        """
        make(int n_timeslots, int n_subcarriers, int overlap, int ic_iter, pmt_vector_cfloat frequency_taps, constellation_sptr constellation, std::vector< int,std::allocator< int > > subcarrier_map, int do_phase_compensation) -> advanced_receiver_sb_cc_sptr

        Return a shared_ptr to a new instance of gfdm::advanced_receiver_sb_cc.

        To avoid accidental use of raw pointers, gfdm::advanced_receiver_sb_cc's constructor is in a private implementation class. gfdm::advanced_receiver_sb_cc::make is the public interface for creating new instances.

        Params: (n_timeslots, n_subcarriers, overlap, ic_iter, frequency_taps, constellation, subcarrier_map, do_phase_compensation)
        """
        return _gfdm_swig.advanced_receiver_sb_cc_make(n_timeslots, n_subcarriers, overlap, ic_iter, frequency_taps, constellation, subcarrier_map, do_phase_compensation)

    make = staticmethod(make)

    def set_phase_compensation(self, do_phase_compensation):
        """
        set_phase_compensation(advanced_receiver_sb_cc self, int do_phase_compensation)



        Params: (do_phase_compensation)
        """
        return _gfdm_swig.advanced_receiver_sb_cc_set_phase_compensation(self, do_phase_compensation)


    def get_phase_compensation(self):
        """
        get_phase_compensation(advanced_receiver_sb_cc self) -> int



        Params: (NONE)
        """
        return _gfdm_swig.advanced_receiver_sb_cc_get_phase_compensation(self)


    def set_ic(self, ic_iter):
        """
        set_ic(advanced_receiver_sb_cc self, int ic_iter)



        Params: (ic_iter)
        """
        return _gfdm_swig.advanced_receiver_sb_cc_set_ic(self, ic_iter)


    def get_ic(self):
        """
        get_ic(advanced_receiver_sb_cc self) -> int



        Params: ()
        """
        return _gfdm_swig.advanced_receiver_sb_cc_get_ic(self)

    __swig_destroy__ = _gfdm_swig.delete_advanced_receiver_sb_cc
    __del__ = lambda self: None
advanced_receiver_sb_cc_swigregister = _gfdm_swig.advanced_receiver_sb_cc_swigregister
advanced_receiver_sb_cc_swigregister(advanced_receiver_sb_cc)

def advanced_receiver_sb_cc_make(n_timeslots, n_subcarriers, overlap, ic_iter, frequency_taps, constellation, subcarrier_map, do_phase_compensation):
    """
    advanced_receiver_sb_cc_make(int n_timeslots, int n_subcarriers, int overlap, int ic_iter, pmt_vector_cfloat frequency_taps, constellation_sptr constellation, std::vector< int,std::allocator< int > > subcarrier_map, int do_phase_compensation) -> advanced_receiver_sb_cc_sptr

    Return a shared_ptr to a new instance of gfdm::advanced_receiver_sb_cc.

    To avoid accidental use of raw pointers, gfdm::advanced_receiver_sb_cc's constructor is in a private implementation class. gfdm::advanced_receiver_sb_cc::make is the public interface for creating new instances.

    Params: (n_timeslots, n_subcarriers, overlap, ic_iter, frequency_taps, constellation, subcarrier_map, do_phase_compensation)
    """
    return _gfdm_swig.advanced_receiver_sb_cc_make(n_timeslots, n_subcarriers, overlap, ic_iter, frequency_taps, constellation, subcarrier_map, do_phase_compensation)

class advanced_receiver_sb_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::gfdm::advanced_receiver_sb_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::gfdm::advanced_receiver_sb_cc)> self) -> advanced_receiver_sb_cc_sptr
        __init__(boost::shared_ptr<(gr::gfdm::advanced_receiver_sb_cc)> self, advanced_receiver_sb_cc p) -> advanced_receiver_sb_cc_sptr
        """
        this = _gfdm_swig.new_advanced_receiver_sb_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(advanced_receiver_sb_cc_sptr self) -> advanced_receiver_sb_cc"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_advanced_receiver_sb_cc_sptr
    __del__ = lambda self: None

    def make(self, n_timeslots, n_subcarriers, overlap, ic_iter, frequency_taps, constellation, subcarrier_map, do_phase_compensation):
        """
        make(advanced_receiver_sb_cc_sptr self, int n_timeslots, int n_subcarriers, int overlap, int ic_iter, pmt_vector_cfloat frequency_taps, constellation_sptr constellation, std::vector< int,std::allocator< int > > subcarrier_map, int do_phase_compensation) -> advanced_receiver_sb_cc_sptr

        Return a shared_ptr to a new instance of gfdm::advanced_receiver_sb_cc.

        To avoid accidental use of raw pointers, gfdm::advanced_receiver_sb_cc's constructor is in a private implementation class. gfdm::advanced_receiver_sb_cc::make is the public interface for creating new instances.

        Params: (n_timeslots, n_subcarriers, overlap, ic_iter, frequency_taps, constellation, subcarrier_map, do_phase_compensation)
        """
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_make(self, n_timeslots, n_subcarriers, overlap, ic_iter, frequency_taps, constellation, subcarrier_map, do_phase_compensation)


    def set_phase_compensation(self, do_phase_compensation):
        """
        set_phase_compensation(advanced_receiver_sb_cc_sptr self, int do_phase_compensation)



        Params: (do_phase_compensation)
        """
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_set_phase_compensation(self, do_phase_compensation)


    def get_phase_compensation(self):
        """
        get_phase_compensation(advanced_receiver_sb_cc_sptr self) -> int



        Params: (NONE)
        """
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_get_phase_compensation(self)


    def set_ic(self, ic_iter):
        """
        set_ic(advanced_receiver_sb_cc_sptr self, int ic_iter)



        Params: (ic_iter)
        """
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_set_ic(self, ic_iter)


    def get_ic(self):
        """
        get_ic(advanced_receiver_sb_cc_sptr self) -> int



        Params: ()
        """
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_get_ic(self)


    def history(self):
        """history(advanced_receiver_sb_cc_sptr self) -> unsigned int"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(advanced_receiver_sb_cc_sptr self, int which, int delay)
        declare_sample_delay(advanced_receiver_sb_cc_sptr self, unsigned int delay)
        """
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(advanced_receiver_sb_cc_sptr self, int which) -> unsigned int"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(advanced_receiver_sb_cc_sptr self) -> int"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(advanced_receiver_sb_cc_sptr self) -> double"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_relative_rate(self)


    def start(self):
        """start(advanced_receiver_sb_cc_sptr self) -> bool"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_start(self)


    def stop(self):
        """stop(advanced_receiver_sb_cc_sptr self) -> bool"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(advanced_receiver_sb_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(advanced_receiver_sb_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(advanced_receiver_sb_cc_sptr self) -> int"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(advanced_receiver_sb_cc_sptr self, int m)"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(advanced_receiver_sb_cc_sptr self)"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(advanced_receiver_sb_cc_sptr self) -> bool"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(advanced_receiver_sb_cc_sptr self, int m)"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(advanced_receiver_sb_cc_sptr self) -> int"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(advanced_receiver_sb_cc_sptr self, int i) -> long"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(advanced_receiver_sb_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(advanced_receiver_sb_cc_sptr self, int port, long max_output_buffer)
        """
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(advanced_receiver_sb_cc_sptr self, int i) -> long"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(advanced_receiver_sb_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(advanced_receiver_sb_cc_sptr self, int port, long min_output_buffer)
        """
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(advanced_receiver_sb_cc_sptr self) -> float"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(advanced_receiver_sb_cc_sptr self) -> float"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(advanced_receiver_sb_cc_sptr self) -> float"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(advanced_receiver_sb_cc_sptr self) -> float"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(advanced_receiver_sb_cc_sptr self) -> float"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(advanced_receiver_sb_cc_sptr self) -> float"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(advanced_receiver_sb_cc_sptr self, int which) -> float
        pc_input_buffers_full(advanced_receiver_sb_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(advanced_receiver_sb_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(advanced_receiver_sb_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(advanced_receiver_sb_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(advanced_receiver_sb_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(advanced_receiver_sb_cc_sptr self, int which) -> float
        pc_output_buffers_full(advanced_receiver_sb_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(advanced_receiver_sb_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(advanced_receiver_sb_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(advanced_receiver_sb_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(advanced_receiver_sb_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(advanced_receiver_sb_cc_sptr self) -> float"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(advanced_receiver_sb_cc_sptr self) -> float"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(advanced_receiver_sb_cc_sptr self) -> float"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(advanced_receiver_sb_cc_sptr self) -> float"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(advanced_receiver_sb_cc_sptr self) -> float"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(advanced_receiver_sb_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(advanced_receiver_sb_cc_sptr self)"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(advanced_receiver_sb_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(advanced_receiver_sb_cc_sptr self) -> int"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(advanced_receiver_sb_cc_sptr self) -> int"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(advanced_receiver_sb_cc_sptr self, int priority) -> int"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(advanced_receiver_sb_cc_sptr self) -> std::string"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(advanced_receiver_sb_cc_sptr self) -> std::string"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(advanced_receiver_sb_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(advanced_receiver_sb_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(advanced_receiver_sb_cc_sptr self) -> long"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(advanced_receiver_sb_cc_sptr self) -> basic_block_sptr"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(advanced_receiver_sb_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(advanced_receiver_sb_cc_sptr self) -> std::string"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(advanced_receiver_sb_cc_sptr self, std::string name)"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(advanced_receiver_sb_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(advanced_receiver_sb_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(advanced_receiver_sb_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(advanced_receiver_sb_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _gfdm_swig.advanced_receiver_sb_cc_sptr_message_subscribers(self, which_port)

advanced_receiver_sb_cc_sptr_swigregister = _gfdm_swig.advanced_receiver_sb_cc_sptr_swigregister
advanced_receiver_sb_cc_sptr_swigregister(advanced_receiver_sb_cc_sptr)


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

class resource_mapper_cc(object):
    """Take timeslots * active_subcarriers items and map them on a vector for GFDM modulation."""

    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(timeslots, subcarriers, active_subcarriers, subcarrier_map, per_timeslot):
        """
        make(int timeslots, int subcarriers, int active_subcarriers, std::vector< int,std::allocator< int > > subcarrier_map, bool per_timeslot) -> resource_mapper_cc_sptr

        Return a shared_ptr to a new instance of gfdm::resource_mapper_cc.

        To avoid accidental use of raw pointers, gfdm::resource_mapper_cc's constructor is in a private implementation class. gfdm::resource_mapper_cc::make is the public interface for creating new instances.

        Params: (timeslots, subcarriers, active_subcarriers, subcarrier_map, per_timeslot)
        """
        return _gfdm_swig.resource_mapper_cc_make(timeslots, subcarriers, active_subcarriers, subcarrier_map, per_timeslot)

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_resource_mapper_cc
    __del__ = lambda self: None
resource_mapper_cc_swigregister = _gfdm_swig.resource_mapper_cc_swigregister
resource_mapper_cc_swigregister(resource_mapper_cc)

def resource_mapper_cc_make(timeslots, subcarriers, active_subcarriers, subcarrier_map, per_timeslot):
    """
    resource_mapper_cc_make(int timeslots, int subcarriers, int active_subcarriers, std::vector< int,std::allocator< int > > subcarrier_map, bool per_timeslot) -> resource_mapper_cc_sptr

    Return a shared_ptr to a new instance of gfdm::resource_mapper_cc.

    To avoid accidental use of raw pointers, gfdm::resource_mapper_cc's constructor is in a private implementation class. gfdm::resource_mapper_cc::make is the public interface for creating new instances.

    Params: (timeslots, subcarriers, active_subcarriers, subcarrier_map, per_timeslot)
    """
    return _gfdm_swig.resource_mapper_cc_make(timeslots, subcarriers, active_subcarriers, subcarrier_map, per_timeslot)

class resource_mapper_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::gfdm::resource_mapper_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::gfdm::resource_mapper_cc)> self) -> resource_mapper_cc_sptr
        __init__(boost::shared_ptr<(gr::gfdm::resource_mapper_cc)> self, resource_mapper_cc p) -> resource_mapper_cc_sptr
        """
        this = _gfdm_swig.new_resource_mapper_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(resource_mapper_cc_sptr self) -> resource_mapper_cc"""
        return _gfdm_swig.resource_mapper_cc_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_resource_mapper_cc_sptr
    __del__ = lambda self: None

    def make(self, timeslots, subcarriers, active_subcarriers, subcarrier_map, per_timeslot):
        """
        make(resource_mapper_cc_sptr self, int timeslots, int subcarriers, int active_subcarriers, std::vector< int,std::allocator< int > > subcarrier_map, bool per_timeslot) -> resource_mapper_cc_sptr

        Return a shared_ptr to a new instance of gfdm::resource_mapper_cc.

        To avoid accidental use of raw pointers, gfdm::resource_mapper_cc's constructor is in a private implementation class. gfdm::resource_mapper_cc::make is the public interface for creating new instances.

        Params: (timeslots, subcarriers, active_subcarriers, subcarrier_map, per_timeslot)
        """
        return _gfdm_swig.resource_mapper_cc_sptr_make(self, timeslots, subcarriers, active_subcarriers, subcarrier_map, per_timeslot)


    def history(self):
        """history(resource_mapper_cc_sptr self) -> unsigned int"""
        return _gfdm_swig.resource_mapper_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(resource_mapper_cc_sptr self, int which, int delay)
        declare_sample_delay(resource_mapper_cc_sptr self, unsigned int delay)
        """
        return _gfdm_swig.resource_mapper_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(resource_mapper_cc_sptr self, int which) -> unsigned int"""
        return _gfdm_swig.resource_mapper_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(resource_mapper_cc_sptr self) -> int"""
        return _gfdm_swig.resource_mapper_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(resource_mapper_cc_sptr self) -> double"""
        return _gfdm_swig.resource_mapper_cc_sptr_relative_rate(self)


    def start(self):
        """start(resource_mapper_cc_sptr self) -> bool"""
        return _gfdm_swig.resource_mapper_cc_sptr_start(self)


    def stop(self):
        """stop(resource_mapper_cc_sptr self) -> bool"""
        return _gfdm_swig.resource_mapper_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(resource_mapper_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _gfdm_swig.resource_mapper_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(resource_mapper_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _gfdm_swig.resource_mapper_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(resource_mapper_cc_sptr self) -> int"""
        return _gfdm_swig.resource_mapper_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(resource_mapper_cc_sptr self, int m)"""
        return _gfdm_swig.resource_mapper_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(resource_mapper_cc_sptr self)"""
        return _gfdm_swig.resource_mapper_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(resource_mapper_cc_sptr self) -> bool"""
        return _gfdm_swig.resource_mapper_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(resource_mapper_cc_sptr self, int m)"""
        return _gfdm_swig.resource_mapper_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(resource_mapper_cc_sptr self) -> int"""
        return _gfdm_swig.resource_mapper_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(resource_mapper_cc_sptr self, int i) -> long"""
        return _gfdm_swig.resource_mapper_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(resource_mapper_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(resource_mapper_cc_sptr self, int port, long max_output_buffer)
        """
        return _gfdm_swig.resource_mapper_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(resource_mapper_cc_sptr self, int i) -> long"""
        return _gfdm_swig.resource_mapper_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(resource_mapper_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(resource_mapper_cc_sptr self, int port, long min_output_buffer)
        """
        return _gfdm_swig.resource_mapper_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(resource_mapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_mapper_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(resource_mapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_mapper_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(resource_mapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_mapper_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(resource_mapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_mapper_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(resource_mapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_mapper_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(resource_mapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_mapper_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(resource_mapper_cc_sptr self, int which) -> float
        pc_input_buffers_full(resource_mapper_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.resource_mapper_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(resource_mapper_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(resource_mapper_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.resource_mapper_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(resource_mapper_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(resource_mapper_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.resource_mapper_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(resource_mapper_cc_sptr self, int which) -> float
        pc_output_buffers_full(resource_mapper_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.resource_mapper_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(resource_mapper_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(resource_mapper_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.resource_mapper_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(resource_mapper_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(resource_mapper_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.resource_mapper_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(resource_mapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_mapper_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(resource_mapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_mapper_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(resource_mapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_mapper_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(resource_mapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_mapper_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(resource_mapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_mapper_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(resource_mapper_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _gfdm_swig.resource_mapper_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(resource_mapper_cc_sptr self)"""
        return _gfdm_swig.resource_mapper_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(resource_mapper_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.resource_mapper_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(resource_mapper_cc_sptr self) -> int"""
        return _gfdm_swig.resource_mapper_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(resource_mapper_cc_sptr self) -> int"""
        return _gfdm_swig.resource_mapper_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(resource_mapper_cc_sptr self, int priority) -> int"""
        return _gfdm_swig.resource_mapper_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(resource_mapper_cc_sptr self) -> std::string"""
        return _gfdm_swig.resource_mapper_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(resource_mapper_cc_sptr self) -> std::string"""
        return _gfdm_swig.resource_mapper_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(resource_mapper_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.resource_mapper_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(resource_mapper_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.resource_mapper_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(resource_mapper_cc_sptr self) -> long"""
        return _gfdm_swig.resource_mapper_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(resource_mapper_cc_sptr self) -> basic_block_sptr"""
        return _gfdm_swig.resource_mapper_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(resource_mapper_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _gfdm_swig.resource_mapper_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(resource_mapper_cc_sptr self) -> std::string"""
        return _gfdm_swig.resource_mapper_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(resource_mapper_cc_sptr self, std::string name)"""
        return _gfdm_swig.resource_mapper_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(resource_mapper_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _gfdm_swig.resource_mapper_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(resource_mapper_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.resource_mapper_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(resource_mapper_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.resource_mapper_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(resource_mapper_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _gfdm_swig.resource_mapper_cc_sptr_message_subscribers(self, which_port)

resource_mapper_cc_sptr_swigregister = _gfdm_swig.resource_mapper_cc_sptr_swigregister
resource_mapper_cc_sptr_swigregister(resource_mapper_cc_sptr)


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

class frame_energy_detector_cc(object):
    """Detect frames based on energy ramp detection."""

    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, average_len, frame_len, backoff_len, tag_key):
        """
        make(float alpha, int average_len, int frame_len, int backoff_len, std::string const & tag_key) -> frame_energy_detector_cc_sptr

        Return a shared_ptr to a new instance of gfdm::frame_energy_detector_cc.

        To avoid accidental use of raw pointers, gfdm::frame_energy_detector_cc's constructor is in a private implementation class. gfdm::frame_energy_detector_cc::make is the public interface for creating new instances.

        Params: (alpha, average_len, frame_len, backoff_len, tag_key)
        """
        return _gfdm_swig.frame_energy_detector_cc_make(alpha, average_len, frame_len, backoff_len, tag_key)

    make = staticmethod(make)

    def alpha(self):
        """
        alpha(frame_energy_detector_cc self) -> float



        Params: (NONE)
        """
        return _gfdm_swig.frame_energy_detector_cc_alpha(self)


    def set_alpha(self, alpha):
        """
        set_alpha(frame_energy_detector_cc self, float alpha)



        Params: (alpha)
        """
        return _gfdm_swig.frame_energy_detector_cc_set_alpha(self, alpha)


    def backoff_len(self):
        """
        backoff_len(frame_energy_detector_cc self) -> int



        Params: (NONE)
        """
        return _gfdm_swig.frame_energy_detector_cc_backoff_len(self)


    def set_backoff_len(self, backoff_len):
        """
        set_backoff_len(frame_energy_detector_cc self, int backoff_len)



        Params: (backoff_len)
        """
        return _gfdm_swig.frame_energy_detector_cc_set_backoff_len(self, backoff_len)

    __swig_destroy__ = _gfdm_swig.delete_frame_energy_detector_cc
    __del__ = lambda self: None
frame_energy_detector_cc_swigregister = _gfdm_swig.frame_energy_detector_cc_swigregister
frame_energy_detector_cc_swigregister(frame_energy_detector_cc)

def frame_energy_detector_cc_make(alpha, average_len, frame_len, backoff_len, tag_key):
    """
    frame_energy_detector_cc_make(float alpha, int average_len, int frame_len, int backoff_len, std::string const & tag_key) -> frame_energy_detector_cc_sptr

    Return a shared_ptr to a new instance of gfdm::frame_energy_detector_cc.

    To avoid accidental use of raw pointers, gfdm::frame_energy_detector_cc's constructor is in a private implementation class. gfdm::frame_energy_detector_cc::make is the public interface for creating new instances.

    Params: (alpha, average_len, frame_len, backoff_len, tag_key)
    """
    return _gfdm_swig.frame_energy_detector_cc_make(alpha, average_len, frame_len, backoff_len, tag_key)

class frame_energy_detector_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::gfdm::frame_energy_detector_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::gfdm::frame_energy_detector_cc)> self) -> frame_energy_detector_cc_sptr
        __init__(boost::shared_ptr<(gr::gfdm::frame_energy_detector_cc)> self, frame_energy_detector_cc p) -> frame_energy_detector_cc_sptr
        """
        this = _gfdm_swig.new_frame_energy_detector_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(frame_energy_detector_cc_sptr self) -> frame_energy_detector_cc"""
        return _gfdm_swig.frame_energy_detector_cc_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_frame_energy_detector_cc_sptr
    __del__ = lambda self: None

    def make(self, alpha, average_len, frame_len, backoff_len, tag_key):
        """
        make(frame_energy_detector_cc_sptr self, float alpha, int average_len, int frame_len, int backoff_len, std::string const & tag_key) -> frame_energy_detector_cc_sptr

        Return a shared_ptr to a new instance of gfdm::frame_energy_detector_cc.

        To avoid accidental use of raw pointers, gfdm::frame_energy_detector_cc's constructor is in a private implementation class. gfdm::frame_energy_detector_cc::make is the public interface for creating new instances.

        Params: (alpha, average_len, frame_len, backoff_len, tag_key)
        """
        return _gfdm_swig.frame_energy_detector_cc_sptr_make(self, alpha, average_len, frame_len, backoff_len, tag_key)


    def alpha(self):
        """
        alpha(frame_energy_detector_cc_sptr self) -> float



        Params: (NONE)
        """
        return _gfdm_swig.frame_energy_detector_cc_sptr_alpha(self)


    def set_alpha(self, alpha):
        """
        set_alpha(frame_energy_detector_cc_sptr self, float alpha)



        Params: (alpha)
        """
        return _gfdm_swig.frame_energy_detector_cc_sptr_set_alpha(self, alpha)


    def backoff_len(self):
        """
        backoff_len(frame_energy_detector_cc_sptr self) -> int



        Params: (NONE)
        """
        return _gfdm_swig.frame_energy_detector_cc_sptr_backoff_len(self)


    def set_backoff_len(self, backoff_len):
        """
        set_backoff_len(frame_energy_detector_cc_sptr self, int backoff_len)



        Params: (backoff_len)
        """
        return _gfdm_swig.frame_energy_detector_cc_sptr_set_backoff_len(self, backoff_len)


    def history(self):
        """history(frame_energy_detector_cc_sptr self) -> unsigned int"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(frame_energy_detector_cc_sptr self, int which, int delay)
        declare_sample_delay(frame_energy_detector_cc_sptr self, unsigned int delay)
        """
        return _gfdm_swig.frame_energy_detector_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(frame_energy_detector_cc_sptr self, int which) -> unsigned int"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(frame_energy_detector_cc_sptr self) -> int"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(frame_energy_detector_cc_sptr self) -> double"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_relative_rate(self)


    def start(self):
        """start(frame_energy_detector_cc_sptr self) -> bool"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_start(self)


    def stop(self):
        """stop(frame_energy_detector_cc_sptr self) -> bool"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(frame_energy_detector_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(frame_energy_detector_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(frame_energy_detector_cc_sptr self) -> int"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(frame_energy_detector_cc_sptr self, int m)"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(frame_energy_detector_cc_sptr self)"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(frame_energy_detector_cc_sptr self) -> bool"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(frame_energy_detector_cc_sptr self, int m)"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(frame_energy_detector_cc_sptr self) -> int"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(frame_energy_detector_cc_sptr self, int i) -> long"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(frame_energy_detector_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(frame_energy_detector_cc_sptr self, int port, long max_output_buffer)
        """
        return _gfdm_swig.frame_energy_detector_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(frame_energy_detector_cc_sptr self, int i) -> long"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(frame_energy_detector_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(frame_energy_detector_cc_sptr self, int port, long min_output_buffer)
        """
        return _gfdm_swig.frame_energy_detector_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(frame_energy_detector_cc_sptr self) -> float"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(frame_energy_detector_cc_sptr self) -> float"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(frame_energy_detector_cc_sptr self) -> float"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(frame_energy_detector_cc_sptr self) -> float"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(frame_energy_detector_cc_sptr self) -> float"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(frame_energy_detector_cc_sptr self) -> float"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(frame_energy_detector_cc_sptr self, int which) -> float
        pc_input_buffers_full(frame_energy_detector_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.frame_energy_detector_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(frame_energy_detector_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(frame_energy_detector_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.frame_energy_detector_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(frame_energy_detector_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(frame_energy_detector_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.frame_energy_detector_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(frame_energy_detector_cc_sptr self, int which) -> float
        pc_output_buffers_full(frame_energy_detector_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.frame_energy_detector_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(frame_energy_detector_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(frame_energy_detector_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.frame_energy_detector_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(frame_energy_detector_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(frame_energy_detector_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.frame_energy_detector_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(frame_energy_detector_cc_sptr self) -> float"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(frame_energy_detector_cc_sptr self) -> float"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(frame_energy_detector_cc_sptr self) -> float"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(frame_energy_detector_cc_sptr self) -> float"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(frame_energy_detector_cc_sptr self) -> float"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(frame_energy_detector_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(frame_energy_detector_cc_sptr self)"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(frame_energy_detector_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(frame_energy_detector_cc_sptr self) -> int"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(frame_energy_detector_cc_sptr self) -> int"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(frame_energy_detector_cc_sptr self, int priority) -> int"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(frame_energy_detector_cc_sptr self) -> std::string"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(frame_energy_detector_cc_sptr self) -> std::string"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(frame_energy_detector_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(frame_energy_detector_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(frame_energy_detector_cc_sptr self) -> long"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(frame_energy_detector_cc_sptr self) -> basic_block_sptr"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(frame_energy_detector_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(frame_energy_detector_cc_sptr self) -> std::string"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(frame_energy_detector_cc_sptr self, std::string name)"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(frame_energy_detector_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _gfdm_swig.frame_energy_detector_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(frame_energy_detector_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(frame_energy_detector_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(frame_energy_detector_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _gfdm_swig.frame_energy_detector_cc_sptr_message_subscribers(self, which_port)

frame_energy_detector_cc_sptr_swigregister = _gfdm_swig.frame_energy_detector_cc_sptr_swigregister
frame_energy_detector_cc_sptr_swigregister(frame_energy_detector_cc_sptr)


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

class simple_preamble_sync_cc(object):
    """Synchronizes GFDM frame to known preamble."""

    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(frame_len, subcarriers, cp_len, preamble, in_key, out_key):
        """
        make(int frame_len, int subcarriers, int cp_len, pmt_vector_cfloat preamble, std::string const & in_key, std::string const & out_key) -> simple_preamble_sync_cc_sptr

        Return a shared_ptr to a new instance of gfdm::simple_preamble_sync_cc.

        To avoid accidental use of raw pointers, gfdm::simple_preamble_sync_cc's constructor is in a private implementation class. gfdm::simple_preamble_sync_cc::make is the public interface for creating new instances.

        Params: (frame_len, subcarriers, cp_len, preamble, in_key, out_key)
        """
        return _gfdm_swig.simple_preamble_sync_cc_make(frame_len, subcarriers, cp_len, preamble, in_key, out_key)

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_simple_preamble_sync_cc
    __del__ = lambda self: None
simple_preamble_sync_cc_swigregister = _gfdm_swig.simple_preamble_sync_cc_swigregister
simple_preamble_sync_cc_swigregister(simple_preamble_sync_cc)

def simple_preamble_sync_cc_make(frame_len, subcarriers, cp_len, preamble, in_key, out_key):
    """
    simple_preamble_sync_cc_make(int frame_len, int subcarriers, int cp_len, pmt_vector_cfloat preamble, std::string const & in_key, std::string const & out_key) -> simple_preamble_sync_cc_sptr

    Return a shared_ptr to a new instance of gfdm::simple_preamble_sync_cc.

    To avoid accidental use of raw pointers, gfdm::simple_preamble_sync_cc's constructor is in a private implementation class. gfdm::simple_preamble_sync_cc::make is the public interface for creating new instances.

    Params: (frame_len, subcarriers, cp_len, preamble, in_key, out_key)
    """
    return _gfdm_swig.simple_preamble_sync_cc_make(frame_len, subcarriers, cp_len, preamble, in_key, out_key)

class simple_preamble_sync_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::gfdm::simple_preamble_sync_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::gfdm::simple_preamble_sync_cc)> self) -> simple_preamble_sync_cc_sptr
        __init__(boost::shared_ptr<(gr::gfdm::simple_preamble_sync_cc)> self, simple_preamble_sync_cc p) -> simple_preamble_sync_cc_sptr
        """
        this = _gfdm_swig.new_simple_preamble_sync_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(simple_preamble_sync_cc_sptr self) -> simple_preamble_sync_cc"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_simple_preamble_sync_cc_sptr
    __del__ = lambda self: None

    def make(self, frame_len, subcarriers, cp_len, preamble, in_key, out_key):
        """
        make(simple_preamble_sync_cc_sptr self, int frame_len, int subcarriers, int cp_len, pmt_vector_cfloat preamble, std::string const & in_key, std::string const & out_key) -> simple_preamble_sync_cc_sptr

        Return a shared_ptr to a new instance of gfdm::simple_preamble_sync_cc.

        To avoid accidental use of raw pointers, gfdm::simple_preamble_sync_cc's constructor is in a private implementation class. gfdm::simple_preamble_sync_cc::make is the public interface for creating new instances.

        Params: (frame_len, subcarriers, cp_len, preamble, in_key, out_key)
        """
        return _gfdm_swig.simple_preamble_sync_cc_sptr_make(self, frame_len, subcarriers, cp_len, preamble, in_key, out_key)


    def history(self):
        """history(simple_preamble_sync_cc_sptr self) -> unsigned int"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(simple_preamble_sync_cc_sptr self, int which, int delay)
        declare_sample_delay(simple_preamble_sync_cc_sptr self, unsigned int delay)
        """
        return _gfdm_swig.simple_preamble_sync_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(simple_preamble_sync_cc_sptr self, int which) -> unsigned int"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(simple_preamble_sync_cc_sptr self) -> int"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(simple_preamble_sync_cc_sptr self) -> double"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_relative_rate(self)


    def start(self):
        """start(simple_preamble_sync_cc_sptr self) -> bool"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_start(self)


    def stop(self):
        """stop(simple_preamble_sync_cc_sptr self) -> bool"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(simple_preamble_sync_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(simple_preamble_sync_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(simple_preamble_sync_cc_sptr self) -> int"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(simple_preamble_sync_cc_sptr self, int m)"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(simple_preamble_sync_cc_sptr self)"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(simple_preamble_sync_cc_sptr self) -> bool"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(simple_preamble_sync_cc_sptr self, int m)"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(simple_preamble_sync_cc_sptr self) -> int"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(simple_preamble_sync_cc_sptr self, int i) -> long"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(simple_preamble_sync_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(simple_preamble_sync_cc_sptr self, int port, long max_output_buffer)
        """
        return _gfdm_swig.simple_preamble_sync_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(simple_preamble_sync_cc_sptr self, int i) -> long"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(simple_preamble_sync_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(simple_preamble_sync_cc_sptr self, int port, long min_output_buffer)
        """
        return _gfdm_swig.simple_preamble_sync_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(simple_preamble_sync_cc_sptr self) -> float"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(simple_preamble_sync_cc_sptr self) -> float"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(simple_preamble_sync_cc_sptr self) -> float"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(simple_preamble_sync_cc_sptr self) -> float"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(simple_preamble_sync_cc_sptr self) -> float"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(simple_preamble_sync_cc_sptr self) -> float"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(simple_preamble_sync_cc_sptr self, int which) -> float
        pc_input_buffers_full(simple_preamble_sync_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.simple_preamble_sync_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(simple_preamble_sync_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(simple_preamble_sync_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.simple_preamble_sync_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(simple_preamble_sync_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(simple_preamble_sync_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.simple_preamble_sync_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(simple_preamble_sync_cc_sptr self, int which) -> float
        pc_output_buffers_full(simple_preamble_sync_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.simple_preamble_sync_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(simple_preamble_sync_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(simple_preamble_sync_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.simple_preamble_sync_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(simple_preamble_sync_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(simple_preamble_sync_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.simple_preamble_sync_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(simple_preamble_sync_cc_sptr self) -> float"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(simple_preamble_sync_cc_sptr self) -> float"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(simple_preamble_sync_cc_sptr self) -> float"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(simple_preamble_sync_cc_sptr self) -> float"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(simple_preamble_sync_cc_sptr self) -> float"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(simple_preamble_sync_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(simple_preamble_sync_cc_sptr self)"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(simple_preamble_sync_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(simple_preamble_sync_cc_sptr self) -> int"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(simple_preamble_sync_cc_sptr self) -> int"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(simple_preamble_sync_cc_sptr self, int priority) -> int"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(simple_preamble_sync_cc_sptr self) -> std::string"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(simple_preamble_sync_cc_sptr self) -> std::string"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(simple_preamble_sync_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(simple_preamble_sync_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(simple_preamble_sync_cc_sptr self) -> long"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(simple_preamble_sync_cc_sptr self) -> basic_block_sptr"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(simple_preamble_sync_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(simple_preamble_sync_cc_sptr self) -> std::string"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(simple_preamble_sync_cc_sptr self, std::string name)"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(simple_preamble_sync_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(simple_preamble_sync_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(simple_preamble_sync_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(simple_preamble_sync_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _gfdm_swig.simple_preamble_sync_cc_sptr_message_subscribers(self, which_port)

simple_preamble_sync_cc_sptr_swigregister = _gfdm_swig.simple_preamble_sync_cc_sptr_swigregister
simple_preamble_sync_cc_sptr_swigregister(simple_preamble_sync_cc_sptr)


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

class resource_demapper_cc(object):
    """Demap info symbols from GFDM frame."""

    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(timeslots, subcarriers, active_subcarriers, subcarrier_map, per_timeslot):
        """
        make(int timeslots, int subcarriers, int active_subcarriers, std::vector< int,std::allocator< int > > subcarrier_map, bool per_timeslot) -> resource_demapper_cc_sptr

        Return a shared_ptr to a new instance of gfdm::resource_demapper_cc.

        To avoid accidental use of raw pointers, gfdm::resource_demapper_cc's constructor is in a private implementation class. gfdm::resource_demapper_cc::make is the public interface for creating new instances.

        Params: (timeslots, subcarriers, active_subcarriers, subcarrier_map, per_timeslot)
        """
        return _gfdm_swig.resource_demapper_cc_make(timeslots, subcarriers, active_subcarriers, subcarrier_map, per_timeslot)

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_resource_demapper_cc
    __del__ = lambda self: None
resource_demapper_cc_swigregister = _gfdm_swig.resource_demapper_cc_swigregister
resource_demapper_cc_swigregister(resource_demapper_cc)

def resource_demapper_cc_make(timeslots, subcarriers, active_subcarriers, subcarrier_map, per_timeslot):
    """
    resource_demapper_cc_make(int timeslots, int subcarriers, int active_subcarriers, std::vector< int,std::allocator< int > > subcarrier_map, bool per_timeslot) -> resource_demapper_cc_sptr

    Return a shared_ptr to a new instance of gfdm::resource_demapper_cc.

    To avoid accidental use of raw pointers, gfdm::resource_demapper_cc's constructor is in a private implementation class. gfdm::resource_demapper_cc::make is the public interface for creating new instances.

    Params: (timeslots, subcarriers, active_subcarriers, subcarrier_map, per_timeslot)
    """
    return _gfdm_swig.resource_demapper_cc_make(timeslots, subcarriers, active_subcarriers, subcarrier_map, per_timeslot)

class resource_demapper_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::gfdm::resource_demapper_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::gfdm::resource_demapper_cc)> self) -> resource_demapper_cc_sptr
        __init__(boost::shared_ptr<(gr::gfdm::resource_demapper_cc)> self, resource_demapper_cc p) -> resource_demapper_cc_sptr
        """
        this = _gfdm_swig.new_resource_demapper_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(resource_demapper_cc_sptr self) -> resource_demapper_cc"""
        return _gfdm_swig.resource_demapper_cc_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_resource_demapper_cc_sptr
    __del__ = lambda self: None

    def make(self, timeslots, subcarriers, active_subcarriers, subcarrier_map, per_timeslot):
        """
        make(resource_demapper_cc_sptr self, int timeslots, int subcarriers, int active_subcarriers, std::vector< int,std::allocator< int > > subcarrier_map, bool per_timeslot) -> resource_demapper_cc_sptr

        Return a shared_ptr to a new instance of gfdm::resource_demapper_cc.

        To avoid accidental use of raw pointers, gfdm::resource_demapper_cc's constructor is in a private implementation class. gfdm::resource_demapper_cc::make is the public interface for creating new instances.

        Params: (timeslots, subcarriers, active_subcarriers, subcarrier_map, per_timeslot)
        """
        return _gfdm_swig.resource_demapper_cc_sptr_make(self, timeslots, subcarriers, active_subcarriers, subcarrier_map, per_timeslot)


    def history(self):
        """history(resource_demapper_cc_sptr self) -> unsigned int"""
        return _gfdm_swig.resource_demapper_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(resource_demapper_cc_sptr self, int which, int delay)
        declare_sample_delay(resource_demapper_cc_sptr self, unsigned int delay)
        """
        return _gfdm_swig.resource_demapper_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(resource_demapper_cc_sptr self, int which) -> unsigned int"""
        return _gfdm_swig.resource_demapper_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(resource_demapper_cc_sptr self) -> int"""
        return _gfdm_swig.resource_demapper_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(resource_demapper_cc_sptr self) -> double"""
        return _gfdm_swig.resource_demapper_cc_sptr_relative_rate(self)


    def start(self):
        """start(resource_demapper_cc_sptr self) -> bool"""
        return _gfdm_swig.resource_demapper_cc_sptr_start(self)


    def stop(self):
        """stop(resource_demapper_cc_sptr self) -> bool"""
        return _gfdm_swig.resource_demapper_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(resource_demapper_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _gfdm_swig.resource_demapper_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(resource_demapper_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _gfdm_swig.resource_demapper_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(resource_demapper_cc_sptr self) -> int"""
        return _gfdm_swig.resource_demapper_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(resource_demapper_cc_sptr self, int m)"""
        return _gfdm_swig.resource_demapper_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(resource_demapper_cc_sptr self)"""
        return _gfdm_swig.resource_demapper_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(resource_demapper_cc_sptr self) -> bool"""
        return _gfdm_swig.resource_demapper_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(resource_demapper_cc_sptr self, int m)"""
        return _gfdm_swig.resource_demapper_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(resource_demapper_cc_sptr self) -> int"""
        return _gfdm_swig.resource_demapper_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(resource_demapper_cc_sptr self, int i) -> long"""
        return _gfdm_swig.resource_demapper_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(resource_demapper_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(resource_demapper_cc_sptr self, int port, long max_output_buffer)
        """
        return _gfdm_swig.resource_demapper_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(resource_demapper_cc_sptr self, int i) -> long"""
        return _gfdm_swig.resource_demapper_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(resource_demapper_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(resource_demapper_cc_sptr self, int port, long min_output_buffer)
        """
        return _gfdm_swig.resource_demapper_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(resource_demapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_demapper_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(resource_demapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_demapper_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(resource_demapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_demapper_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(resource_demapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_demapper_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(resource_demapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_demapper_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(resource_demapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_demapper_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(resource_demapper_cc_sptr self, int which) -> float
        pc_input_buffers_full(resource_demapper_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.resource_demapper_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(resource_demapper_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(resource_demapper_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.resource_demapper_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(resource_demapper_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(resource_demapper_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.resource_demapper_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(resource_demapper_cc_sptr self, int which) -> float
        pc_output_buffers_full(resource_demapper_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.resource_demapper_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(resource_demapper_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(resource_demapper_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.resource_demapper_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(resource_demapper_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(resource_demapper_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.resource_demapper_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(resource_demapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_demapper_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(resource_demapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_demapper_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(resource_demapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_demapper_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(resource_demapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_demapper_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(resource_demapper_cc_sptr self) -> float"""
        return _gfdm_swig.resource_demapper_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(resource_demapper_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _gfdm_swig.resource_demapper_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(resource_demapper_cc_sptr self)"""
        return _gfdm_swig.resource_demapper_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(resource_demapper_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.resource_demapper_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(resource_demapper_cc_sptr self) -> int"""
        return _gfdm_swig.resource_demapper_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(resource_demapper_cc_sptr self) -> int"""
        return _gfdm_swig.resource_demapper_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(resource_demapper_cc_sptr self, int priority) -> int"""
        return _gfdm_swig.resource_demapper_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(resource_demapper_cc_sptr self) -> std::string"""
        return _gfdm_swig.resource_demapper_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(resource_demapper_cc_sptr self) -> std::string"""
        return _gfdm_swig.resource_demapper_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(resource_demapper_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.resource_demapper_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(resource_demapper_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.resource_demapper_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(resource_demapper_cc_sptr self) -> long"""
        return _gfdm_swig.resource_demapper_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(resource_demapper_cc_sptr self) -> basic_block_sptr"""
        return _gfdm_swig.resource_demapper_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(resource_demapper_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _gfdm_swig.resource_demapper_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(resource_demapper_cc_sptr self) -> std::string"""
        return _gfdm_swig.resource_demapper_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(resource_demapper_cc_sptr self, std::string name)"""
        return _gfdm_swig.resource_demapper_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(resource_demapper_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _gfdm_swig.resource_demapper_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(resource_demapper_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.resource_demapper_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(resource_demapper_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.resource_demapper_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(resource_demapper_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _gfdm_swig.resource_demapper_cc_sptr_message_subscribers(self, which_port)

resource_demapper_cc_sptr_swigregister = _gfdm_swig.resource_demapper_cc_sptr_swigregister
resource_demapper_cc_sptr_swigregister(resource_demapper_cc_sptr)


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

class extract_burst_cc(object):
    """<+description of block+>"""

    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(burst_len, tag_backoff, burst_start_tag, activate_cfo_correction=False):
        """
        make(int burst_len, int tag_backoff, std::string burst_start_tag, bool activate_cfo_correction=False) -> extract_burst_cc_sptr

        Return a shared_ptr to a new instance of gfdm::extract_burst_cc.

        To avoid accidental use of raw pointers, gfdm::extract_burst_cc's constructor is in a private implementation class. gfdm::extract_burst_cc::make is the public interface for creating new instances.

        Params: (burst_len, tag_backoff, burst_start_tag, activate_cfo_correction)
        """
        return _gfdm_swig.extract_burst_cc_make(burst_len, tag_backoff, burst_start_tag, activate_cfo_correction)

    make = staticmethod(make)

    def activate_cfo_compensation(self, activate_cfo_compensation):
        """
        activate_cfo_compensation(extract_burst_cc self, bool activate_cfo_compensation)



        Params: (activate_cfo_compensation)
        """
        return _gfdm_swig.extract_burst_cc_activate_cfo_compensation(self, activate_cfo_compensation)

    __swig_destroy__ = _gfdm_swig.delete_extract_burst_cc
    __del__ = lambda self: None
extract_burst_cc_swigregister = _gfdm_swig.extract_burst_cc_swigregister
extract_burst_cc_swigregister(extract_burst_cc)

def extract_burst_cc_make(burst_len, tag_backoff, burst_start_tag, activate_cfo_correction=False):
    """
    extract_burst_cc_make(int burst_len, int tag_backoff, std::string burst_start_tag, bool activate_cfo_correction=False) -> extract_burst_cc_sptr

    Return a shared_ptr to a new instance of gfdm::extract_burst_cc.

    To avoid accidental use of raw pointers, gfdm::extract_burst_cc's constructor is in a private implementation class. gfdm::extract_burst_cc::make is the public interface for creating new instances.

    Params: (burst_len, tag_backoff, burst_start_tag, activate_cfo_correction)
    """
    return _gfdm_swig.extract_burst_cc_make(burst_len, tag_backoff, burst_start_tag, activate_cfo_correction)

class extract_burst_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::gfdm::extract_burst_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::gfdm::extract_burst_cc)> self) -> extract_burst_cc_sptr
        __init__(boost::shared_ptr<(gr::gfdm::extract_burst_cc)> self, extract_burst_cc p) -> extract_burst_cc_sptr
        """
        this = _gfdm_swig.new_extract_burst_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(extract_burst_cc_sptr self) -> extract_burst_cc"""
        return _gfdm_swig.extract_burst_cc_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_extract_burst_cc_sptr
    __del__ = lambda self: None

    def make(self, burst_len, tag_backoff, burst_start_tag, activate_cfo_correction=False):
        """
        make(extract_burst_cc_sptr self, int burst_len, int tag_backoff, std::string burst_start_tag, bool activate_cfo_correction=False) -> extract_burst_cc_sptr

        Return a shared_ptr to a new instance of gfdm::extract_burst_cc.

        To avoid accidental use of raw pointers, gfdm::extract_burst_cc's constructor is in a private implementation class. gfdm::extract_burst_cc::make is the public interface for creating new instances.

        Params: (burst_len, tag_backoff, burst_start_tag, activate_cfo_correction)
        """
        return _gfdm_swig.extract_burst_cc_sptr_make(self, burst_len, tag_backoff, burst_start_tag, activate_cfo_correction)


    def activate_cfo_compensation(self, activate_cfo_compensation):
        """
        activate_cfo_compensation(extract_burst_cc_sptr self, bool activate_cfo_compensation)



        Params: (activate_cfo_compensation)
        """
        return _gfdm_swig.extract_burst_cc_sptr_activate_cfo_compensation(self, activate_cfo_compensation)


    def history(self):
        """history(extract_burst_cc_sptr self) -> unsigned int"""
        return _gfdm_swig.extract_burst_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(extract_burst_cc_sptr self, int which, int delay)
        declare_sample_delay(extract_burst_cc_sptr self, unsigned int delay)
        """
        return _gfdm_swig.extract_burst_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(extract_burst_cc_sptr self, int which) -> unsigned int"""
        return _gfdm_swig.extract_burst_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(extract_burst_cc_sptr self) -> int"""
        return _gfdm_swig.extract_burst_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(extract_burst_cc_sptr self) -> double"""
        return _gfdm_swig.extract_burst_cc_sptr_relative_rate(self)


    def start(self):
        """start(extract_burst_cc_sptr self) -> bool"""
        return _gfdm_swig.extract_burst_cc_sptr_start(self)


    def stop(self):
        """stop(extract_burst_cc_sptr self) -> bool"""
        return _gfdm_swig.extract_burst_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(extract_burst_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _gfdm_swig.extract_burst_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(extract_burst_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _gfdm_swig.extract_burst_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(extract_burst_cc_sptr self) -> int"""
        return _gfdm_swig.extract_burst_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(extract_burst_cc_sptr self, int m)"""
        return _gfdm_swig.extract_burst_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(extract_burst_cc_sptr self)"""
        return _gfdm_swig.extract_burst_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(extract_burst_cc_sptr self) -> bool"""
        return _gfdm_swig.extract_burst_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(extract_burst_cc_sptr self, int m)"""
        return _gfdm_swig.extract_burst_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(extract_burst_cc_sptr self) -> int"""
        return _gfdm_swig.extract_burst_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(extract_burst_cc_sptr self, int i) -> long"""
        return _gfdm_swig.extract_burst_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(extract_burst_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(extract_burst_cc_sptr self, int port, long max_output_buffer)
        """
        return _gfdm_swig.extract_burst_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(extract_burst_cc_sptr self, int i) -> long"""
        return _gfdm_swig.extract_burst_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(extract_burst_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(extract_burst_cc_sptr self, int port, long min_output_buffer)
        """
        return _gfdm_swig.extract_burst_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(extract_burst_cc_sptr self) -> float"""
        return _gfdm_swig.extract_burst_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(extract_burst_cc_sptr self) -> float"""
        return _gfdm_swig.extract_burst_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(extract_burst_cc_sptr self) -> float"""
        return _gfdm_swig.extract_burst_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(extract_burst_cc_sptr self) -> float"""
        return _gfdm_swig.extract_burst_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(extract_burst_cc_sptr self) -> float"""
        return _gfdm_swig.extract_burst_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(extract_burst_cc_sptr self) -> float"""
        return _gfdm_swig.extract_burst_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(extract_burst_cc_sptr self, int which) -> float
        pc_input_buffers_full(extract_burst_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.extract_burst_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(extract_burst_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(extract_burst_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.extract_burst_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(extract_burst_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(extract_burst_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.extract_burst_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(extract_burst_cc_sptr self, int which) -> float
        pc_output_buffers_full(extract_burst_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.extract_burst_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(extract_burst_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(extract_burst_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.extract_burst_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(extract_burst_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(extract_burst_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.extract_burst_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(extract_burst_cc_sptr self) -> float"""
        return _gfdm_swig.extract_burst_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(extract_burst_cc_sptr self) -> float"""
        return _gfdm_swig.extract_burst_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(extract_burst_cc_sptr self) -> float"""
        return _gfdm_swig.extract_burst_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(extract_burst_cc_sptr self) -> float"""
        return _gfdm_swig.extract_burst_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(extract_burst_cc_sptr self) -> float"""
        return _gfdm_swig.extract_burst_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(extract_burst_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _gfdm_swig.extract_burst_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(extract_burst_cc_sptr self)"""
        return _gfdm_swig.extract_burst_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(extract_burst_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.extract_burst_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(extract_burst_cc_sptr self) -> int"""
        return _gfdm_swig.extract_burst_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(extract_burst_cc_sptr self) -> int"""
        return _gfdm_swig.extract_burst_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(extract_burst_cc_sptr self, int priority) -> int"""
        return _gfdm_swig.extract_burst_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(extract_burst_cc_sptr self) -> std::string"""
        return _gfdm_swig.extract_burst_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(extract_burst_cc_sptr self) -> std::string"""
        return _gfdm_swig.extract_burst_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(extract_burst_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.extract_burst_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(extract_burst_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.extract_burst_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(extract_burst_cc_sptr self) -> long"""
        return _gfdm_swig.extract_burst_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(extract_burst_cc_sptr self) -> basic_block_sptr"""
        return _gfdm_swig.extract_burst_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(extract_burst_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _gfdm_swig.extract_burst_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(extract_burst_cc_sptr self) -> std::string"""
        return _gfdm_swig.extract_burst_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(extract_burst_cc_sptr self, std::string name)"""
        return _gfdm_swig.extract_burst_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(extract_burst_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _gfdm_swig.extract_burst_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(extract_burst_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.extract_burst_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(extract_burst_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.extract_burst_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(extract_burst_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _gfdm_swig.extract_burst_cc_sptr_message_subscribers(self, which_port)

extract_burst_cc_sptr_swigregister = _gfdm_swig.extract_burst_cc_sptr_swigregister
extract_burst_cc_sptr_swigregister(extract_burst_cc_sptr)


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

class channel_estimator_cc(object):
    """<+description of block+>"""

    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(timeslots, fft_len, active_subcarriers, is_dc_free, which_estimator, preamble):
        """
        make(int timeslots, int fft_len, int active_subcarriers, bool is_dc_free, int which_estimator, pmt_vector_cfloat preamble) -> channel_estimator_cc_sptr

        Return a shared_ptr to a new instance of gfdm::channel_estimator_cc.

        To avoid accidental use of raw pointers, gfdm::channel_estimator_cc's constructor is in a private implementation class. gfdm::channel_estimator_cc::make is the public interface for creating new instances.

        Params: (timeslots, fft_len, active_subcarriers, is_dc_free, which_estimator, preamble)
        """
        return _gfdm_swig.channel_estimator_cc_make(timeslots, fft_len, active_subcarriers, is_dc_free, which_estimator, preamble)

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_channel_estimator_cc
    __del__ = lambda self: None
channel_estimator_cc_swigregister = _gfdm_swig.channel_estimator_cc_swigregister
channel_estimator_cc_swigregister(channel_estimator_cc)

def channel_estimator_cc_make(timeslots, fft_len, active_subcarriers, is_dc_free, which_estimator, preamble):
    """
    channel_estimator_cc_make(int timeslots, int fft_len, int active_subcarriers, bool is_dc_free, int which_estimator, pmt_vector_cfloat preamble) -> channel_estimator_cc_sptr

    Return a shared_ptr to a new instance of gfdm::channel_estimator_cc.

    To avoid accidental use of raw pointers, gfdm::channel_estimator_cc's constructor is in a private implementation class. gfdm::channel_estimator_cc::make is the public interface for creating new instances.

    Params: (timeslots, fft_len, active_subcarriers, is_dc_free, which_estimator, preamble)
    """
    return _gfdm_swig.channel_estimator_cc_make(timeslots, fft_len, active_subcarriers, is_dc_free, which_estimator, preamble)

class channel_estimator_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::gfdm::channel_estimator_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::gfdm::channel_estimator_cc)> self) -> channel_estimator_cc_sptr
        __init__(boost::shared_ptr<(gr::gfdm::channel_estimator_cc)> self, channel_estimator_cc p) -> channel_estimator_cc_sptr
        """
        this = _gfdm_swig.new_channel_estimator_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(channel_estimator_cc_sptr self) -> channel_estimator_cc"""
        return _gfdm_swig.channel_estimator_cc_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_channel_estimator_cc_sptr
    __del__ = lambda self: None

    def make(self, timeslots, fft_len, active_subcarriers, is_dc_free, which_estimator, preamble):
        """
        make(channel_estimator_cc_sptr self, int timeslots, int fft_len, int active_subcarriers, bool is_dc_free, int which_estimator, pmt_vector_cfloat preamble) -> channel_estimator_cc_sptr

        Return a shared_ptr to a new instance of gfdm::channel_estimator_cc.

        To avoid accidental use of raw pointers, gfdm::channel_estimator_cc's constructor is in a private implementation class. gfdm::channel_estimator_cc::make is the public interface for creating new instances.

        Params: (timeslots, fft_len, active_subcarriers, is_dc_free, which_estimator, preamble)
        """
        return _gfdm_swig.channel_estimator_cc_sptr_make(self, timeslots, fft_len, active_subcarriers, is_dc_free, which_estimator, preamble)


    def history(self):
        """history(channel_estimator_cc_sptr self) -> unsigned int"""
        return _gfdm_swig.channel_estimator_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(channel_estimator_cc_sptr self, int which, int delay)
        declare_sample_delay(channel_estimator_cc_sptr self, unsigned int delay)
        """
        return _gfdm_swig.channel_estimator_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(channel_estimator_cc_sptr self, int which) -> unsigned int"""
        return _gfdm_swig.channel_estimator_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(channel_estimator_cc_sptr self) -> int"""
        return _gfdm_swig.channel_estimator_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(channel_estimator_cc_sptr self) -> double"""
        return _gfdm_swig.channel_estimator_cc_sptr_relative_rate(self)


    def start(self):
        """start(channel_estimator_cc_sptr self) -> bool"""
        return _gfdm_swig.channel_estimator_cc_sptr_start(self)


    def stop(self):
        """stop(channel_estimator_cc_sptr self) -> bool"""
        return _gfdm_swig.channel_estimator_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(channel_estimator_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _gfdm_swig.channel_estimator_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(channel_estimator_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _gfdm_swig.channel_estimator_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(channel_estimator_cc_sptr self) -> int"""
        return _gfdm_swig.channel_estimator_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(channel_estimator_cc_sptr self, int m)"""
        return _gfdm_swig.channel_estimator_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(channel_estimator_cc_sptr self)"""
        return _gfdm_swig.channel_estimator_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(channel_estimator_cc_sptr self) -> bool"""
        return _gfdm_swig.channel_estimator_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(channel_estimator_cc_sptr self, int m)"""
        return _gfdm_swig.channel_estimator_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(channel_estimator_cc_sptr self) -> int"""
        return _gfdm_swig.channel_estimator_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(channel_estimator_cc_sptr self, int i) -> long"""
        return _gfdm_swig.channel_estimator_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(channel_estimator_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(channel_estimator_cc_sptr self, int port, long max_output_buffer)
        """
        return _gfdm_swig.channel_estimator_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(channel_estimator_cc_sptr self, int i) -> long"""
        return _gfdm_swig.channel_estimator_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(channel_estimator_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(channel_estimator_cc_sptr self, int port, long min_output_buffer)
        """
        return _gfdm_swig.channel_estimator_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(channel_estimator_cc_sptr self) -> float"""
        return _gfdm_swig.channel_estimator_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(channel_estimator_cc_sptr self) -> float"""
        return _gfdm_swig.channel_estimator_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(channel_estimator_cc_sptr self) -> float"""
        return _gfdm_swig.channel_estimator_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(channel_estimator_cc_sptr self) -> float"""
        return _gfdm_swig.channel_estimator_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(channel_estimator_cc_sptr self) -> float"""
        return _gfdm_swig.channel_estimator_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(channel_estimator_cc_sptr self) -> float"""
        return _gfdm_swig.channel_estimator_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(channel_estimator_cc_sptr self, int which) -> float
        pc_input_buffers_full(channel_estimator_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.channel_estimator_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(channel_estimator_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(channel_estimator_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.channel_estimator_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(channel_estimator_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(channel_estimator_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.channel_estimator_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(channel_estimator_cc_sptr self, int which) -> float
        pc_output_buffers_full(channel_estimator_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.channel_estimator_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(channel_estimator_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(channel_estimator_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.channel_estimator_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(channel_estimator_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(channel_estimator_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.channel_estimator_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(channel_estimator_cc_sptr self) -> float"""
        return _gfdm_swig.channel_estimator_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(channel_estimator_cc_sptr self) -> float"""
        return _gfdm_swig.channel_estimator_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(channel_estimator_cc_sptr self) -> float"""
        return _gfdm_swig.channel_estimator_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(channel_estimator_cc_sptr self) -> float"""
        return _gfdm_swig.channel_estimator_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(channel_estimator_cc_sptr self) -> float"""
        return _gfdm_swig.channel_estimator_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(channel_estimator_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _gfdm_swig.channel_estimator_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(channel_estimator_cc_sptr self)"""
        return _gfdm_swig.channel_estimator_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(channel_estimator_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.channel_estimator_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(channel_estimator_cc_sptr self) -> int"""
        return _gfdm_swig.channel_estimator_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(channel_estimator_cc_sptr self) -> int"""
        return _gfdm_swig.channel_estimator_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(channel_estimator_cc_sptr self, int priority) -> int"""
        return _gfdm_swig.channel_estimator_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(channel_estimator_cc_sptr self) -> std::string"""
        return _gfdm_swig.channel_estimator_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(channel_estimator_cc_sptr self) -> std::string"""
        return _gfdm_swig.channel_estimator_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(channel_estimator_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.channel_estimator_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(channel_estimator_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.channel_estimator_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(channel_estimator_cc_sptr self) -> long"""
        return _gfdm_swig.channel_estimator_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(channel_estimator_cc_sptr self) -> basic_block_sptr"""
        return _gfdm_swig.channel_estimator_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(channel_estimator_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _gfdm_swig.channel_estimator_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(channel_estimator_cc_sptr self) -> std::string"""
        return _gfdm_swig.channel_estimator_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(channel_estimator_cc_sptr self, std::string name)"""
        return _gfdm_swig.channel_estimator_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(channel_estimator_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _gfdm_swig.channel_estimator_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(channel_estimator_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.channel_estimator_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(channel_estimator_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.channel_estimator_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(channel_estimator_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _gfdm_swig.channel_estimator_cc_sptr_message_subscribers(self, which_port)

channel_estimator_cc_sptr_swigregister = _gfdm_swig.channel_estimator_cc_sptr_swigregister
channel_estimator_cc_sptr_swigregister(channel_estimator_cc_sptr)


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

class transmitter_kernel(object):
    """<+description+>"""

    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, timeslots, subcarriers, active_subcarriers, cp_len, cs_len, ramp_len, subcarrier_map, per_timeslot, overlap, frequency_taps, window_taps, preamble):
        """
        __init__(gr::gfdm::transmitter_kernel self, int timeslots, int subcarriers, int active_subcarriers, int cp_len, int cs_len, int ramp_len, std::vector< int,std::allocator< int > > subcarrier_map, bool per_timeslot, int overlap, std::vector< gr::gfdm::transmitter_kernel::gfdm_complex,std::allocator< gr::gfdm::transmitter_kernel::gfdm_complex > > frequency_taps, std::vector< gr::gfdm::transmitter_kernel::gfdm_complex,std::allocator< gr::gfdm::transmitter_kernel::gfdm_complex > > window_taps, std::vector< gr::gfdm::transmitter_kernel::gfdm_complex,std::allocator< gr::gfdm::transmitter_kernel::gfdm_complex > > preamble) -> transmitter_kernel



        Params: (timeslots, subcarriers, active_subcarriers, cp_len, cs_len, ramp_len, subcarrier_map, per_timeslot, overlap, frequency_taps, window_taps, preamble)
        """
        this = _gfdm_swig.new_transmitter_kernel(timeslots, subcarriers, active_subcarriers, cp_len, cs_len, ramp_len, subcarrier_map, per_timeslot, overlap, frequency_taps, window_taps, preamble)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _gfdm_swig.delete_transmitter_kernel
    __del__ = lambda self: None

    def input_vector_size(self):
        """
        input_vector_size(transmitter_kernel self) -> int



        Params: (NONE)
        """
        return _gfdm_swig.transmitter_kernel_input_vector_size(self)


    def output_vector_size(self):
        """
        output_vector_size(transmitter_kernel self) -> int



        Params: (NONE)
        """
        return _gfdm_swig.transmitter_kernel_output_vector_size(self)


    def generic_work(self, p_out, p_in, ninput_size):
        """
        generic_work(transmitter_kernel self, gr::gfdm::transmitter_kernel::gfdm_complex * p_out, gr::gfdm::transmitter_kernel::gfdm_complex const * p_in, int const ninput_size)



        Params: (p_out, p_in, ninput_size)
        """
        return _gfdm_swig.transmitter_kernel_generic_work(self, p_out, p_in, ninput_size)

transmitter_kernel_swigregister = _gfdm_swig.transmitter_kernel_swigregister
transmitter_kernel_swigregister(transmitter_kernel)

class transmitter_cc(object):
    """<+description of block+>"""

    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, **kwargs):
        """
        make(int timeslots, int subcarriers, int active_subcarriers, int cp_len, int cs_len, int ramp_len, std::vector< int,std::allocator< int > > subcarrier_map, bool per_timeslot, int overlap, pmt_vector_cfloat frequency_taps, pmt_vector_cfloat window_taps, pmt_vector_cfloat preamble, std::string const & tsb_tag_key) -> transmitter_cc_sptr

        Return a shared_ptr to a new instance of gfdm::transmitter_cc.

        To avoid accidental use of raw pointers, gfdm::transmitter_cc's constructor is in a private implementation class. gfdm::transmitter_cc::make is the public interface for creating new instances.

        Params: (timeslots, subcarriers, active_subcarriers, cp_len, cs_len, ramp_len, subcarrier_map, per_timeslot, overlap, frequency_taps, window_taps, preamble, tsb_tag_key)
        """
        return _gfdm_swig.transmitter_cc_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_transmitter_cc
    __del__ = lambda self: None
transmitter_cc_swigregister = _gfdm_swig.transmitter_cc_swigregister
transmitter_cc_swigregister(transmitter_cc)

def transmitter_cc_make(*args, **kwargs):
    """
    transmitter_cc_make(int timeslots, int subcarriers, int active_subcarriers, int cp_len, int cs_len, int ramp_len, std::vector< int,std::allocator< int > > subcarrier_map, bool per_timeslot, int overlap, pmt_vector_cfloat frequency_taps, pmt_vector_cfloat window_taps, pmt_vector_cfloat preamble, std::string const & tsb_tag_key) -> transmitter_cc_sptr

    Return a shared_ptr to a new instance of gfdm::transmitter_cc.

    To avoid accidental use of raw pointers, gfdm::transmitter_cc's constructor is in a private implementation class. gfdm::transmitter_cc::make is the public interface for creating new instances.

    Params: (timeslots, subcarriers, active_subcarriers, cp_len, cs_len, ramp_len, subcarrier_map, per_timeslot, overlap, frequency_taps, window_taps, preamble, tsb_tag_key)
    """
    return _gfdm_swig.transmitter_cc_make(*args, **kwargs)

class transmitter_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::gfdm::transmitter_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::gfdm::transmitter_cc)> self) -> transmitter_cc_sptr
        __init__(boost::shared_ptr<(gr::gfdm::transmitter_cc)> self, transmitter_cc p) -> transmitter_cc_sptr
        """
        this = _gfdm_swig.new_transmitter_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(transmitter_cc_sptr self) -> transmitter_cc"""
        return _gfdm_swig.transmitter_cc_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_transmitter_cc_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """
        make(transmitter_cc_sptr self, int timeslots, int subcarriers, int active_subcarriers, int cp_len, int cs_len, int ramp_len, std::vector< int,std::allocator< int > > subcarrier_map, bool per_timeslot, int overlap, pmt_vector_cfloat frequency_taps, pmt_vector_cfloat window_taps, pmt_vector_cfloat preamble, std::string const & tsb_tag_key) -> transmitter_cc_sptr

        Return a shared_ptr to a new instance of gfdm::transmitter_cc.

        To avoid accidental use of raw pointers, gfdm::transmitter_cc's constructor is in a private implementation class. gfdm::transmitter_cc::make is the public interface for creating new instances.

        Params: (timeslots, subcarriers, active_subcarriers, cp_len, cs_len, ramp_len, subcarrier_map, per_timeslot, overlap, frequency_taps, window_taps, preamble, tsb_tag_key)
        """
        return _gfdm_swig.transmitter_cc_sptr_make(self, *args, **kwargs)


    def history(self):
        """history(transmitter_cc_sptr self) -> unsigned int"""
        return _gfdm_swig.transmitter_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(transmitter_cc_sptr self, int which, int delay)
        declare_sample_delay(transmitter_cc_sptr self, unsigned int delay)
        """
        return _gfdm_swig.transmitter_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(transmitter_cc_sptr self, int which) -> unsigned int"""
        return _gfdm_swig.transmitter_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(transmitter_cc_sptr self) -> int"""
        return _gfdm_swig.transmitter_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(transmitter_cc_sptr self) -> double"""
        return _gfdm_swig.transmitter_cc_sptr_relative_rate(self)


    def start(self):
        """start(transmitter_cc_sptr self) -> bool"""
        return _gfdm_swig.transmitter_cc_sptr_start(self)


    def stop(self):
        """stop(transmitter_cc_sptr self) -> bool"""
        return _gfdm_swig.transmitter_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(transmitter_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _gfdm_swig.transmitter_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(transmitter_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _gfdm_swig.transmitter_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(transmitter_cc_sptr self) -> int"""
        return _gfdm_swig.transmitter_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(transmitter_cc_sptr self, int m)"""
        return _gfdm_swig.transmitter_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(transmitter_cc_sptr self)"""
        return _gfdm_swig.transmitter_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(transmitter_cc_sptr self) -> bool"""
        return _gfdm_swig.transmitter_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(transmitter_cc_sptr self, int m)"""
        return _gfdm_swig.transmitter_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(transmitter_cc_sptr self) -> int"""
        return _gfdm_swig.transmitter_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(transmitter_cc_sptr self, int i) -> long"""
        return _gfdm_swig.transmitter_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(transmitter_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(transmitter_cc_sptr self, int port, long max_output_buffer)
        """
        return _gfdm_swig.transmitter_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(transmitter_cc_sptr self, int i) -> long"""
        return _gfdm_swig.transmitter_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(transmitter_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(transmitter_cc_sptr self, int port, long min_output_buffer)
        """
        return _gfdm_swig.transmitter_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(transmitter_cc_sptr self) -> float"""
        return _gfdm_swig.transmitter_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(transmitter_cc_sptr self) -> float"""
        return _gfdm_swig.transmitter_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(transmitter_cc_sptr self) -> float"""
        return _gfdm_swig.transmitter_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(transmitter_cc_sptr self) -> float"""
        return _gfdm_swig.transmitter_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(transmitter_cc_sptr self) -> float"""
        return _gfdm_swig.transmitter_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(transmitter_cc_sptr self) -> float"""
        return _gfdm_swig.transmitter_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(transmitter_cc_sptr self, int which) -> float
        pc_input_buffers_full(transmitter_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.transmitter_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(transmitter_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(transmitter_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.transmitter_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(transmitter_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(transmitter_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.transmitter_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(transmitter_cc_sptr self, int which) -> float
        pc_output_buffers_full(transmitter_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.transmitter_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(transmitter_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(transmitter_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.transmitter_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(transmitter_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(transmitter_cc_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.transmitter_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(transmitter_cc_sptr self) -> float"""
        return _gfdm_swig.transmitter_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(transmitter_cc_sptr self) -> float"""
        return _gfdm_swig.transmitter_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(transmitter_cc_sptr self) -> float"""
        return _gfdm_swig.transmitter_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(transmitter_cc_sptr self) -> float"""
        return _gfdm_swig.transmitter_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(transmitter_cc_sptr self) -> float"""
        return _gfdm_swig.transmitter_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(transmitter_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _gfdm_swig.transmitter_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(transmitter_cc_sptr self)"""
        return _gfdm_swig.transmitter_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(transmitter_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.transmitter_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(transmitter_cc_sptr self) -> int"""
        return _gfdm_swig.transmitter_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(transmitter_cc_sptr self) -> int"""
        return _gfdm_swig.transmitter_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(transmitter_cc_sptr self, int priority) -> int"""
        return _gfdm_swig.transmitter_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(transmitter_cc_sptr self) -> std::string"""
        return _gfdm_swig.transmitter_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(transmitter_cc_sptr self) -> std::string"""
        return _gfdm_swig.transmitter_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(transmitter_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.transmitter_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(transmitter_cc_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.transmitter_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(transmitter_cc_sptr self) -> long"""
        return _gfdm_swig.transmitter_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(transmitter_cc_sptr self) -> basic_block_sptr"""
        return _gfdm_swig.transmitter_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(transmitter_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _gfdm_swig.transmitter_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(transmitter_cc_sptr self) -> std::string"""
        return _gfdm_swig.transmitter_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(transmitter_cc_sptr self, std::string name)"""
        return _gfdm_swig.transmitter_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(transmitter_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _gfdm_swig.transmitter_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(transmitter_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.transmitter_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(transmitter_cc_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.transmitter_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(transmitter_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _gfdm_swig.transmitter_cc_sptr_message_subscribers(self, which_port)

transmitter_cc_sptr_swigregister = _gfdm_swig.transmitter_cc_sptr_swigregister
transmitter_cc_sptr_swigregister(transmitter_cc_sptr)


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

class short_burst_shaper(object):
    """<+description of block+>"""

    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, **kwargs):
        """
        make(int pre_padding, int post_padding, std::string const & length_tag_name) -> short_burst_shaper_sptr

        Return a shared_ptr to a new instance of gfdm::short_burst_shaper.

        To avoid accidental use of raw pointers, gfdm::short_burst_shaper's constructor is in a private implementation class. gfdm::short_burst_shaper::make is the public interface for creating new instances.

        Params: (pre_padding, post_padding, length_tag_name)
        """
        return _gfdm_swig.short_burst_shaper_make(*args, **kwargs)

    make = staticmethod(make)
    __swig_destroy__ = _gfdm_swig.delete_short_burst_shaper
    __del__ = lambda self: None
short_burst_shaper_swigregister = _gfdm_swig.short_burst_shaper_swigregister
short_burst_shaper_swigregister(short_burst_shaper)

def short_burst_shaper_make(*args, **kwargs):
    """
    short_burst_shaper_make(int pre_padding, int post_padding, std::string const & length_tag_name) -> short_burst_shaper_sptr

    Return a shared_ptr to a new instance of gfdm::short_burst_shaper.

    To avoid accidental use of raw pointers, gfdm::short_burst_shaper's constructor is in a private implementation class. gfdm::short_burst_shaper::make is the public interface for creating new instances.

    Params: (pre_padding, post_padding, length_tag_name)
    """
    return _gfdm_swig.short_burst_shaper_make(*args, **kwargs)

class short_burst_shaper_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::gfdm::short_burst_shaper)> 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::gfdm::short_burst_shaper)> self) -> short_burst_shaper_sptr
        __init__(boost::shared_ptr<(gr::gfdm::short_burst_shaper)> self, short_burst_shaper p) -> short_burst_shaper_sptr
        """
        this = _gfdm_swig.new_short_burst_shaper_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(short_burst_shaper_sptr self) -> short_burst_shaper"""
        return _gfdm_swig.short_burst_shaper_sptr___deref__(self)

    __swig_destroy__ = _gfdm_swig.delete_short_burst_shaper_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """
        make(short_burst_shaper_sptr self, int pre_padding, int post_padding, std::string const & length_tag_name) -> short_burst_shaper_sptr

        Return a shared_ptr to a new instance of gfdm::short_burst_shaper.

        To avoid accidental use of raw pointers, gfdm::short_burst_shaper's constructor is in a private implementation class. gfdm::short_burst_shaper::make is the public interface for creating new instances.

        Params: (pre_padding, post_padding, length_tag_name)
        """
        return _gfdm_swig.short_burst_shaper_sptr_make(self, *args, **kwargs)


    def history(self):
        """history(short_burst_shaper_sptr self) -> unsigned int"""
        return _gfdm_swig.short_burst_shaper_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(short_burst_shaper_sptr self, int which, int delay)
        declare_sample_delay(short_burst_shaper_sptr self, unsigned int delay)
        """
        return _gfdm_swig.short_burst_shaper_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(short_burst_shaper_sptr self, int which) -> unsigned int"""
        return _gfdm_swig.short_burst_shaper_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(short_burst_shaper_sptr self) -> int"""
        return _gfdm_swig.short_burst_shaper_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(short_burst_shaper_sptr self) -> double"""
        return _gfdm_swig.short_burst_shaper_sptr_relative_rate(self)


    def start(self):
        """start(short_burst_shaper_sptr self) -> bool"""
        return _gfdm_swig.short_burst_shaper_sptr_start(self)


    def stop(self):
        """stop(short_burst_shaper_sptr self) -> bool"""
        return _gfdm_swig.short_burst_shaper_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(short_burst_shaper_sptr self, unsigned int which_input) -> uint64_t"""
        return _gfdm_swig.short_burst_shaper_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(short_burst_shaper_sptr self, unsigned int which_output) -> uint64_t"""
        return _gfdm_swig.short_burst_shaper_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(short_burst_shaper_sptr self) -> int"""
        return _gfdm_swig.short_burst_shaper_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(short_burst_shaper_sptr self, int m)"""
        return _gfdm_swig.short_burst_shaper_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(short_burst_shaper_sptr self)"""
        return _gfdm_swig.short_burst_shaper_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(short_burst_shaper_sptr self) -> bool"""
        return _gfdm_swig.short_burst_shaper_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(short_burst_shaper_sptr self, int m)"""
        return _gfdm_swig.short_burst_shaper_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(short_burst_shaper_sptr self) -> int"""
        return _gfdm_swig.short_burst_shaper_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(short_burst_shaper_sptr self, int i) -> long"""
        return _gfdm_swig.short_burst_shaper_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(short_burst_shaper_sptr self, long max_output_buffer)
        set_max_output_buffer(short_burst_shaper_sptr self, int port, long max_output_buffer)
        """
        return _gfdm_swig.short_burst_shaper_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(short_burst_shaper_sptr self, int i) -> long"""
        return _gfdm_swig.short_burst_shaper_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(short_burst_shaper_sptr self, long min_output_buffer)
        set_min_output_buffer(short_burst_shaper_sptr self, int port, long min_output_buffer)
        """
        return _gfdm_swig.short_burst_shaper_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(short_burst_shaper_sptr self) -> float"""
        return _gfdm_swig.short_burst_shaper_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(short_burst_shaper_sptr self) -> float"""
        return _gfdm_swig.short_burst_shaper_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(short_burst_shaper_sptr self) -> float"""
        return _gfdm_swig.short_burst_shaper_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(short_burst_shaper_sptr self) -> float"""
        return _gfdm_swig.short_burst_shaper_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(short_burst_shaper_sptr self) -> float"""
        return _gfdm_swig.short_burst_shaper_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(short_burst_shaper_sptr self) -> float"""
        return _gfdm_swig.short_burst_shaper_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(short_burst_shaper_sptr self, int which) -> float
        pc_input_buffers_full(short_burst_shaper_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.short_burst_shaper_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(short_burst_shaper_sptr self, int which) -> float
        pc_input_buffers_full_avg(short_burst_shaper_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.short_burst_shaper_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(short_burst_shaper_sptr self, int which) -> float
        pc_input_buffers_full_var(short_burst_shaper_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.short_burst_shaper_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(short_burst_shaper_sptr self, int which) -> float
        pc_output_buffers_full(short_burst_shaper_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.short_burst_shaper_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(short_burst_shaper_sptr self, int which) -> float
        pc_output_buffers_full_avg(short_burst_shaper_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.short_burst_shaper_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(short_burst_shaper_sptr self, int which) -> float
        pc_output_buffers_full_var(short_burst_shaper_sptr self) -> pmt_vector_float
        """
        return _gfdm_swig.short_burst_shaper_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(short_burst_shaper_sptr self) -> float"""
        return _gfdm_swig.short_burst_shaper_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(short_burst_shaper_sptr self) -> float"""
        return _gfdm_swig.short_burst_shaper_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(short_burst_shaper_sptr self) -> float"""
        return _gfdm_swig.short_burst_shaper_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(short_burst_shaper_sptr self) -> float"""
        return _gfdm_swig.short_burst_shaper_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(short_burst_shaper_sptr self) -> float"""
        return _gfdm_swig.short_burst_shaper_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(short_burst_shaper_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _gfdm_swig.short_burst_shaper_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(short_burst_shaper_sptr self)"""
        return _gfdm_swig.short_burst_shaper_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(short_burst_shaper_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _gfdm_swig.short_burst_shaper_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(short_burst_shaper_sptr self) -> int"""
        return _gfdm_swig.short_burst_shaper_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(short_burst_shaper_sptr self) -> int"""
        return _gfdm_swig.short_burst_shaper_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(short_burst_shaper_sptr self, int priority) -> int"""
        return _gfdm_swig.short_burst_shaper_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(short_burst_shaper_sptr self) -> std::string"""
        return _gfdm_swig.short_burst_shaper_sptr_name(self)


    def symbol_name(self):
        """symbol_name(short_burst_shaper_sptr self) -> std::string"""
        return _gfdm_swig.short_burst_shaper_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(short_burst_shaper_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.short_burst_shaper_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(short_burst_shaper_sptr self) -> io_signature_sptr"""
        return _gfdm_swig.short_burst_shaper_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(short_burst_shaper_sptr self) -> long"""
        return _gfdm_swig.short_burst_shaper_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(short_burst_shaper_sptr self) -> basic_block_sptr"""
        return _gfdm_swig.short_burst_shaper_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(short_burst_shaper_sptr self, int ninputs, int noutputs) -> bool"""
        return _gfdm_swig.short_burst_shaper_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(short_burst_shaper_sptr self) -> std::string"""
        return _gfdm_swig.short_burst_shaper_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(short_burst_shaper_sptr self, std::string name)"""
        return _gfdm_swig.short_burst_shaper_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(short_burst_shaper_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _gfdm_swig.short_burst_shaper_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(short_burst_shaper_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.short_burst_shaper_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(short_burst_shaper_sptr self) -> swig_int_ptr"""
        return _gfdm_swig.short_burst_shaper_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(short_burst_shaper_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _gfdm_swig.short_burst_shaper_sptr_message_subscribers(self, which_port)

short_burst_shaper_sptr_swigregister = _gfdm_swig.short_burst_shaper_sptr_swigregister
short_burst_shaper_sptr_swigregister(short_burst_shaper_sptr)


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



