# 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, '_cdma_swig')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_cdma_swig')
    _cdma_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('_cdma_swig', [dirname(__file__)])
        except ImportError:
            import _cdma_swig
            return _cdma_swig
        try:
            _mod = imp.load_module('_cdma_swig', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _cdma_swig = swig_import_helper()
    del swig_import_helper
else:
    import _cdma_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 _cdma_swig.high_res_timer_now()

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

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

def high_res_timer_epoch():
    """high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _cdma_swig.high_res_timer_epoch()
class packet_header_default(object):
    """Proxy of C++ gr::digital::packet_header_default class."""

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

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

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


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


    def set_header_num(self, header_num):
        """set_header_num(packet_header_default self, unsigned int header_num)"""
        return _cdma_swig.packet_header_default_set_header_num(self, header_num)


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


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


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


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


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

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

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

class packet_header2(packet_header_default):
    """
    Default header formatter for digital packet transmission.

    For bursty/packetized digital transmission, packets are usually prepended with a packet header, containing the number of bytes etc. This class is not a block, but a tool to create these packet header.


    This is a default packet header (see header_formatter()) for a description on the header format). To create other header, derive packet header creator classes from this function.


    gr::digital::packet_headergenerator_bb uses header generators derived from this class to create packet headers from data streams.
    """

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

    def __init__(self, *args, **kwargs):
        """
        __init__(gr::cdma::packet_header2 self, long header_len, std::string const & len_tag_key, std::string const & num_tag_key, int bits_per_byte=1, int tcm_type=1, std::string const & tcm_type_key) -> packet_header2



        Params: (header_len, len_tag_key, num_tag_key, bits_per_byte, tcm_type, tcm_type_key)
        """
        this = _cdma_swig.new_packet_header2(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _cdma_swig.delete_packet_header2
    __del__ = lambda self: None

    def set_tcm_type(self, tcm_type):
        """
        set_tcm_type(packet_header2 self, int tcm_type)



        Params: (tcm_type)
        """
        return _cdma_swig.packet_header2_set_tcm_type(self, tcm_type)


    def num_tag_key(self):
        """
        num_tag_key(packet_header2 self) -> swig_int_ptr



        Params: (NONE)
        """
        return _cdma_swig.packet_header2_num_tag_key(self)


    def make(*args, **kwargs):
        """
        make(long header_len, std::string const & len_tag_key, std::string const & num_tag_key, int bits_per_byte=1, int tcm_type=1, std::string const & tcm_tag_key) -> packet_header2_sptr



        Params: (header_len, len_tag_key, num_tag_key, bits_per_byte, tcm_type, tcm_tag_key)
        """
        return _cdma_swig.packet_header2_make(*args, **kwargs)

    make = staticmethod(make)
packet_header2_swigregister = _cdma_swig.packet_header2_swigregister
packet_header2_swigregister(packet_header2)

def packet_header2_make(*args, **kwargs):
    """
    packet_header2_make(long header_len, std::string const & len_tag_key, std::string const & num_tag_key, int bits_per_byte=1, int tcm_type=1, std::string const & tcm_tag_key) -> packet_header2_sptr



    Params: (header_len, len_tag_key, num_tag_key, bits_per_byte, tcm_type, tcm_tag_key)
    """
    return _cdma_swig.packet_header2_make(*args, **kwargs)

class packet_headerparser_b2(object):
    """
    Post header metadata as a PMT.

    In a sense, this is the inverse block to packet_headergenerator_bb. The difference is, the parsed header is not output as a stream, but as a PMT dictionary, which is published to message port with the id "header_data".


    The dictionary consists of the tags created by the header formatter object. You should be able to use the exact same formatter object as used on the Tx side in the packet_headergenerator_bb.


    If only a header length is given, this block uses the default header format.
    """

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

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

    def make(*args):
        """
        make(packet_header2_sptr header_formatter) -> packet_headerparser_b2_sptr
        make(long header_len, std::string const & len_tag_key) -> packet_headerparser_b2_sptr



        Params: (header_formatter)
        """
        return _cdma_swig.packet_headerparser_b2_make(*args)

    make = staticmethod(make)
    __swig_destroy__ = _cdma_swig.delete_packet_headerparser_b2
    __del__ = lambda self: None
packet_headerparser_b2_swigregister = _cdma_swig.packet_headerparser_b2_swigregister
packet_headerparser_b2_swigregister(packet_headerparser_b2)

def packet_headerparser_b2_make(*args):
    """
    make(packet_header2_sptr header_formatter) -> packet_headerparser_b2_sptr
    packet_headerparser_b2_make(long header_len, std::string const & len_tag_key) -> packet_headerparser_b2_sptr



    Params: (header_formatter)
    """
    return _cdma_swig.packet_headerparser_b2_make(*args)

class packet_headerparser_b2_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::cdma::packet_headerparser_b2)> 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::cdma::packet_headerparser_b2)> self) -> packet_headerparser_b2_sptr
        __init__(boost::shared_ptr<(gr::cdma::packet_headerparser_b2)> self, packet_headerparser_b2 p) -> packet_headerparser_b2_sptr
        """
        this = _cdma_swig.new_packet_headerparser_b2_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(packet_headerparser_b2_sptr self) -> packet_headerparser_b2"""
        return _cdma_swig.packet_headerparser_b2_sptr___deref__(self)

    __swig_destroy__ = _cdma_swig.delete_packet_headerparser_b2_sptr
    __del__ = lambda self: None

    def make(self, *args):
        """
        make(packet_headerparser_b2_sptr self, packet_header2_sptr header_formatter) -> packet_headerparser_b2_sptr
        make(packet_headerparser_b2_sptr self, long header_len, std::string const & len_tag_key) -> packet_headerparser_b2_sptr



        Params: (header_formatter)
        """
        return _cdma_swig.packet_headerparser_b2_sptr_make(self, *args)


    def history(self):
        """history(packet_headerparser_b2_sptr self) -> unsigned int"""
        return _cdma_swig.packet_headerparser_b2_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(packet_headerparser_b2_sptr self, int which, int delay)
        declare_sample_delay(packet_headerparser_b2_sptr self, unsigned int delay)
        """
        return _cdma_swig.packet_headerparser_b2_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(packet_headerparser_b2_sptr self, int which) -> unsigned int"""
        return _cdma_swig.packet_headerparser_b2_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(packet_headerparser_b2_sptr self) -> int"""
        return _cdma_swig.packet_headerparser_b2_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(packet_headerparser_b2_sptr self) -> double"""
        return _cdma_swig.packet_headerparser_b2_sptr_relative_rate(self)


    def start(self):
        """start(packet_headerparser_b2_sptr self) -> bool"""
        return _cdma_swig.packet_headerparser_b2_sptr_start(self)


    def stop(self):
        """stop(packet_headerparser_b2_sptr self) -> bool"""
        return _cdma_swig.packet_headerparser_b2_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(packet_headerparser_b2_sptr self, unsigned int which_input) -> uint64_t"""
        return _cdma_swig.packet_headerparser_b2_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(packet_headerparser_b2_sptr self, unsigned int which_output) -> uint64_t"""
        return _cdma_swig.packet_headerparser_b2_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(packet_headerparser_b2_sptr self) -> int"""
        return _cdma_swig.packet_headerparser_b2_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(packet_headerparser_b2_sptr self, int m)"""
        return _cdma_swig.packet_headerparser_b2_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(packet_headerparser_b2_sptr self)"""
        return _cdma_swig.packet_headerparser_b2_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(packet_headerparser_b2_sptr self) -> bool"""
        return _cdma_swig.packet_headerparser_b2_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(packet_headerparser_b2_sptr self, int m)"""
        return _cdma_swig.packet_headerparser_b2_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(packet_headerparser_b2_sptr self) -> int"""
        return _cdma_swig.packet_headerparser_b2_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(packet_headerparser_b2_sptr self, int i) -> long"""
        return _cdma_swig.packet_headerparser_b2_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(packet_headerparser_b2_sptr self, long max_output_buffer)
        set_max_output_buffer(packet_headerparser_b2_sptr self, int port, long max_output_buffer)
        """
        return _cdma_swig.packet_headerparser_b2_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(packet_headerparser_b2_sptr self, int i) -> long"""
        return _cdma_swig.packet_headerparser_b2_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(packet_headerparser_b2_sptr self, long min_output_buffer)
        set_min_output_buffer(packet_headerparser_b2_sptr self, int port, long min_output_buffer)
        """
        return _cdma_swig.packet_headerparser_b2_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(packet_headerparser_b2_sptr self) -> float"""
        return _cdma_swig.packet_headerparser_b2_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(packet_headerparser_b2_sptr self) -> float"""
        return _cdma_swig.packet_headerparser_b2_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(packet_headerparser_b2_sptr self) -> float"""
        return _cdma_swig.packet_headerparser_b2_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(packet_headerparser_b2_sptr self) -> float"""
        return _cdma_swig.packet_headerparser_b2_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(packet_headerparser_b2_sptr self) -> float"""
        return _cdma_swig.packet_headerparser_b2_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(packet_headerparser_b2_sptr self) -> float"""
        return _cdma_swig.packet_headerparser_b2_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(packet_headerparser_b2_sptr self, int which) -> float
        pc_input_buffers_full(packet_headerparser_b2_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.packet_headerparser_b2_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(packet_headerparser_b2_sptr self, int which) -> float
        pc_input_buffers_full_avg(packet_headerparser_b2_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.packet_headerparser_b2_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(packet_headerparser_b2_sptr self, int which) -> float
        pc_input_buffers_full_var(packet_headerparser_b2_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.packet_headerparser_b2_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(packet_headerparser_b2_sptr self, int which) -> float
        pc_output_buffers_full(packet_headerparser_b2_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.packet_headerparser_b2_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(packet_headerparser_b2_sptr self, int which) -> float
        pc_output_buffers_full_avg(packet_headerparser_b2_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.packet_headerparser_b2_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(packet_headerparser_b2_sptr self, int which) -> float
        pc_output_buffers_full_var(packet_headerparser_b2_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.packet_headerparser_b2_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(packet_headerparser_b2_sptr self) -> float"""
        return _cdma_swig.packet_headerparser_b2_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(packet_headerparser_b2_sptr self) -> float"""
        return _cdma_swig.packet_headerparser_b2_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(packet_headerparser_b2_sptr self) -> float"""
        return _cdma_swig.packet_headerparser_b2_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(packet_headerparser_b2_sptr self) -> float"""
        return _cdma_swig.packet_headerparser_b2_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(packet_headerparser_b2_sptr self) -> float"""
        return _cdma_swig.packet_headerparser_b2_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(packet_headerparser_b2_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _cdma_swig.packet_headerparser_b2_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(packet_headerparser_b2_sptr self)"""
        return _cdma_swig.packet_headerparser_b2_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(packet_headerparser_b2_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _cdma_swig.packet_headerparser_b2_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(packet_headerparser_b2_sptr self) -> int"""
        return _cdma_swig.packet_headerparser_b2_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(packet_headerparser_b2_sptr self) -> int"""
        return _cdma_swig.packet_headerparser_b2_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(packet_headerparser_b2_sptr self, int priority) -> int"""
        return _cdma_swig.packet_headerparser_b2_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(packet_headerparser_b2_sptr self) -> std::string"""
        return _cdma_swig.packet_headerparser_b2_sptr_name(self)


    def symbol_name(self):
        """symbol_name(packet_headerparser_b2_sptr self) -> std::string"""
        return _cdma_swig.packet_headerparser_b2_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(packet_headerparser_b2_sptr self) -> io_signature_sptr"""
        return _cdma_swig.packet_headerparser_b2_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(packet_headerparser_b2_sptr self) -> io_signature_sptr"""
        return _cdma_swig.packet_headerparser_b2_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(packet_headerparser_b2_sptr self) -> long"""
        return _cdma_swig.packet_headerparser_b2_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(packet_headerparser_b2_sptr self) -> basic_block_sptr"""
        return _cdma_swig.packet_headerparser_b2_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(packet_headerparser_b2_sptr self, int ninputs, int noutputs) -> bool"""
        return _cdma_swig.packet_headerparser_b2_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(packet_headerparser_b2_sptr self) -> std::string"""
        return _cdma_swig.packet_headerparser_b2_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(packet_headerparser_b2_sptr self, std::string name)"""
        return _cdma_swig.packet_headerparser_b2_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(packet_headerparser_b2_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _cdma_swig.packet_headerparser_b2_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(packet_headerparser_b2_sptr self) -> swig_int_ptr"""
        return _cdma_swig.packet_headerparser_b2_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(packet_headerparser_b2_sptr self) -> swig_int_ptr"""
        return _cdma_swig.packet_headerparser_b2_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(packet_headerparser_b2_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _cdma_swig.packet_headerparser_b2_sptr_message_subscribers(self, which_port)

packet_headerparser_b2_sptr_swigregister = _cdma_swig.packet_headerparser_b2_sptr_swigregister
packet_headerparser_b2_sptr_swigregister(packet_headerparser_b2_sptr)


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

class chopper(object):
    """
    Chop the input data stream according to the flags in the input control stream.

    When flag is detected in the control stream, the chopper start to chop. The chopper outputs a copy of length_out items from the input stream to the output stream per chop.
    The chopper consumes length_in items from the input and control streams.
    Typically the flags are periodic and length_out>=length_in. Therefore, there exist three cases.
    Case 1: period <= length_in <= length_out 
    For example, with length_in=4, length_out=5, period=3, the input and output streams will look like 
    input:-->abcdefghijklmn...
    flags:-->10010010010010... (period=3)
    outputs:-->abcdeghijkmn...

    Case 2: length_in <= period <= length_out 
    For example, with length_in=4, length_out=6, period=5, the input and output streams will look like 
    input:-->abcdefghijklmn...
    flags:-->100001000010000... (period=5)
    outputs:-->abcdeffghijkklmnop...

    Case 3: length_in <=length_out <= period 
    For example, with length_in=4, length_out=6, period=7, the input and output streams will look like 
    input:-->abcdefghijklmnopqrst...
    flags:-->100000010000001000000...(periold=7) 
    outputs:-->abcdefhijklmonqrst...
    """

    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(length_out, length_in, vector_length):
        """
        make(int length_out, int length_in, size_t vector_length) -> chopper_sptr

        Return a shared_ptr to a new instance of cdma::chopper.

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

        Params: (length_out, length_in, vector_length)
        """
        return _cdma_swig.chopper_make(length_out, length_in, vector_length)

    make = staticmethod(make)
    __swig_destroy__ = _cdma_swig.delete_chopper
    __del__ = lambda self: None
chopper_swigregister = _cdma_swig.chopper_swigregister
chopper_swigregister(chopper)

def chopper_make(length_out, length_in, vector_length):
    """
    chopper_make(int length_out, int length_in, size_t vector_length) -> chopper_sptr

    Return a shared_ptr to a new instance of cdma::chopper.

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

    Params: (length_out, length_in, vector_length)
    """
    return _cdma_swig.chopper_make(length_out, length_in, vector_length)

class chopper_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::cdma::chopper)> 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::cdma::chopper)> self) -> chopper_sptr
        __init__(boost::shared_ptr<(gr::cdma::chopper)> self, chopper p) -> chopper_sptr
        """
        this = _cdma_swig.new_chopper_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(chopper_sptr self) -> chopper"""
        return _cdma_swig.chopper_sptr___deref__(self)

    __swig_destroy__ = _cdma_swig.delete_chopper_sptr
    __del__ = lambda self: None

    def make(self, length_out, length_in, vector_length):
        """
        make(chopper_sptr self, int length_out, int length_in, size_t vector_length) -> chopper_sptr

        Return a shared_ptr to a new instance of cdma::chopper.

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

        Params: (length_out, length_in, vector_length)
        """
        return _cdma_swig.chopper_sptr_make(self, length_out, length_in, vector_length)


    def history(self):
        """history(chopper_sptr self) -> unsigned int"""
        return _cdma_swig.chopper_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(chopper_sptr self, int which, int delay)
        declare_sample_delay(chopper_sptr self, unsigned int delay)
        """
        return _cdma_swig.chopper_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(chopper_sptr self, int which) -> unsigned int"""
        return _cdma_swig.chopper_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(chopper_sptr self) -> int"""
        return _cdma_swig.chopper_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(chopper_sptr self) -> double"""
        return _cdma_swig.chopper_sptr_relative_rate(self)


    def start(self):
        """start(chopper_sptr self) -> bool"""
        return _cdma_swig.chopper_sptr_start(self)


    def stop(self):
        """stop(chopper_sptr self) -> bool"""
        return _cdma_swig.chopper_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(chopper_sptr self, unsigned int which_input) -> uint64_t"""
        return _cdma_swig.chopper_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(chopper_sptr self, unsigned int which_output) -> uint64_t"""
        return _cdma_swig.chopper_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(chopper_sptr self) -> int"""
        return _cdma_swig.chopper_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(chopper_sptr self, int m)"""
        return _cdma_swig.chopper_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(chopper_sptr self)"""
        return _cdma_swig.chopper_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(chopper_sptr self) -> bool"""
        return _cdma_swig.chopper_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(chopper_sptr self, int m)"""
        return _cdma_swig.chopper_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(chopper_sptr self) -> int"""
        return _cdma_swig.chopper_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(chopper_sptr self, int i) -> long"""
        return _cdma_swig.chopper_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(chopper_sptr self, long max_output_buffer)
        set_max_output_buffer(chopper_sptr self, int port, long max_output_buffer)
        """
        return _cdma_swig.chopper_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(chopper_sptr self, int i) -> long"""
        return _cdma_swig.chopper_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(chopper_sptr self, long min_output_buffer)
        set_min_output_buffer(chopper_sptr self, int port, long min_output_buffer)
        """
        return _cdma_swig.chopper_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(chopper_sptr self) -> float"""
        return _cdma_swig.chopper_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(chopper_sptr self) -> float"""
        return _cdma_swig.chopper_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(chopper_sptr self) -> float"""
        return _cdma_swig.chopper_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(chopper_sptr self) -> float"""
        return _cdma_swig.chopper_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(chopper_sptr self) -> float"""
        return _cdma_swig.chopper_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(chopper_sptr self) -> float"""
        return _cdma_swig.chopper_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(chopper_sptr self, int which) -> float
        pc_input_buffers_full(chopper_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.chopper_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(chopper_sptr self, int which) -> float
        pc_input_buffers_full_avg(chopper_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.chopper_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(chopper_sptr self, int which) -> float
        pc_input_buffers_full_var(chopper_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.chopper_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(chopper_sptr self, int which) -> float
        pc_output_buffers_full(chopper_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.chopper_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(chopper_sptr self, int which) -> float
        pc_output_buffers_full_avg(chopper_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.chopper_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(chopper_sptr self, int which) -> float
        pc_output_buffers_full_var(chopper_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.chopper_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(chopper_sptr self) -> float"""
        return _cdma_swig.chopper_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(chopper_sptr self) -> float"""
        return _cdma_swig.chopper_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(chopper_sptr self) -> float"""
        return _cdma_swig.chopper_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(chopper_sptr self) -> float"""
        return _cdma_swig.chopper_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(chopper_sptr self) -> float"""
        return _cdma_swig.chopper_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(chopper_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _cdma_swig.chopper_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(chopper_sptr self)"""
        return _cdma_swig.chopper_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(chopper_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _cdma_swig.chopper_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(chopper_sptr self) -> int"""
        return _cdma_swig.chopper_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(chopper_sptr self) -> int"""
        return _cdma_swig.chopper_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(chopper_sptr self, int priority) -> int"""
        return _cdma_swig.chopper_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(chopper_sptr self) -> std::string"""
        return _cdma_swig.chopper_sptr_name(self)


    def symbol_name(self):
        """symbol_name(chopper_sptr self) -> std::string"""
        return _cdma_swig.chopper_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(chopper_sptr self) -> io_signature_sptr"""
        return _cdma_swig.chopper_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(chopper_sptr self) -> io_signature_sptr"""
        return _cdma_swig.chopper_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(chopper_sptr self) -> long"""
        return _cdma_swig.chopper_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(chopper_sptr self) -> basic_block_sptr"""
        return _cdma_swig.chopper_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(chopper_sptr self, int ninputs, int noutputs) -> bool"""
        return _cdma_swig.chopper_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(chopper_sptr self) -> std::string"""
        return _cdma_swig.chopper_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(chopper_sptr self, std::string name)"""
        return _cdma_swig.chopper_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(chopper_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _cdma_swig.chopper_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(chopper_sptr self) -> swig_int_ptr"""
        return _cdma_swig.chopper_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(chopper_sptr self) -> swig_int_ptr"""
        return _cdma_swig.chopper_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(chopper_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _cdma_swig.chopper_sptr_message_subscribers(self, which_port)

chopper_sptr_swigregister = _cdma_swig.chopper_sptr_swigregister
chopper_sptr_swigregister(chopper_sptr)


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

class vector_insert2(object):
    """
    Insert a specified (complex) vector periodically in the (complex) input stream.

    For example, with data=(x,y), periodicity=3, and offset=1, the input and output streams will look like 
    input: abcdefghijk... 
    output: axybcdxyefgxyhijxyk...
    """

    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(data, periodicity, offset):
        """
        make(pmt_vector_cfloat data, int periodicity, int offset) -> vector_insert2_sptr

        Return a shared_ptr to a new instance of cdma::vector_insert2.

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

        Params: (data, periodicity, offset)
        """
        return _cdma_swig.vector_insert2_make(data, periodicity, offset)

    make = staticmethod(make)
    __swig_destroy__ = _cdma_swig.delete_vector_insert2
    __del__ = lambda self: None
vector_insert2_swigregister = _cdma_swig.vector_insert2_swigregister
vector_insert2_swigregister(vector_insert2)

def vector_insert2_make(data, periodicity, offset):
    """
    vector_insert2_make(pmt_vector_cfloat data, int periodicity, int offset) -> vector_insert2_sptr

    Return a shared_ptr to a new instance of cdma::vector_insert2.

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

    Params: (data, periodicity, offset)
    """
    return _cdma_swig.vector_insert2_make(data, periodicity, offset)

class vector_insert2_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::cdma::vector_insert2)> 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::cdma::vector_insert2)> self) -> vector_insert2_sptr
        __init__(boost::shared_ptr<(gr::cdma::vector_insert2)> self, vector_insert2 p) -> vector_insert2_sptr
        """
        this = _cdma_swig.new_vector_insert2_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(vector_insert2_sptr self) -> vector_insert2"""
        return _cdma_swig.vector_insert2_sptr___deref__(self)

    __swig_destroy__ = _cdma_swig.delete_vector_insert2_sptr
    __del__ = lambda self: None

    def make(self, data, periodicity, offset):
        """
        make(vector_insert2_sptr self, pmt_vector_cfloat data, int periodicity, int offset) -> vector_insert2_sptr

        Return a shared_ptr to a new instance of cdma::vector_insert2.

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

        Params: (data, periodicity, offset)
        """
        return _cdma_swig.vector_insert2_sptr_make(self, data, periodicity, offset)


    def history(self):
        """history(vector_insert2_sptr self) -> unsigned int"""
        return _cdma_swig.vector_insert2_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(vector_insert2_sptr self, int which, int delay)
        declare_sample_delay(vector_insert2_sptr self, unsigned int delay)
        """
        return _cdma_swig.vector_insert2_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(vector_insert2_sptr self, int which) -> unsigned int"""
        return _cdma_swig.vector_insert2_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(vector_insert2_sptr self) -> int"""
        return _cdma_swig.vector_insert2_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(vector_insert2_sptr self) -> double"""
        return _cdma_swig.vector_insert2_sptr_relative_rate(self)


    def start(self):
        """start(vector_insert2_sptr self) -> bool"""
        return _cdma_swig.vector_insert2_sptr_start(self)


    def stop(self):
        """stop(vector_insert2_sptr self) -> bool"""
        return _cdma_swig.vector_insert2_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(vector_insert2_sptr self, unsigned int which_input) -> uint64_t"""
        return _cdma_swig.vector_insert2_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(vector_insert2_sptr self, unsigned int which_output) -> uint64_t"""
        return _cdma_swig.vector_insert2_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(vector_insert2_sptr self) -> int"""
        return _cdma_swig.vector_insert2_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(vector_insert2_sptr self, int m)"""
        return _cdma_swig.vector_insert2_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(vector_insert2_sptr self)"""
        return _cdma_swig.vector_insert2_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(vector_insert2_sptr self) -> bool"""
        return _cdma_swig.vector_insert2_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(vector_insert2_sptr self, int m)"""
        return _cdma_swig.vector_insert2_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(vector_insert2_sptr self) -> int"""
        return _cdma_swig.vector_insert2_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(vector_insert2_sptr self, int i) -> long"""
        return _cdma_swig.vector_insert2_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(vector_insert2_sptr self, long max_output_buffer)
        set_max_output_buffer(vector_insert2_sptr self, int port, long max_output_buffer)
        """
        return _cdma_swig.vector_insert2_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(vector_insert2_sptr self, int i) -> long"""
        return _cdma_swig.vector_insert2_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(vector_insert2_sptr self, long min_output_buffer)
        set_min_output_buffer(vector_insert2_sptr self, int port, long min_output_buffer)
        """
        return _cdma_swig.vector_insert2_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(vector_insert2_sptr self) -> float"""
        return _cdma_swig.vector_insert2_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(vector_insert2_sptr self) -> float"""
        return _cdma_swig.vector_insert2_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(vector_insert2_sptr self) -> float"""
        return _cdma_swig.vector_insert2_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(vector_insert2_sptr self) -> float"""
        return _cdma_swig.vector_insert2_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(vector_insert2_sptr self) -> float"""
        return _cdma_swig.vector_insert2_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(vector_insert2_sptr self) -> float"""
        return _cdma_swig.vector_insert2_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(vector_insert2_sptr self, int which) -> float
        pc_input_buffers_full(vector_insert2_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.vector_insert2_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(vector_insert2_sptr self, int which) -> float
        pc_input_buffers_full_avg(vector_insert2_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.vector_insert2_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(vector_insert2_sptr self, int which) -> float
        pc_input_buffers_full_var(vector_insert2_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.vector_insert2_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(vector_insert2_sptr self, int which) -> float
        pc_output_buffers_full(vector_insert2_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.vector_insert2_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(vector_insert2_sptr self, int which) -> float
        pc_output_buffers_full_avg(vector_insert2_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.vector_insert2_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(vector_insert2_sptr self, int which) -> float
        pc_output_buffers_full_var(vector_insert2_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.vector_insert2_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(vector_insert2_sptr self) -> float"""
        return _cdma_swig.vector_insert2_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(vector_insert2_sptr self) -> float"""
        return _cdma_swig.vector_insert2_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(vector_insert2_sptr self) -> float"""
        return _cdma_swig.vector_insert2_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(vector_insert2_sptr self) -> float"""
        return _cdma_swig.vector_insert2_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(vector_insert2_sptr self) -> float"""
        return _cdma_swig.vector_insert2_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(vector_insert2_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _cdma_swig.vector_insert2_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(vector_insert2_sptr self)"""
        return _cdma_swig.vector_insert2_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(vector_insert2_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _cdma_swig.vector_insert2_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(vector_insert2_sptr self) -> int"""
        return _cdma_swig.vector_insert2_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(vector_insert2_sptr self) -> int"""
        return _cdma_swig.vector_insert2_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(vector_insert2_sptr self, int priority) -> int"""
        return _cdma_swig.vector_insert2_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(vector_insert2_sptr self) -> std::string"""
        return _cdma_swig.vector_insert2_sptr_name(self)


    def symbol_name(self):
        """symbol_name(vector_insert2_sptr self) -> std::string"""
        return _cdma_swig.vector_insert2_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(vector_insert2_sptr self) -> io_signature_sptr"""
        return _cdma_swig.vector_insert2_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(vector_insert2_sptr self) -> io_signature_sptr"""
        return _cdma_swig.vector_insert2_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(vector_insert2_sptr self) -> long"""
        return _cdma_swig.vector_insert2_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(vector_insert2_sptr self) -> basic_block_sptr"""
        return _cdma_swig.vector_insert2_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(vector_insert2_sptr self, int ninputs, int noutputs) -> bool"""
        return _cdma_swig.vector_insert2_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(vector_insert2_sptr self) -> std::string"""
        return _cdma_swig.vector_insert2_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(vector_insert2_sptr self, std::string name)"""
        return _cdma_swig.vector_insert2_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(vector_insert2_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _cdma_swig.vector_insert2_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(vector_insert2_sptr self) -> swig_int_ptr"""
        return _cdma_swig.vector_insert2_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(vector_insert2_sptr self) -> swig_int_ptr"""
        return _cdma_swig.vector_insert2_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(vector_insert2_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _cdma_swig.vector_insert2_sptr_message_subscribers(self, which_port)

vector_insert2_sptr_swigregister = _cdma_swig.vector_insert2_sptr_swigregister
vector_insert2_sptr_swigregister(vector_insert2_sptr)


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

class flag_gen(object):
    """
    This block either passes through the input stream (assumed to be zeros or ones) when its internal state is acq=1, or it outputs a stream of zeros with periodic ones (with given period) when its internal state is acq=0.

    The purpose of this block is to be used right after the timing/frequency acquisition block. The timing/frequency acquisition block outputs a stream of 0s and 1s, with 1s indicating the begining of a cdma frame.
    When the system is in acquisition mode (acq=1), the flag_gen block just passes through its input stream, which comes from the timing/frequency acquisition block.
    When the system is in tracking mode (acq=0), the timing/frequency acquisition block is not supposed to produce any meaningful output flags. In this case, the flag_gen block produces periodical flags (with given period equal to the frame length) starting from the last flag produced by the timing/frequency acquisition block, in order to provide timing information for the remaining of the system.
     For example, when period is 4 the input and output streams will look like:
    acq:--->111111000000000...
    input:->010100000000000...
    output:-->010100010001000...
    where the first 1 in the input and output is for example due to a false acquisition.
    """

    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(period, acq):
        """
        make(int period, int acq) -> flag_gen_sptr

        Return a shared_ptr to a new instance of cdma::flag_gen.

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

        Params: (period, acq)
        """
        return _cdma_swig.flag_gen_make(period, acq)

    make = staticmethod(make)

    def set_acq(self, acq):
        """
        set_acq(flag_gen self, int acq)



        Params: (acq)
        """
        return _cdma_swig.flag_gen_set_acq(self, acq)

    __swig_destroy__ = _cdma_swig.delete_flag_gen
    __del__ = lambda self: None
flag_gen_swigregister = _cdma_swig.flag_gen_swigregister
flag_gen_swigregister(flag_gen)

def flag_gen_make(period, acq):
    """
    flag_gen_make(int period, int acq) -> flag_gen_sptr

    Return a shared_ptr to a new instance of cdma::flag_gen.

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

    Params: (period, acq)
    """
    return _cdma_swig.flag_gen_make(period, acq)

class flag_gen_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::cdma::flag_gen)> 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::cdma::flag_gen)> self) -> flag_gen_sptr
        __init__(boost::shared_ptr<(gr::cdma::flag_gen)> self, flag_gen p) -> flag_gen_sptr
        """
        this = _cdma_swig.new_flag_gen_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(flag_gen_sptr self) -> flag_gen"""
        return _cdma_swig.flag_gen_sptr___deref__(self)

    __swig_destroy__ = _cdma_swig.delete_flag_gen_sptr
    __del__ = lambda self: None

    def make(self, period, acq):
        """
        make(flag_gen_sptr self, int period, int acq) -> flag_gen_sptr

        Return a shared_ptr to a new instance of cdma::flag_gen.

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

        Params: (period, acq)
        """
        return _cdma_swig.flag_gen_sptr_make(self, period, acq)


    def set_acq(self, acq):
        """
        set_acq(flag_gen_sptr self, int acq)



        Params: (acq)
        """
        return _cdma_swig.flag_gen_sptr_set_acq(self, acq)


    def history(self):
        """history(flag_gen_sptr self) -> unsigned int"""
        return _cdma_swig.flag_gen_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(flag_gen_sptr self, int which, int delay)
        declare_sample_delay(flag_gen_sptr self, unsigned int delay)
        """
        return _cdma_swig.flag_gen_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(flag_gen_sptr self, int which) -> unsigned int"""
        return _cdma_swig.flag_gen_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(flag_gen_sptr self) -> int"""
        return _cdma_swig.flag_gen_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(flag_gen_sptr self) -> double"""
        return _cdma_swig.flag_gen_sptr_relative_rate(self)


    def start(self):
        """start(flag_gen_sptr self) -> bool"""
        return _cdma_swig.flag_gen_sptr_start(self)


    def stop(self):
        """stop(flag_gen_sptr self) -> bool"""
        return _cdma_swig.flag_gen_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(flag_gen_sptr self, unsigned int which_input) -> uint64_t"""
        return _cdma_swig.flag_gen_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(flag_gen_sptr self, unsigned int which_output) -> uint64_t"""
        return _cdma_swig.flag_gen_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(flag_gen_sptr self) -> int"""
        return _cdma_swig.flag_gen_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(flag_gen_sptr self, int m)"""
        return _cdma_swig.flag_gen_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(flag_gen_sptr self)"""
        return _cdma_swig.flag_gen_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(flag_gen_sptr self) -> bool"""
        return _cdma_swig.flag_gen_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(flag_gen_sptr self, int m)"""
        return _cdma_swig.flag_gen_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(flag_gen_sptr self) -> int"""
        return _cdma_swig.flag_gen_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(flag_gen_sptr self, int i) -> long"""
        return _cdma_swig.flag_gen_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(flag_gen_sptr self, long max_output_buffer)
        set_max_output_buffer(flag_gen_sptr self, int port, long max_output_buffer)
        """
        return _cdma_swig.flag_gen_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(flag_gen_sptr self, int i) -> long"""
        return _cdma_swig.flag_gen_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(flag_gen_sptr self, long min_output_buffer)
        set_min_output_buffer(flag_gen_sptr self, int port, long min_output_buffer)
        """
        return _cdma_swig.flag_gen_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(flag_gen_sptr self) -> float"""
        return _cdma_swig.flag_gen_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(flag_gen_sptr self) -> float"""
        return _cdma_swig.flag_gen_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(flag_gen_sptr self) -> float"""
        return _cdma_swig.flag_gen_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(flag_gen_sptr self) -> float"""
        return _cdma_swig.flag_gen_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(flag_gen_sptr self) -> float"""
        return _cdma_swig.flag_gen_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(flag_gen_sptr self) -> float"""
        return _cdma_swig.flag_gen_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(flag_gen_sptr self, int which) -> float
        pc_input_buffers_full(flag_gen_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.flag_gen_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(flag_gen_sptr self, int which) -> float
        pc_input_buffers_full_avg(flag_gen_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.flag_gen_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(flag_gen_sptr self, int which) -> float
        pc_input_buffers_full_var(flag_gen_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.flag_gen_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(flag_gen_sptr self, int which) -> float
        pc_output_buffers_full(flag_gen_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.flag_gen_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(flag_gen_sptr self, int which) -> float
        pc_output_buffers_full_avg(flag_gen_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.flag_gen_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(flag_gen_sptr self, int which) -> float
        pc_output_buffers_full_var(flag_gen_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.flag_gen_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(flag_gen_sptr self) -> float"""
        return _cdma_swig.flag_gen_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(flag_gen_sptr self) -> float"""
        return _cdma_swig.flag_gen_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(flag_gen_sptr self) -> float"""
        return _cdma_swig.flag_gen_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(flag_gen_sptr self) -> float"""
        return _cdma_swig.flag_gen_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(flag_gen_sptr self) -> float"""
        return _cdma_swig.flag_gen_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(flag_gen_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _cdma_swig.flag_gen_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(flag_gen_sptr self)"""
        return _cdma_swig.flag_gen_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(flag_gen_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _cdma_swig.flag_gen_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(flag_gen_sptr self) -> int"""
        return _cdma_swig.flag_gen_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(flag_gen_sptr self) -> int"""
        return _cdma_swig.flag_gen_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(flag_gen_sptr self, int priority) -> int"""
        return _cdma_swig.flag_gen_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(flag_gen_sptr self) -> std::string"""
        return _cdma_swig.flag_gen_sptr_name(self)


    def symbol_name(self):
        """symbol_name(flag_gen_sptr self) -> std::string"""
        return _cdma_swig.flag_gen_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(flag_gen_sptr self) -> io_signature_sptr"""
        return _cdma_swig.flag_gen_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(flag_gen_sptr self) -> io_signature_sptr"""
        return _cdma_swig.flag_gen_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(flag_gen_sptr self) -> long"""
        return _cdma_swig.flag_gen_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(flag_gen_sptr self) -> basic_block_sptr"""
        return _cdma_swig.flag_gen_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(flag_gen_sptr self, int ninputs, int noutputs) -> bool"""
        return _cdma_swig.flag_gen_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(flag_gen_sptr self) -> std::string"""
        return _cdma_swig.flag_gen_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(flag_gen_sptr self, std::string name)"""
        return _cdma_swig.flag_gen_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(flag_gen_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _cdma_swig.flag_gen_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(flag_gen_sptr self) -> swig_int_ptr"""
        return _cdma_swig.flag_gen_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(flag_gen_sptr self) -> swig_int_ptr"""
        return _cdma_swig.flag_gen_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(flag_gen_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _cdma_swig.flag_gen_sptr_message_subscribers(self, which_port)

flag_gen_sptr_swigregister = _cdma_swig.flag_gen_sptr_swigregister
flag_gen_sptr_swigregister(flag_gen_sptr)


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

class amp_var_est(object):
    """
    Assumes as input a constant complex signal with complex noise s[i]=(A+j B) + (wr[i]+j wi[i]) Estimates the signal power on the real part A^2 and real noise variance sigma^2.

    First convert the input stream from complex type to real type, so r[i]=A + wr[i]. 
    Then split the stream into two branches: 
     1) Pass the first branch through a single-pole IIR filter (averaging), square the result, and obtain an estimate of the signal power A^2. 
     2) Square the second branch, pass the result through a single-pole IIR filter, subtract the estimated signal power and obtain an estimate of the noise power sigma^2.

     For the IIR filter, the parameter alpha controls the averaging length. See equation below: 
     y[i] = (1-alpha)*y[i-1] + alpha*x[i].
    """

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

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

    def make(alpha):
        """
        make(float alpha) -> amp_var_est_sptr

        Return a shared_ptr to a new instance of cdma::amp_var_est.

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

        Params: (alpha)
        """
        return _cdma_swig.amp_var_est_make(alpha)

    make = staticmethod(make)

    def alpha(self):
        """
        alpha(amp_var_est self) -> float



        Params: (NONE)
        """
        return _cdma_swig.amp_var_est_alpha(self)


    def set_alpha(self, k):
        """
        set_alpha(amp_var_est self, float k)



        Params: (k)
        """
        return _cdma_swig.amp_var_est_set_alpha(self, k)

    __swig_destroy__ = _cdma_swig.delete_amp_var_est
    __del__ = lambda self: None
amp_var_est_swigregister = _cdma_swig.amp_var_est_swigregister
amp_var_est_swigregister(amp_var_est)

def amp_var_est_make(alpha):
    """
    amp_var_est_make(float alpha) -> amp_var_est_sptr

    Return a shared_ptr to a new instance of cdma::amp_var_est.

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

    Params: (alpha)
    """
    return _cdma_swig.amp_var_est_make(alpha)

class amp_var_est_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::cdma::amp_var_est)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::cdma::amp_var_est)> self) -> amp_var_est_sptr
        __init__(boost::shared_ptr<(gr::cdma::amp_var_est)> self, amp_var_est p) -> amp_var_est_sptr
        """
        this = _cdma_swig.new_amp_var_est_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(amp_var_est_sptr self) -> amp_var_est"""
        return _cdma_swig.amp_var_est_sptr___deref__(self)

    __swig_destroy__ = _cdma_swig.delete_amp_var_est_sptr
    __del__ = lambda self: None

    def make(self, alpha):
        """
        make(amp_var_est_sptr self, float alpha) -> amp_var_est_sptr

        Return a shared_ptr to a new instance of cdma::amp_var_est.

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

        Params: (alpha)
        """
        return _cdma_swig.amp_var_est_sptr_make(self, alpha)


    def alpha(self):
        """
        alpha(amp_var_est_sptr self) -> float



        Params: (NONE)
        """
        return _cdma_swig.amp_var_est_sptr_alpha(self)


    def set_alpha(self, k):
        """
        set_alpha(amp_var_est_sptr self, float k)



        Params: (k)
        """
        return _cdma_swig.amp_var_est_sptr_set_alpha(self, k)


    def history(self):
        """history(amp_var_est_sptr self) -> unsigned int"""
        return _cdma_swig.amp_var_est_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(amp_var_est_sptr self, int which, int delay)
        declare_sample_delay(amp_var_est_sptr self, unsigned int delay)
        """
        return _cdma_swig.amp_var_est_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(amp_var_est_sptr self, int which) -> unsigned int"""
        return _cdma_swig.amp_var_est_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(amp_var_est_sptr self) -> int"""
        return _cdma_swig.amp_var_est_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(amp_var_est_sptr self) -> double"""
        return _cdma_swig.amp_var_est_sptr_relative_rate(self)


    def start(self):
        """start(amp_var_est_sptr self) -> bool"""
        return _cdma_swig.amp_var_est_sptr_start(self)


    def stop(self):
        """stop(amp_var_est_sptr self) -> bool"""
        return _cdma_swig.amp_var_est_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(amp_var_est_sptr self, unsigned int which_input) -> uint64_t"""
        return _cdma_swig.amp_var_est_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(amp_var_est_sptr self, unsigned int which_output) -> uint64_t"""
        return _cdma_swig.amp_var_est_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(amp_var_est_sptr self) -> int"""
        return _cdma_swig.amp_var_est_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(amp_var_est_sptr self, int m)"""
        return _cdma_swig.amp_var_est_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(amp_var_est_sptr self)"""
        return _cdma_swig.amp_var_est_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(amp_var_est_sptr self) -> bool"""
        return _cdma_swig.amp_var_est_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(amp_var_est_sptr self, int m)"""
        return _cdma_swig.amp_var_est_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(amp_var_est_sptr self) -> int"""
        return _cdma_swig.amp_var_est_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(amp_var_est_sptr self, int i) -> long"""
        return _cdma_swig.amp_var_est_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(amp_var_est_sptr self, long max_output_buffer)
        set_max_output_buffer(amp_var_est_sptr self, int port, long max_output_buffer)
        """
        return _cdma_swig.amp_var_est_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(amp_var_est_sptr self, int i) -> long"""
        return _cdma_swig.amp_var_est_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(amp_var_est_sptr self, long min_output_buffer)
        set_min_output_buffer(amp_var_est_sptr self, int port, long min_output_buffer)
        """
        return _cdma_swig.amp_var_est_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(amp_var_est_sptr self) -> float"""
        return _cdma_swig.amp_var_est_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(amp_var_est_sptr self) -> float"""
        return _cdma_swig.amp_var_est_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(amp_var_est_sptr self) -> float"""
        return _cdma_swig.amp_var_est_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(amp_var_est_sptr self) -> float"""
        return _cdma_swig.amp_var_est_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(amp_var_est_sptr self) -> float"""
        return _cdma_swig.amp_var_est_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(amp_var_est_sptr self) -> float"""
        return _cdma_swig.amp_var_est_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(amp_var_est_sptr self, int which) -> float
        pc_input_buffers_full(amp_var_est_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.amp_var_est_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(amp_var_est_sptr self, int which) -> float
        pc_input_buffers_full_avg(amp_var_est_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.amp_var_est_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(amp_var_est_sptr self, int which) -> float
        pc_input_buffers_full_var(amp_var_est_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.amp_var_est_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(amp_var_est_sptr self, int which) -> float
        pc_output_buffers_full(amp_var_est_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.amp_var_est_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(amp_var_est_sptr self, int which) -> float
        pc_output_buffers_full_avg(amp_var_est_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.amp_var_est_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(amp_var_est_sptr self, int which) -> float
        pc_output_buffers_full_var(amp_var_est_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.amp_var_est_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(amp_var_est_sptr self) -> float"""
        return _cdma_swig.amp_var_est_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(amp_var_est_sptr self) -> float"""
        return _cdma_swig.amp_var_est_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(amp_var_est_sptr self) -> float"""
        return _cdma_swig.amp_var_est_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(amp_var_est_sptr self) -> float"""
        return _cdma_swig.amp_var_est_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(amp_var_est_sptr self) -> float"""
        return _cdma_swig.amp_var_est_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(amp_var_est_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _cdma_swig.amp_var_est_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(amp_var_est_sptr self)"""
        return _cdma_swig.amp_var_est_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(amp_var_est_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _cdma_swig.amp_var_est_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(amp_var_est_sptr self) -> int"""
        return _cdma_swig.amp_var_est_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(amp_var_est_sptr self) -> int"""
        return _cdma_swig.amp_var_est_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(amp_var_est_sptr self, int priority) -> int"""
        return _cdma_swig.amp_var_est_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(amp_var_est_sptr self) -> std::string"""
        return _cdma_swig.amp_var_est_sptr_name(self)


    def symbol_name(self):
        """symbol_name(amp_var_est_sptr self) -> std::string"""
        return _cdma_swig.amp_var_est_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(amp_var_est_sptr self) -> io_signature_sptr"""
        return _cdma_swig.amp_var_est_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(amp_var_est_sptr self) -> io_signature_sptr"""
        return _cdma_swig.amp_var_est_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(amp_var_est_sptr self) -> long"""
        return _cdma_swig.amp_var_est_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(amp_var_est_sptr self) -> basic_block_sptr"""
        return _cdma_swig.amp_var_est_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(amp_var_est_sptr self, int ninputs, int noutputs) -> bool"""
        return _cdma_swig.amp_var_est_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(amp_var_est_sptr self) -> std::string"""
        return _cdma_swig.amp_var_est_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(amp_var_est_sptr self, std::string name)"""
        return _cdma_swig.amp_var_est_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(amp_var_est_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _cdma_swig.amp_var_est_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(amp_var_est_sptr self) -> swig_int_ptr"""
        return _cdma_swig.amp_var_est_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(amp_var_est_sptr self) -> swig_int_ptr"""
        return _cdma_swig.amp_var_est_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(amp_var_est_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _cdma_swig.amp_var_est_sptr_message_subscribers(self, which_port)

amp_var_est_sptr_swigregister = _cdma_swig.amp_var_est_sptr_swigregister
amp_var_est_sptr_swigregister(amp_var_est_sptr)


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

class switched_peak_detector_fb(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(threshold_factor_rise=0.25, threshold_factor_fall=0.40, look_ahead=10, alpha=0.001, on=1):
        """
        make(float threshold_factor_rise=0.25, float threshold_factor_fall=0.40, int look_ahead=10, float alpha=0.001, int on=1) -> switched_peak_detector_fb_sptr

        Return a shared_ptr to a new instance of cdma::switched_peak_detector_fb.

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

        Params: (threshold_factor_rise, threshold_factor_fall, look_ahead, alpha, on)
        """
        return _cdma_swig.switched_peak_detector_fb_make(threshold_factor_rise, threshold_factor_fall, look_ahead, alpha, on)

    make = staticmethod(make)

    def set_threshold_factor_rise(self, thr):
        """
        set_threshold_factor_rise(switched_peak_detector_fb self, float thr)



        Params: (thr)
        """
        return _cdma_swig.switched_peak_detector_fb_set_threshold_factor_rise(self, thr)


    def set_threshold_factor_fall(self, thr):
        """
        set_threshold_factor_fall(switched_peak_detector_fb self, float thr)



        Params: (thr)
        """
        return _cdma_swig.switched_peak_detector_fb_set_threshold_factor_fall(self, thr)


    def set_look_ahead(self, look):
        """
        set_look_ahead(switched_peak_detector_fb self, int look)



        Params: (look)
        """
        return _cdma_swig.switched_peak_detector_fb_set_look_ahead(self, look)


    def set_alpha(self, alpha):
        """
        set_alpha(switched_peak_detector_fb self, float alpha)



        Params: (alpha)
        """
        return _cdma_swig.switched_peak_detector_fb_set_alpha(self, alpha)


    def set_on(self, on):
        """
        set_on(switched_peak_detector_fb self, int on)



        Params: (on)
        """
        return _cdma_swig.switched_peak_detector_fb_set_on(self, on)


    def threshold_factor_rise(self):
        """
        threshold_factor_rise(switched_peak_detector_fb self) -> float



        Params: (NONE)
        """
        return _cdma_swig.switched_peak_detector_fb_threshold_factor_rise(self)


    def threshold_factor_fall(self):
        """
        threshold_factor_fall(switched_peak_detector_fb self) -> float



        Params: (NONE)
        """
        return _cdma_swig.switched_peak_detector_fb_threshold_factor_fall(self)


    def look_ahead(self):
        """
        look_ahead(switched_peak_detector_fb self) -> int



        Params: (NONE)
        """
        return _cdma_swig.switched_peak_detector_fb_look_ahead(self)


    def alpha(self):
        """
        alpha(switched_peak_detector_fb self) -> float



        Params: (NONE)
        """
        return _cdma_swig.switched_peak_detector_fb_alpha(self)


    def on(self):
        """
        on(switched_peak_detector_fb self) -> int



        Params: (NONE)
        """
        return _cdma_swig.switched_peak_detector_fb_on(self)

    __swig_destroy__ = _cdma_swig.delete_switched_peak_detector_fb
    __del__ = lambda self: None
switched_peak_detector_fb_swigregister = _cdma_swig.switched_peak_detector_fb_swigregister
switched_peak_detector_fb_swigregister(switched_peak_detector_fb)

def switched_peak_detector_fb_make(threshold_factor_rise=0.25, threshold_factor_fall=0.40, look_ahead=10, alpha=0.001, on=1):
    """
    switched_peak_detector_fb_make(float threshold_factor_rise=0.25, float threshold_factor_fall=0.40, int look_ahead=10, float alpha=0.001, int on=1) -> switched_peak_detector_fb_sptr

    Return a shared_ptr to a new instance of cdma::switched_peak_detector_fb.

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

    Params: (threshold_factor_rise, threshold_factor_fall, look_ahead, alpha, on)
    """
    return _cdma_swig.switched_peak_detector_fb_make(threshold_factor_rise, threshold_factor_fall, look_ahead, alpha, on)

class switched_peak_detector_fb_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::cdma::switched_peak_detector_fb)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::cdma::switched_peak_detector_fb)> self) -> switched_peak_detector_fb_sptr
        __init__(boost::shared_ptr<(gr::cdma::switched_peak_detector_fb)> self, switched_peak_detector_fb p) -> switched_peak_detector_fb_sptr
        """
        this = _cdma_swig.new_switched_peak_detector_fb_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(switched_peak_detector_fb_sptr self) -> switched_peak_detector_fb"""
        return _cdma_swig.switched_peak_detector_fb_sptr___deref__(self)

    __swig_destroy__ = _cdma_swig.delete_switched_peak_detector_fb_sptr
    __del__ = lambda self: None

    def make(self, threshold_factor_rise=0.25, threshold_factor_fall=0.40, look_ahead=10, alpha=0.001, on=1):
        """
        make(switched_peak_detector_fb_sptr self, float threshold_factor_rise=0.25, float threshold_factor_fall=0.40, int look_ahead=10, float alpha=0.001, int on=1) -> switched_peak_detector_fb_sptr

        Return a shared_ptr to a new instance of cdma::switched_peak_detector_fb.

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

        Params: (threshold_factor_rise, threshold_factor_fall, look_ahead, alpha, on)
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_make(self, threshold_factor_rise, threshold_factor_fall, look_ahead, alpha, on)


    def set_threshold_factor_rise(self, thr):
        """
        set_threshold_factor_rise(switched_peak_detector_fb_sptr self, float thr)



        Params: (thr)
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_set_threshold_factor_rise(self, thr)


    def set_threshold_factor_fall(self, thr):
        """
        set_threshold_factor_fall(switched_peak_detector_fb_sptr self, float thr)



        Params: (thr)
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_set_threshold_factor_fall(self, thr)


    def set_look_ahead(self, look):
        """
        set_look_ahead(switched_peak_detector_fb_sptr self, int look)



        Params: (look)
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_set_look_ahead(self, look)


    def set_alpha(self, alpha):
        """
        set_alpha(switched_peak_detector_fb_sptr self, float alpha)



        Params: (alpha)
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_set_alpha(self, alpha)


    def set_on(self, on):
        """
        set_on(switched_peak_detector_fb_sptr self, int on)



        Params: (on)
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_set_on(self, on)


    def threshold_factor_rise(self):
        """
        threshold_factor_rise(switched_peak_detector_fb_sptr self) -> float



        Params: (NONE)
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_threshold_factor_rise(self)


    def threshold_factor_fall(self):
        """
        threshold_factor_fall(switched_peak_detector_fb_sptr self) -> float



        Params: (NONE)
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_threshold_factor_fall(self)


    def look_ahead(self):
        """
        look_ahead(switched_peak_detector_fb_sptr self) -> int



        Params: (NONE)
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_look_ahead(self)


    def alpha(self):
        """
        alpha(switched_peak_detector_fb_sptr self) -> float



        Params: (NONE)
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_alpha(self)


    def on(self):
        """
        on(switched_peak_detector_fb_sptr self) -> int



        Params: (NONE)
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_on(self)


    def history(self):
        """history(switched_peak_detector_fb_sptr self) -> unsigned int"""
        return _cdma_swig.switched_peak_detector_fb_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(switched_peak_detector_fb_sptr self, int which, int delay)
        declare_sample_delay(switched_peak_detector_fb_sptr self, unsigned int delay)
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(switched_peak_detector_fb_sptr self, int which) -> unsigned int"""
        return _cdma_swig.switched_peak_detector_fb_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(switched_peak_detector_fb_sptr self) -> int"""
        return _cdma_swig.switched_peak_detector_fb_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(switched_peak_detector_fb_sptr self) -> double"""
        return _cdma_swig.switched_peak_detector_fb_sptr_relative_rate(self)


    def start(self):
        """start(switched_peak_detector_fb_sptr self) -> bool"""
        return _cdma_swig.switched_peak_detector_fb_sptr_start(self)


    def stop(self):
        """stop(switched_peak_detector_fb_sptr self) -> bool"""
        return _cdma_swig.switched_peak_detector_fb_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(switched_peak_detector_fb_sptr self, unsigned int which_input) -> uint64_t"""
        return _cdma_swig.switched_peak_detector_fb_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(switched_peak_detector_fb_sptr self, unsigned int which_output) -> uint64_t"""
        return _cdma_swig.switched_peak_detector_fb_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(switched_peak_detector_fb_sptr self) -> int"""
        return _cdma_swig.switched_peak_detector_fb_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(switched_peak_detector_fb_sptr self, int m)"""
        return _cdma_swig.switched_peak_detector_fb_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(switched_peak_detector_fb_sptr self)"""
        return _cdma_swig.switched_peak_detector_fb_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(switched_peak_detector_fb_sptr self) -> bool"""
        return _cdma_swig.switched_peak_detector_fb_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(switched_peak_detector_fb_sptr self, int m)"""
        return _cdma_swig.switched_peak_detector_fb_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(switched_peak_detector_fb_sptr self) -> int"""
        return _cdma_swig.switched_peak_detector_fb_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(switched_peak_detector_fb_sptr self, int i) -> long"""
        return _cdma_swig.switched_peak_detector_fb_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(switched_peak_detector_fb_sptr self, long max_output_buffer)
        set_max_output_buffer(switched_peak_detector_fb_sptr self, int port, long max_output_buffer)
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(switched_peak_detector_fb_sptr self, int i) -> long"""
        return _cdma_swig.switched_peak_detector_fb_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(switched_peak_detector_fb_sptr self, long min_output_buffer)
        set_min_output_buffer(switched_peak_detector_fb_sptr self, int port, long min_output_buffer)
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(switched_peak_detector_fb_sptr self) -> float"""
        return _cdma_swig.switched_peak_detector_fb_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(switched_peak_detector_fb_sptr self) -> float"""
        return _cdma_swig.switched_peak_detector_fb_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(switched_peak_detector_fb_sptr self) -> float"""
        return _cdma_swig.switched_peak_detector_fb_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(switched_peak_detector_fb_sptr self) -> float"""
        return _cdma_swig.switched_peak_detector_fb_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(switched_peak_detector_fb_sptr self) -> float"""
        return _cdma_swig.switched_peak_detector_fb_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(switched_peak_detector_fb_sptr self) -> float"""
        return _cdma_swig.switched_peak_detector_fb_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(switched_peak_detector_fb_sptr self, int which) -> float
        pc_input_buffers_full(switched_peak_detector_fb_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(switched_peak_detector_fb_sptr self, int which) -> float
        pc_input_buffers_full_avg(switched_peak_detector_fb_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(switched_peak_detector_fb_sptr self, int which) -> float
        pc_input_buffers_full_var(switched_peak_detector_fb_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(switched_peak_detector_fb_sptr self, int which) -> float
        pc_output_buffers_full(switched_peak_detector_fb_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(switched_peak_detector_fb_sptr self, int which) -> float
        pc_output_buffers_full_avg(switched_peak_detector_fb_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(switched_peak_detector_fb_sptr self, int which) -> float
        pc_output_buffers_full_var(switched_peak_detector_fb_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.switched_peak_detector_fb_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(switched_peak_detector_fb_sptr self) -> float"""
        return _cdma_swig.switched_peak_detector_fb_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(switched_peak_detector_fb_sptr self) -> float"""
        return _cdma_swig.switched_peak_detector_fb_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(switched_peak_detector_fb_sptr self) -> float"""
        return _cdma_swig.switched_peak_detector_fb_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(switched_peak_detector_fb_sptr self) -> float"""
        return _cdma_swig.switched_peak_detector_fb_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(switched_peak_detector_fb_sptr self) -> float"""
        return _cdma_swig.switched_peak_detector_fb_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(switched_peak_detector_fb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _cdma_swig.switched_peak_detector_fb_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(switched_peak_detector_fb_sptr self)"""
        return _cdma_swig.switched_peak_detector_fb_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(switched_peak_detector_fb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _cdma_swig.switched_peak_detector_fb_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(switched_peak_detector_fb_sptr self) -> int"""
        return _cdma_swig.switched_peak_detector_fb_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(switched_peak_detector_fb_sptr self) -> int"""
        return _cdma_swig.switched_peak_detector_fb_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(switched_peak_detector_fb_sptr self, int priority) -> int"""
        return _cdma_swig.switched_peak_detector_fb_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(switched_peak_detector_fb_sptr self) -> std::string"""
        return _cdma_swig.switched_peak_detector_fb_sptr_name(self)


    def symbol_name(self):
        """symbol_name(switched_peak_detector_fb_sptr self) -> std::string"""
        return _cdma_swig.switched_peak_detector_fb_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(switched_peak_detector_fb_sptr self) -> io_signature_sptr"""
        return _cdma_swig.switched_peak_detector_fb_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(switched_peak_detector_fb_sptr self) -> io_signature_sptr"""
        return _cdma_swig.switched_peak_detector_fb_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(switched_peak_detector_fb_sptr self) -> long"""
        return _cdma_swig.switched_peak_detector_fb_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(switched_peak_detector_fb_sptr self) -> basic_block_sptr"""
        return _cdma_swig.switched_peak_detector_fb_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(switched_peak_detector_fb_sptr self, int ninputs, int noutputs) -> bool"""
        return _cdma_swig.switched_peak_detector_fb_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(switched_peak_detector_fb_sptr self) -> std::string"""
        return _cdma_swig.switched_peak_detector_fb_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(switched_peak_detector_fb_sptr self, std::string name)"""
        return _cdma_swig.switched_peak_detector_fb_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(switched_peak_detector_fb_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _cdma_swig.switched_peak_detector_fb_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(switched_peak_detector_fb_sptr self) -> swig_int_ptr"""
        return _cdma_swig.switched_peak_detector_fb_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(switched_peak_detector_fb_sptr self) -> swig_int_ptr"""
        return _cdma_swig.switched_peak_detector_fb_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(switched_peak_detector_fb_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _cdma_swig.switched_peak_detector_fb_sptr_message_subscribers(self, which_port)

switched_peak_detector_fb_sptr_swigregister = _cdma_swig.switched_peak_detector_fb_sptr_swigregister
switched_peak_detector_fb_sptr_swigregister(switched_peak_detector_fb_sptr)


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

class packet_header2_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::cdma::packet_header2)> 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::cdma::packet_header2)> self) -> packet_header2_sptr
        __init__(boost::shared_ptr<(gr::cdma::packet_header2)> self, packet_header2 p) -> packet_header2_sptr
        """
        this = _cdma_swig.new_packet_header2_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(packet_header2_sptr self) -> packet_header2"""
        return _cdma_swig.packet_header2_sptr___deref__(self)

    __swig_destroy__ = _cdma_swig.delete_packet_header2_sptr
    __del__ = lambda self: None

    def set_tcm_type(self, tcm_type):
        """
        set_tcm_type(packet_header2_sptr self, int tcm_type)



        Params: (tcm_type)
        """
        return _cdma_swig.packet_header2_sptr_set_tcm_type(self, tcm_type)


    def num_tag_key(self):
        """
        num_tag_key(packet_header2_sptr self) -> swig_int_ptr



        Params: (NONE)
        """
        return _cdma_swig.packet_header2_sptr_num_tag_key(self)


    def make(self, *args, **kwargs):
        """
        make(packet_header2_sptr self, long header_len, std::string const & len_tag_key, std::string const & num_tag_key, int bits_per_byte=1, int tcm_type=1, std::string const & tcm_tag_key) -> packet_header2_sptr



        Params: (header_len, len_tag_key, num_tag_key, bits_per_byte, tcm_type, tcm_tag_key)
        """
        return _cdma_swig.packet_header2_sptr_make(self, *args, **kwargs)


    def base(self):
        """base(packet_header2_sptr self) -> gr::digital::packet_header_default::sptr"""
        return _cdma_swig.packet_header2_sptr_base(self)


    def formatter(self):
        """formatter(packet_header2_sptr self) -> gr::digital::packet_header_default::sptr"""
        return _cdma_swig.packet_header2_sptr_formatter(self)


    def set_header_num(self, header_num):
        """set_header_num(packet_header2_sptr self, unsigned int header_num)"""
        return _cdma_swig.packet_header2_sptr_set_header_num(self, header_num)


    def header_len(self):
        """header_len(packet_header2_sptr self) -> long"""
        return _cdma_swig.packet_header2_sptr_header_len(self)


    def len_tag_key(self):
        """len_tag_key(packet_header2_sptr self) -> swig_int_ptr"""
        return _cdma_swig.packet_header2_sptr_len_tag_key(self)


    def header_formatter(self, *args, **kwargs):
        """header_formatter(packet_header2_sptr self, long packet_len, unsigned char * out, tags_vector_t tags) -> bool"""
        return _cdma_swig.packet_header2_sptr_header_formatter(self, *args, **kwargs)


    def header_parser(self, header, tags):
        """header_parser(packet_header2_sptr self, unsigned char const * header, tags_vector_t tags) -> bool"""
        return _cdma_swig.packet_header2_sptr_header_parser(self, header, tags)

packet_header2_sptr_swigregister = _cdma_swig.packet_header2_sptr_swigregister
packet_header2_sptr_swigregister(packet_header2_sptr)


packet_header2_sptr.__repr__ = lambda self: "<packet_header2>"
packet_header2 = packet_header2.make;

class pac_err_cal(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(winsize, cycsize, pkt_num_tag):
        """
        make(unsigned long winsize, unsigned long cycsize, std::string pkt_num_tag) -> pac_err_cal_sptr

        Return a shared_ptr to a new instance of cdma::pac_err_cal.

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

        Params: (winsize, cycsize, pkt_num_tag)
        """
        return _cdma_swig.pac_err_cal_make(winsize, cycsize, pkt_num_tag)

    make = staticmethod(make)

    def set_winsize(self, k):
        """
        set_winsize(pac_err_cal self, unsigned long k)



        Params: (k)
        """
        return _cdma_swig.pac_err_cal_set_winsize(self, k)


    def set_cycsize(self, t):
        """
        set_cycsize(pac_err_cal self, unsigned long t)



        Params: (t)
        """
        return _cdma_swig.pac_err_cal_set_cycsize(self, t)


    def set_pkt_num_tag(self, str):
        """
        set_pkt_num_tag(pac_err_cal self, std::string str)



        Params: (str)
        """
        return _cdma_swig.pac_err_cal_set_pkt_num_tag(self, str)

    __swig_destroy__ = _cdma_swig.delete_pac_err_cal
    __del__ = lambda self: None
pac_err_cal_swigregister = _cdma_swig.pac_err_cal_swigregister
pac_err_cal_swigregister(pac_err_cal)

def pac_err_cal_make(winsize, cycsize, pkt_num_tag):
    """
    pac_err_cal_make(unsigned long winsize, unsigned long cycsize, std::string pkt_num_tag) -> pac_err_cal_sptr

    Return a shared_ptr to a new instance of cdma::pac_err_cal.

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

    Params: (winsize, cycsize, pkt_num_tag)
    """
    return _cdma_swig.pac_err_cal_make(winsize, cycsize, pkt_num_tag)

class pac_err_cal_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::cdma::pac_err_cal)> 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::cdma::pac_err_cal)> self) -> pac_err_cal_sptr
        __init__(boost::shared_ptr<(gr::cdma::pac_err_cal)> self, pac_err_cal p) -> pac_err_cal_sptr
        """
        this = _cdma_swig.new_pac_err_cal_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(pac_err_cal_sptr self) -> pac_err_cal"""
        return _cdma_swig.pac_err_cal_sptr___deref__(self)

    __swig_destroy__ = _cdma_swig.delete_pac_err_cal_sptr
    __del__ = lambda self: None

    def make(self, winsize, cycsize, pkt_num_tag):
        """
        make(pac_err_cal_sptr self, unsigned long winsize, unsigned long cycsize, std::string pkt_num_tag) -> pac_err_cal_sptr

        Return a shared_ptr to a new instance of cdma::pac_err_cal.

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

        Params: (winsize, cycsize, pkt_num_tag)
        """
        return _cdma_swig.pac_err_cal_sptr_make(self, winsize, cycsize, pkt_num_tag)


    def set_winsize(self, k):
        """
        set_winsize(pac_err_cal_sptr self, unsigned long k)



        Params: (k)
        """
        return _cdma_swig.pac_err_cal_sptr_set_winsize(self, k)


    def set_cycsize(self, t):
        """
        set_cycsize(pac_err_cal_sptr self, unsigned long t)



        Params: (t)
        """
        return _cdma_swig.pac_err_cal_sptr_set_cycsize(self, t)


    def set_pkt_num_tag(self, str):
        """
        set_pkt_num_tag(pac_err_cal_sptr self, std::string str)



        Params: (str)
        """
        return _cdma_swig.pac_err_cal_sptr_set_pkt_num_tag(self, str)


    def history(self):
        """history(pac_err_cal_sptr self) -> unsigned int"""
        return _cdma_swig.pac_err_cal_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(pac_err_cal_sptr self, int which, int delay)
        declare_sample_delay(pac_err_cal_sptr self, unsigned int delay)
        """
        return _cdma_swig.pac_err_cal_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(pac_err_cal_sptr self, int which) -> unsigned int"""
        return _cdma_swig.pac_err_cal_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(pac_err_cal_sptr self) -> int"""
        return _cdma_swig.pac_err_cal_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(pac_err_cal_sptr self) -> double"""
        return _cdma_swig.pac_err_cal_sptr_relative_rate(self)


    def start(self):
        """start(pac_err_cal_sptr self) -> bool"""
        return _cdma_swig.pac_err_cal_sptr_start(self)


    def stop(self):
        """stop(pac_err_cal_sptr self) -> bool"""
        return _cdma_swig.pac_err_cal_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(pac_err_cal_sptr self, unsigned int which_input) -> uint64_t"""
        return _cdma_swig.pac_err_cal_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(pac_err_cal_sptr self, unsigned int which_output) -> uint64_t"""
        return _cdma_swig.pac_err_cal_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(pac_err_cal_sptr self) -> int"""
        return _cdma_swig.pac_err_cal_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(pac_err_cal_sptr self, int m)"""
        return _cdma_swig.pac_err_cal_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(pac_err_cal_sptr self)"""
        return _cdma_swig.pac_err_cal_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(pac_err_cal_sptr self) -> bool"""
        return _cdma_swig.pac_err_cal_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(pac_err_cal_sptr self, int m)"""
        return _cdma_swig.pac_err_cal_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(pac_err_cal_sptr self) -> int"""
        return _cdma_swig.pac_err_cal_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(pac_err_cal_sptr self, int i) -> long"""
        return _cdma_swig.pac_err_cal_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(pac_err_cal_sptr self, long max_output_buffer)
        set_max_output_buffer(pac_err_cal_sptr self, int port, long max_output_buffer)
        """
        return _cdma_swig.pac_err_cal_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(pac_err_cal_sptr self, int i) -> long"""
        return _cdma_swig.pac_err_cal_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(pac_err_cal_sptr self, long min_output_buffer)
        set_min_output_buffer(pac_err_cal_sptr self, int port, long min_output_buffer)
        """
        return _cdma_swig.pac_err_cal_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(pac_err_cal_sptr self) -> float"""
        return _cdma_swig.pac_err_cal_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(pac_err_cal_sptr self) -> float"""
        return _cdma_swig.pac_err_cal_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(pac_err_cal_sptr self) -> float"""
        return _cdma_swig.pac_err_cal_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(pac_err_cal_sptr self) -> float"""
        return _cdma_swig.pac_err_cal_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(pac_err_cal_sptr self) -> float"""
        return _cdma_swig.pac_err_cal_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(pac_err_cal_sptr self) -> float"""
        return _cdma_swig.pac_err_cal_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(pac_err_cal_sptr self, int which) -> float
        pc_input_buffers_full(pac_err_cal_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.pac_err_cal_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(pac_err_cal_sptr self, int which) -> float
        pc_input_buffers_full_avg(pac_err_cal_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.pac_err_cal_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(pac_err_cal_sptr self, int which) -> float
        pc_input_buffers_full_var(pac_err_cal_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.pac_err_cal_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(pac_err_cal_sptr self, int which) -> float
        pc_output_buffers_full(pac_err_cal_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.pac_err_cal_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(pac_err_cal_sptr self, int which) -> float
        pc_output_buffers_full_avg(pac_err_cal_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.pac_err_cal_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(pac_err_cal_sptr self, int which) -> float
        pc_output_buffers_full_var(pac_err_cal_sptr self) -> pmt_vector_float
        """
        return _cdma_swig.pac_err_cal_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(pac_err_cal_sptr self) -> float"""
        return _cdma_swig.pac_err_cal_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(pac_err_cal_sptr self) -> float"""
        return _cdma_swig.pac_err_cal_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(pac_err_cal_sptr self) -> float"""
        return _cdma_swig.pac_err_cal_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(pac_err_cal_sptr self) -> float"""
        return _cdma_swig.pac_err_cal_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(pac_err_cal_sptr self) -> float"""
        return _cdma_swig.pac_err_cal_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(pac_err_cal_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _cdma_swig.pac_err_cal_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(pac_err_cal_sptr self)"""
        return _cdma_swig.pac_err_cal_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(pac_err_cal_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _cdma_swig.pac_err_cal_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(pac_err_cal_sptr self) -> int"""
        return _cdma_swig.pac_err_cal_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(pac_err_cal_sptr self) -> int"""
        return _cdma_swig.pac_err_cal_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(pac_err_cal_sptr self, int priority) -> int"""
        return _cdma_swig.pac_err_cal_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(pac_err_cal_sptr self) -> std::string"""
        return _cdma_swig.pac_err_cal_sptr_name(self)


    def symbol_name(self):
        """symbol_name(pac_err_cal_sptr self) -> std::string"""
        return _cdma_swig.pac_err_cal_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(pac_err_cal_sptr self) -> io_signature_sptr"""
        return _cdma_swig.pac_err_cal_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(pac_err_cal_sptr self) -> io_signature_sptr"""
        return _cdma_swig.pac_err_cal_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(pac_err_cal_sptr self) -> long"""
        return _cdma_swig.pac_err_cal_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(pac_err_cal_sptr self) -> basic_block_sptr"""
        return _cdma_swig.pac_err_cal_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(pac_err_cal_sptr self, int ninputs, int noutputs) -> bool"""
        return _cdma_swig.pac_err_cal_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(pac_err_cal_sptr self) -> std::string"""
        return _cdma_swig.pac_err_cal_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(pac_err_cal_sptr self, std::string name)"""
        return _cdma_swig.pac_err_cal_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(pac_err_cal_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _cdma_swig.pac_err_cal_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(pac_err_cal_sptr self) -> swig_int_ptr"""
        return _cdma_swig.pac_err_cal_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(pac_err_cal_sptr self) -> swig_int_ptr"""
        return _cdma_swig.pac_err_cal_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(pac_err_cal_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _cdma_swig.pac_err_cal_sptr_message_subscribers(self, which_port)

pac_err_cal_sptr_swigregister = _cdma_swig.pac_err_cal_sptr_swigregister
pac_err_cal_sptr_swigregister(pac_err_cal_sptr)


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



