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

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

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

def high_res_timer_epoch():
    """high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _ais_swig.high_res_timer_epoch()
class freqest(object):
    """<+description of block+>"""

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

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

    def make(sample_rate, data_rate, fftlen):
        """
        make(float sample_rate, int data_rate, int fftlen) -> freqest_sptr

        Return a shared_ptr to a new instance of ais::freqest.

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

        Params: (sample_rate, data_rate, fftlen)
        """
        return _ais_swig.freqest_make(sample_rate, data_rate, fftlen)

    make = staticmethod(make)
    __swig_destroy__ = _ais_swig.delete_freqest
    __del__ = lambda self: None
freqest_swigregister = _ais_swig.freqest_swigregister
freqest_swigregister(freqest)

def freqest_make(sample_rate, data_rate, fftlen):
    """
    freqest_make(float sample_rate, int data_rate, int fftlen) -> freqest_sptr

    Return a shared_ptr to a new instance of ais::freqest.

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

    Params: (sample_rate, data_rate, fftlen)
    """
    return _ais_swig.freqest_make(sample_rate, data_rate, fftlen)

class freqest_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::ais::freqest)> 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::ais::freqest)> self) -> freqest_sptr
        __init__(boost::shared_ptr<(gr::ais::freqest)> self, freqest p) -> freqest_sptr
        """
        this = _ais_swig.new_freqest_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(freqest_sptr self) -> freqest"""
        return _ais_swig.freqest_sptr___deref__(self)

    __swig_destroy__ = _ais_swig.delete_freqest_sptr
    __del__ = lambda self: None

    def make(self, sample_rate, data_rate, fftlen):
        """
        make(freqest_sptr self, float sample_rate, int data_rate, int fftlen) -> freqest_sptr

        Return a shared_ptr to a new instance of ais::freqest.

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

        Params: (sample_rate, data_rate, fftlen)
        """
        return _ais_swig.freqest_sptr_make(self, sample_rate, data_rate, fftlen)


    def history(self):
        """history(freqest_sptr self) -> unsigned int"""
        return _ais_swig.freqest_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(freqest_sptr self, int which, int delay)
        declare_sample_delay(freqest_sptr self, unsigned int delay)
        """
        return _ais_swig.freqest_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(freqest_sptr self, int which) -> unsigned int"""
        return _ais_swig.freqest_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(freqest_sptr self) -> int"""
        return _ais_swig.freqest_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(freqest_sptr self) -> double"""
        return _ais_swig.freqest_sptr_relative_rate(self)


    def start(self):
        """start(freqest_sptr self) -> bool"""
        return _ais_swig.freqest_sptr_start(self)


    def stop(self):
        """stop(freqest_sptr self) -> bool"""
        return _ais_swig.freqest_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(freqest_sptr self, unsigned int which_input) -> uint64_t"""
        return _ais_swig.freqest_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(freqest_sptr self, unsigned int which_output) -> uint64_t"""
        return _ais_swig.freqest_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(freqest_sptr self) -> int"""
        return _ais_swig.freqest_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(freqest_sptr self, int m)"""
        return _ais_swig.freqest_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(freqest_sptr self)"""
        return _ais_swig.freqest_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(freqest_sptr self) -> bool"""
        return _ais_swig.freqest_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(freqest_sptr self, int m)"""
        return _ais_swig.freqest_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(freqest_sptr self) -> int"""
        return _ais_swig.freqest_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(freqest_sptr self, int i) -> long"""
        return _ais_swig.freqest_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(freqest_sptr self, long max_output_buffer)
        set_max_output_buffer(freqest_sptr self, int port, long max_output_buffer)
        """
        return _ais_swig.freqest_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(freqest_sptr self, int i) -> long"""
        return _ais_swig.freqest_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(freqest_sptr self, long min_output_buffer)
        set_min_output_buffer(freqest_sptr self, int port, long min_output_buffer)
        """
        return _ais_swig.freqest_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(freqest_sptr self) -> float"""
        return _ais_swig.freqest_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(freqest_sptr self) -> float"""
        return _ais_swig.freqest_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(freqest_sptr self) -> float"""
        return _ais_swig.freqest_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(freqest_sptr self) -> float"""
        return _ais_swig.freqest_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(freqest_sptr self) -> float"""
        return _ais_swig.freqest_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(freqest_sptr self) -> float"""
        return _ais_swig.freqest_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(freqest_sptr self, int which) -> float
        pc_input_buffers_full(freqest_sptr self) -> pmt_vector_float
        """
        return _ais_swig.freqest_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(freqest_sptr self, int which) -> float
        pc_input_buffers_full_avg(freqest_sptr self) -> pmt_vector_float
        """
        return _ais_swig.freqest_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(freqest_sptr self, int which) -> float
        pc_input_buffers_full_var(freqest_sptr self) -> pmt_vector_float
        """
        return _ais_swig.freqest_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(freqest_sptr self, int which) -> float
        pc_output_buffers_full(freqest_sptr self) -> pmt_vector_float
        """
        return _ais_swig.freqest_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(freqest_sptr self, int which) -> float
        pc_output_buffers_full_avg(freqest_sptr self) -> pmt_vector_float
        """
        return _ais_swig.freqest_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(freqest_sptr self, int which) -> float
        pc_output_buffers_full_var(freqest_sptr self) -> pmt_vector_float
        """
        return _ais_swig.freqest_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(freqest_sptr self) -> float"""
        return _ais_swig.freqest_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(freqest_sptr self) -> float"""
        return _ais_swig.freqest_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(freqest_sptr self) -> float"""
        return _ais_swig.freqest_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(freqest_sptr self) -> float"""
        return _ais_swig.freqest_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(freqest_sptr self) -> float"""
        return _ais_swig.freqest_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(freqest_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _ais_swig.freqest_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(freqest_sptr self)"""
        return _ais_swig.freqest_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(freqest_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _ais_swig.freqest_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(freqest_sptr self) -> int"""
        return _ais_swig.freqest_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(freqest_sptr self) -> int"""
        return _ais_swig.freqest_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(freqest_sptr self, int priority) -> int"""
        return _ais_swig.freqest_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(freqest_sptr self) -> std::string"""
        return _ais_swig.freqest_sptr_name(self)


    def symbol_name(self):
        """symbol_name(freqest_sptr self) -> std::string"""
        return _ais_swig.freqest_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(freqest_sptr self) -> io_signature_sptr"""
        return _ais_swig.freqest_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(freqest_sptr self) -> io_signature_sptr"""
        return _ais_swig.freqest_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(freqest_sptr self) -> long"""
        return _ais_swig.freqest_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(freqest_sptr self) -> basic_block_sptr"""
        return _ais_swig.freqest_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(freqest_sptr self, int ninputs, int noutputs) -> bool"""
        return _ais_swig.freqest_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(freqest_sptr self) -> std::string"""
        return _ais_swig.freqest_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(freqest_sptr self, std::string name)"""
        return _ais_swig.freqest_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(freqest_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _ais_swig.freqest_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(freqest_sptr self) -> swig_int_ptr"""
        return _ais_swig.freqest_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(freqest_sptr self) -> swig_int_ptr"""
        return _ais_swig.freqest_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(freqest_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _ais_swig.freqest_sptr_message_subscribers(self, which_port)

freqest_sptr_swigregister = _ais_swig.freqest_sptr_swigregister
freqest_sptr_swigregister(freqest_sptr)


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

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

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

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

    def make():
        """
        make() -> invert_sptr

        Return a shared_ptr to a new instance of ais::invert.

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

        Params: (NONE)
        """
        return _ais_swig.invert_make()

    make = staticmethod(make)
    __swig_destroy__ = _ais_swig.delete_invert
    __del__ = lambda self: None
invert_swigregister = _ais_swig.invert_swigregister
invert_swigregister(invert)

def invert_make():
    """
    invert_make() -> invert_sptr

    Return a shared_ptr to a new instance of ais::invert.

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

    Params: (NONE)
    """
    return _ais_swig.invert_make()

class invert_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::ais::invert)> 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::ais::invert)> self) -> invert_sptr
        __init__(boost::shared_ptr<(gr::ais::invert)> self, invert p) -> invert_sptr
        """
        this = _ais_swig.new_invert_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(invert_sptr self) -> invert"""
        return _ais_swig.invert_sptr___deref__(self)

    __swig_destroy__ = _ais_swig.delete_invert_sptr
    __del__ = lambda self: None

    def make(self):
        """
        make(invert_sptr self) -> invert_sptr

        Return a shared_ptr to a new instance of ais::invert.

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

        Params: (NONE)
        """
        return _ais_swig.invert_sptr_make(self)


    def history(self):
        """history(invert_sptr self) -> unsigned int"""
        return _ais_swig.invert_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(invert_sptr self, int which, int delay)
        declare_sample_delay(invert_sptr self, unsigned int delay)
        """
        return _ais_swig.invert_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(invert_sptr self, int which) -> unsigned int"""
        return _ais_swig.invert_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(invert_sptr self) -> int"""
        return _ais_swig.invert_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(invert_sptr self) -> double"""
        return _ais_swig.invert_sptr_relative_rate(self)


    def start(self):
        """start(invert_sptr self) -> bool"""
        return _ais_swig.invert_sptr_start(self)


    def stop(self):
        """stop(invert_sptr self) -> bool"""
        return _ais_swig.invert_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(invert_sptr self, unsigned int which_input) -> uint64_t"""
        return _ais_swig.invert_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(invert_sptr self, unsigned int which_output) -> uint64_t"""
        return _ais_swig.invert_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(invert_sptr self) -> int"""
        return _ais_swig.invert_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(invert_sptr self, int m)"""
        return _ais_swig.invert_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(invert_sptr self)"""
        return _ais_swig.invert_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(invert_sptr self) -> bool"""
        return _ais_swig.invert_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(invert_sptr self, int m)"""
        return _ais_swig.invert_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(invert_sptr self) -> int"""
        return _ais_swig.invert_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(invert_sptr self, int i) -> long"""
        return _ais_swig.invert_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(invert_sptr self, long max_output_buffer)
        set_max_output_buffer(invert_sptr self, int port, long max_output_buffer)
        """
        return _ais_swig.invert_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(invert_sptr self, int i) -> long"""
        return _ais_swig.invert_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(invert_sptr self, long min_output_buffer)
        set_min_output_buffer(invert_sptr self, int port, long min_output_buffer)
        """
        return _ais_swig.invert_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(invert_sptr self) -> float"""
        return _ais_swig.invert_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(invert_sptr self) -> float"""
        return _ais_swig.invert_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(invert_sptr self) -> float"""
        return _ais_swig.invert_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(invert_sptr self) -> float"""
        return _ais_swig.invert_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(invert_sptr self) -> float"""
        return _ais_swig.invert_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(invert_sptr self) -> float"""
        return _ais_swig.invert_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(invert_sptr self, int which) -> float
        pc_input_buffers_full(invert_sptr self) -> pmt_vector_float
        """
        return _ais_swig.invert_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(invert_sptr self, int which) -> float
        pc_input_buffers_full_avg(invert_sptr self) -> pmt_vector_float
        """
        return _ais_swig.invert_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(invert_sptr self, int which) -> float
        pc_input_buffers_full_var(invert_sptr self) -> pmt_vector_float
        """
        return _ais_swig.invert_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(invert_sptr self, int which) -> float
        pc_output_buffers_full(invert_sptr self) -> pmt_vector_float
        """
        return _ais_swig.invert_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(invert_sptr self, int which) -> float
        pc_output_buffers_full_avg(invert_sptr self) -> pmt_vector_float
        """
        return _ais_swig.invert_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(invert_sptr self, int which) -> float
        pc_output_buffers_full_var(invert_sptr self) -> pmt_vector_float
        """
        return _ais_swig.invert_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(invert_sptr self) -> float"""
        return _ais_swig.invert_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(invert_sptr self) -> float"""
        return _ais_swig.invert_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(invert_sptr self) -> float"""
        return _ais_swig.invert_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(invert_sptr self) -> float"""
        return _ais_swig.invert_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(invert_sptr self) -> float"""
        return _ais_swig.invert_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(invert_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _ais_swig.invert_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(invert_sptr self)"""
        return _ais_swig.invert_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(invert_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _ais_swig.invert_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(invert_sptr self) -> int"""
        return _ais_swig.invert_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(invert_sptr self) -> int"""
        return _ais_swig.invert_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(invert_sptr self, int priority) -> int"""
        return _ais_swig.invert_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(invert_sptr self) -> std::string"""
        return _ais_swig.invert_sptr_name(self)


    def symbol_name(self):
        """symbol_name(invert_sptr self) -> std::string"""
        return _ais_swig.invert_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(invert_sptr self) -> io_signature_sptr"""
        return _ais_swig.invert_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(invert_sptr self) -> io_signature_sptr"""
        return _ais_swig.invert_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(invert_sptr self) -> long"""
        return _ais_swig.invert_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(invert_sptr self) -> basic_block_sptr"""
        return _ais_swig.invert_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(invert_sptr self, int ninputs, int noutputs) -> bool"""
        return _ais_swig.invert_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(invert_sptr self) -> std::string"""
        return _ais_swig.invert_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(invert_sptr self, std::string name)"""
        return _ais_swig.invert_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(invert_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _ais_swig.invert_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(invert_sptr self) -> swig_int_ptr"""
        return _ais_swig.invert_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(invert_sptr self) -> swig_int_ptr"""
        return _ais_swig.invert_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(invert_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _ais_swig.invert_sptr_message_subscribers(self, which_port)

invert_sptr_swigregister = _ais_swig.invert_sptr_swigregister
invert_sptr_swigregister(invert_sptr)


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

class msk_timing_recovery_cc(object):
    """
    MSK/GMSK timing recovery.

    This block performs timing synchronization on CPM modulations using a fourth-order nonlinearity feedback method which is non-data-aided. The block does not require prior phase synchronization but is relatively sensitive to frequency offset (keep offset to 0.1x symbol rate).


    For details on the algorithm, see: A.N. D'Andrea, U. Mengali, R. Reggiannini: A digital approach to clock recovery in generalized minimum shift keying. IEEE Transactions on Vehicular Technology, Vol. 39, Issue 3.
    """

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

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

    def make(sps, gain, limit, osps):
        """
        make(float sps, float gain, float limit, int osps) -> msk_timing_recovery_cc_sptr

        Make an MSK timing recovery block.

        Params: (sps, gain, limit, osps)
        """
        return _ais_swig.msk_timing_recovery_cc_make(sps, gain, limit, osps)

    make = staticmethod(make)

    def set_gain(self, gain):
        """
        set_gain(msk_timing_recovery_cc self, float gain)



        Params: (gain)
        """
        return _ais_swig.msk_timing_recovery_cc_set_gain(self, gain)


    def get_gain(self):
        """
        get_gain(msk_timing_recovery_cc self) -> float



        Params: ()
        """
        return _ais_swig.msk_timing_recovery_cc_get_gain(self)


    def set_limit(self, limit):
        """
        set_limit(msk_timing_recovery_cc self, float limit)



        Params: (limit)
        """
        return _ais_swig.msk_timing_recovery_cc_set_limit(self, limit)


    def get_limit(self):
        """
        get_limit(msk_timing_recovery_cc self) -> float



        Params: ()
        """
        return _ais_swig.msk_timing_recovery_cc_get_limit(self)


    def set_sps(self, sps):
        """
        set_sps(msk_timing_recovery_cc self, float sps)



        Params: (sps)
        """
        return _ais_swig.msk_timing_recovery_cc_set_sps(self, sps)


    def get_sps(self):
        """
        get_sps(msk_timing_recovery_cc self) -> float



        Params: ()
        """
        return _ais_swig.msk_timing_recovery_cc_get_sps(self)

    __swig_destroy__ = _ais_swig.delete_msk_timing_recovery_cc
    __del__ = lambda self: None
msk_timing_recovery_cc_swigregister = _ais_swig.msk_timing_recovery_cc_swigregister
msk_timing_recovery_cc_swigregister(msk_timing_recovery_cc)

def msk_timing_recovery_cc_make(sps, gain, limit, osps):
    """
    msk_timing_recovery_cc_make(float sps, float gain, float limit, int osps) -> msk_timing_recovery_cc_sptr

    Make an MSK timing recovery block.

    Params: (sps, gain, limit, osps)
    """
    return _ais_swig.msk_timing_recovery_cc_make(sps, gain, limit, osps)

class msk_timing_recovery_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::ais::msk_timing_recovery_cc)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::ais::msk_timing_recovery_cc)> self) -> msk_timing_recovery_cc_sptr
        __init__(boost::shared_ptr<(gr::ais::msk_timing_recovery_cc)> self, msk_timing_recovery_cc p) -> msk_timing_recovery_cc_sptr
        """
        this = _ais_swig.new_msk_timing_recovery_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(msk_timing_recovery_cc_sptr self) -> msk_timing_recovery_cc"""
        return _ais_swig.msk_timing_recovery_cc_sptr___deref__(self)

    __swig_destroy__ = _ais_swig.delete_msk_timing_recovery_cc_sptr
    __del__ = lambda self: None

    def make(self, sps, gain, limit, osps):
        """
        make(msk_timing_recovery_cc_sptr self, float sps, float gain, float limit, int osps) -> msk_timing_recovery_cc_sptr

        Make an MSK timing recovery block.

        Params: (sps, gain, limit, osps)
        """
        return _ais_swig.msk_timing_recovery_cc_sptr_make(self, sps, gain, limit, osps)


    def set_gain(self, gain):
        """
        set_gain(msk_timing_recovery_cc_sptr self, float gain)



        Params: (gain)
        """
        return _ais_swig.msk_timing_recovery_cc_sptr_set_gain(self, gain)


    def get_gain(self):
        """
        get_gain(msk_timing_recovery_cc_sptr self) -> float



        Params: ()
        """
        return _ais_swig.msk_timing_recovery_cc_sptr_get_gain(self)


    def set_limit(self, limit):
        """
        set_limit(msk_timing_recovery_cc_sptr self, float limit)



        Params: (limit)
        """
        return _ais_swig.msk_timing_recovery_cc_sptr_set_limit(self, limit)


    def get_limit(self):
        """
        get_limit(msk_timing_recovery_cc_sptr self) -> float



        Params: ()
        """
        return _ais_swig.msk_timing_recovery_cc_sptr_get_limit(self)


    def set_sps(self, sps):
        """
        set_sps(msk_timing_recovery_cc_sptr self, float sps)



        Params: (sps)
        """
        return _ais_swig.msk_timing_recovery_cc_sptr_set_sps(self, sps)


    def get_sps(self):
        """
        get_sps(msk_timing_recovery_cc_sptr self) -> float



        Params: ()
        """
        return _ais_swig.msk_timing_recovery_cc_sptr_get_sps(self)


    def history(self):
        """history(msk_timing_recovery_cc_sptr self) -> unsigned int"""
        return _ais_swig.msk_timing_recovery_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(msk_timing_recovery_cc_sptr self, int which, int delay)
        declare_sample_delay(msk_timing_recovery_cc_sptr self, unsigned int delay)
        """
        return _ais_swig.msk_timing_recovery_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(msk_timing_recovery_cc_sptr self, int which) -> unsigned int"""
        return _ais_swig.msk_timing_recovery_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(msk_timing_recovery_cc_sptr self) -> int"""
        return _ais_swig.msk_timing_recovery_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(msk_timing_recovery_cc_sptr self) -> double"""
        return _ais_swig.msk_timing_recovery_cc_sptr_relative_rate(self)


    def start(self):
        """start(msk_timing_recovery_cc_sptr self) -> bool"""
        return _ais_swig.msk_timing_recovery_cc_sptr_start(self)


    def stop(self):
        """stop(msk_timing_recovery_cc_sptr self) -> bool"""
        return _ais_swig.msk_timing_recovery_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(msk_timing_recovery_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _ais_swig.msk_timing_recovery_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(msk_timing_recovery_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _ais_swig.msk_timing_recovery_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(msk_timing_recovery_cc_sptr self) -> int"""
        return _ais_swig.msk_timing_recovery_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(msk_timing_recovery_cc_sptr self, int m)"""
        return _ais_swig.msk_timing_recovery_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(msk_timing_recovery_cc_sptr self)"""
        return _ais_swig.msk_timing_recovery_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(msk_timing_recovery_cc_sptr self) -> bool"""
        return _ais_swig.msk_timing_recovery_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(msk_timing_recovery_cc_sptr self, int m)"""
        return _ais_swig.msk_timing_recovery_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(msk_timing_recovery_cc_sptr self) -> int"""
        return _ais_swig.msk_timing_recovery_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(msk_timing_recovery_cc_sptr self, int i) -> long"""
        return _ais_swig.msk_timing_recovery_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(msk_timing_recovery_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(msk_timing_recovery_cc_sptr self, int port, long max_output_buffer)
        """
        return _ais_swig.msk_timing_recovery_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(msk_timing_recovery_cc_sptr self, int i) -> long"""
        return _ais_swig.msk_timing_recovery_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(msk_timing_recovery_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(msk_timing_recovery_cc_sptr self, int port, long min_output_buffer)
        """
        return _ais_swig.msk_timing_recovery_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(msk_timing_recovery_cc_sptr self) -> float"""
        return _ais_swig.msk_timing_recovery_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(msk_timing_recovery_cc_sptr self) -> float"""
        return _ais_swig.msk_timing_recovery_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(msk_timing_recovery_cc_sptr self) -> float"""
        return _ais_swig.msk_timing_recovery_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(msk_timing_recovery_cc_sptr self) -> float"""
        return _ais_swig.msk_timing_recovery_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(msk_timing_recovery_cc_sptr self) -> float"""
        return _ais_swig.msk_timing_recovery_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(msk_timing_recovery_cc_sptr self) -> float"""
        return _ais_swig.msk_timing_recovery_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(msk_timing_recovery_cc_sptr self, int which) -> float
        pc_input_buffers_full(msk_timing_recovery_cc_sptr self) -> pmt_vector_float
        """
        return _ais_swig.msk_timing_recovery_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(msk_timing_recovery_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(msk_timing_recovery_cc_sptr self) -> pmt_vector_float
        """
        return _ais_swig.msk_timing_recovery_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(msk_timing_recovery_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(msk_timing_recovery_cc_sptr self) -> pmt_vector_float
        """
        return _ais_swig.msk_timing_recovery_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(msk_timing_recovery_cc_sptr self, int which) -> float
        pc_output_buffers_full(msk_timing_recovery_cc_sptr self) -> pmt_vector_float
        """
        return _ais_swig.msk_timing_recovery_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(msk_timing_recovery_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(msk_timing_recovery_cc_sptr self) -> pmt_vector_float
        """
        return _ais_swig.msk_timing_recovery_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(msk_timing_recovery_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(msk_timing_recovery_cc_sptr self) -> pmt_vector_float
        """
        return _ais_swig.msk_timing_recovery_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(msk_timing_recovery_cc_sptr self) -> float"""
        return _ais_swig.msk_timing_recovery_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(msk_timing_recovery_cc_sptr self) -> float"""
        return _ais_swig.msk_timing_recovery_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(msk_timing_recovery_cc_sptr self) -> float"""
        return _ais_swig.msk_timing_recovery_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(msk_timing_recovery_cc_sptr self) -> float"""
        return _ais_swig.msk_timing_recovery_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(msk_timing_recovery_cc_sptr self) -> float"""
        return _ais_swig.msk_timing_recovery_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(msk_timing_recovery_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _ais_swig.msk_timing_recovery_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(msk_timing_recovery_cc_sptr self)"""
        return _ais_swig.msk_timing_recovery_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(msk_timing_recovery_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _ais_swig.msk_timing_recovery_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(msk_timing_recovery_cc_sptr self) -> int"""
        return _ais_swig.msk_timing_recovery_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(msk_timing_recovery_cc_sptr self) -> int"""
        return _ais_swig.msk_timing_recovery_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(msk_timing_recovery_cc_sptr self, int priority) -> int"""
        return _ais_swig.msk_timing_recovery_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(msk_timing_recovery_cc_sptr self) -> std::string"""
        return _ais_swig.msk_timing_recovery_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(msk_timing_recovery_cc_sptr self) -> std::string"""
        return _ais_swig.msk_timing_recovery_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(msk_timing_recovery_cc_sptr self) -> io_signature_sptr"""
        return _ais_swig.msk_timing_recovery_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(msk_timing_recovery_cc_sptr self) -> io_signature_sptr"""
        return _ais_swig.msk_timing_recovery_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(msk_timing_recovery_cc_sptr self) -> long"""
        return _ais_swig.msk_timing_recovery_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(msk_timing_recovery_cc_sptr self) -> basic_block_sptr"""
        return _ais_swig.msk_timing_recovery_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(msk_timing_recovery_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _ais_swig.msk_timing_recovery_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(msk_timing_recovery_cc_sptr self) -> std::string"""
        return _ais_swig.msk_timing_recovery_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(msk_timing_recovery_cc_sptr self, std::string name)"""
        return _ais_swig.msk_timing_recovery_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(msk_timing_recovery_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _ais_swig.msk_timing_recovery_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(msk_timing_recovery_cc_sptr self) -> swig_int_ptr"""
        return _ais_swig.msk_timing_recovery_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(msk_timing_recovery_cc_sptr self) -> swig_int_ptr"""
        return _ais_swig.msk_timing_recovery_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(msk_timing_recovery_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _ais_swig.msk_timing_recovery_cc_sptr_message_subscribers(self, which_port)

msk_timing_recovery_cc_sptr_swigregister = _ais_swig.msk_timing_recovery_cc_sptr_swigregister
msk_timing_recovery_cc_sptr_swigregister(msk_timing_recovery_cc_sptr)


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

class corr_est_cc(object):
    """
    Correlate stream with a pre-defined sequence and estimate peak.

    Input: 
    Output: 

    This block is designed to search for a sync word by correlation and uses the results of the correlation to get a time and phase offset estimate. These estimates are passed downstream as stream tags for use by follow-on synchronization blocks.


    The sync word is provided as a set of symbols along with a baseband matched filter which we use to create the filtered and upsampled symbols that we will receive over-the-air.


    The phase_est tag can be used by downstream blocks to adjust their phase estimatopm/correction loops, and is currently implemented by the gr::digital::costas_loop_cc block.


    The time_est tag can be used to adjust the sampling timing estimate of any downstream synchronization blocks and is currently implemented by the gr::digital::pfb_clock_sync_ccf block.


    The caller must provide a "time_est" and "phase_est" tag marking delay from the start of the correlated signal segment, in order to mark the proper point in the sync word for downstream synchronization blocks. Generally this block cannot know where the actual sync word symbols are located relative to "corr_start", given that some modulations have pulses with intentional ISI. The user should manually examine the primary output and the "corr_start" tag postition to determine the required tag delay settings for the particular modulation, sync word, and downstream blocks used.


    For a discussion of the properties of complex correlations, with respect to signal processing, see: Marple, Jr., S. L., "Estimating Group Delay and Phase Delay via Discrete-Time 'Analytic' Cross-Correlation,  , Volume 47, No. 9, September 1999
    """

    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(symbols, sps, mark_delay, threshold=0.9):
        """
        make(pmt_vector_cfloat symbols, float sps, unsigned int mark_delay, float threshold=0.9) -> corr_est_cc_sptr

        Make a block that correlates against the  vector and outputs a phase and symbol timing estimate.

        Params: (symbols, sps, mark_delay, threshold)
        """
        return _ais_swig.corr_est_cc_make(symbols, sps, mark_delay, threshold)

    make = staticmethod(make)

    def symbols(self):
        """
        symbols(corr_est_cc self) -> pmt_vector_cfloat



        Params: (NONE)
        """
        return _ais_swig.corr_est_cc_symbols(self)


    def set_symbols(self, symbols):
        """
        set_symbols(corr_est_cc self, pmt_vector_cfloat symbols)



        Params: (symbols)
        """
        return _ais_swig.corr_est_cc_set_symbols(self, symbols)

    __swig_destroy__ = _ais_swig.delete_corr_est_cc
    __del__ = lambda self: None
corr_est_cc_swigregister = _ais_swig.corr_est_cc_swigregister
corr_est_cc_swigregister(corr_est_cc)

def corr_est_cc_make(symbols, sps, mark_delay, threshold=0.9):
    """
    corr_est_cc_make(pmt_vector_cfloat symbols, float sps, unsigned int mark_delay, float threshold=0.9) -> corr_est_cc_sptr

    Make a block that correlates against the  vector and outputs a phase and symbol timing estimate.

    Params: (symbols, sps, mark_delay, threshold)
    """
    return _ais_swig.corr_est_cc_make(symbols, sps, mark_delay, threshold)

class corr_est_cc_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::ais::corr_est_cc)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::ais::corr_est_cc)> self) -> corr_est_cc_sptr
        __init__(boost::shared_ptr<(gr::ais::corr_est_cc)> self, corr_est_cc p) -> corr_est_cc_sptr
        """
        this = _ais_swig.new_corr_est_cc_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(corr_est_cc_sptr self) -> corr_est_cc"""
        return _ais_swig.corr_est_cc_sptr___deref__(self)

    __swig_destroy__ = _ais_swig.delete_corr_est_cc_sptr
    __del__ = lambda self: None

    def make(self, symbols, sps, mark_delay, threshold=0.9):
        """
        make(corr_est_cc_sptr self, pmt_vector_cfloat symbols, float sps, unsigned int mark_delay, float threshold=0.9) -> corr_est_cc_sptr

        Make a block that correlates against the  vector and outputs a phase and symbol timing estimate.

        Params: (symbols, sps, mark_delay, threshold)
        """
        return _ais_swig.corr_est_cc_sptr_make(self, symbols, sps, mark_delay, threshold)


    def symbols(self):
        """
        symbols(corr_est_cc_sptr self) -> pmt_vector_cfloat



        Params: (NONE)
        """
        return _ais_swig.corr_est_cc_sptr_symbols(self)


    def set_symbols(self, symbols):
        """
        set_symbols(corr_est_cc_sptr self, pmt_vector_cfloat symbols)



        Params: (symbols)
        """
        return _ais_swig.corr_est_cc_sptr_set_symbols(self, symbols)


    def history(self):
        """history(corr_est_cc_sptr self) -> unsigned int"""
        return _ais_swig.corr_est_cc_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(corr_est_cc_sptr self, int which, int delay)
        declare_sample_delay(corr_est_cc_sptr self, unsigned int delay)
        """
        return _ais_swig.corr_est_cc_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(corr_est_cc_sptr self, int which) -> unsigned int"""
        return _ais_swig.corr_est_cc_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(corr_est_cc_sptr self) -> int"""
        return _ais_swig.corr_est_cc_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(corr_est_cc_sptr self) -> double"""
        return _ais_swig.corr_est_cc_sptr_relative_rate(self)


    def start(self):
        """start(corr_est_cc_sptr self) -> bool"""
        return _ais_swig.corr_est_cc_sptr_start(self)


    def stop(self):
        """stop(corr_est_cc_sptr self) -> bool"""
        return _ais_swig.corr_est_cc_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(corr_est_cc_sptr self, unsigned int which_input) -> uint64_t"""
        return _ais_swig.corr_est_cc_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(corr_est_cc_sptr self, unsigned int which_output) -> uint64_t"""
        return _ais_swig.corr_est_cc_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(corr_est_cc_sptr self) -> int"""
        return _ais_swig.corr_est_cc_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(corr_est_cc_sptr self, int m)"""
        return _ais_swig.corr_est_cc_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(corr_est_cc_sptr self)"""
        return _ais_swig.corr_est_cc_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(corr_est_cc_sptr self) -> bool"""
        return _ais_swig.corr_est_cc_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(corr_est_cc_sptr self, int m)"""
        return _ais_swig.corr_est_cc_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(corr_est_cc_sptr self) -> int"""
        return _ais_swig.corr_est_cc_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(corr_est_cc_sptr self, int i) -> long"""
        return _ais_swig.corr_est_cc_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(corr_est_cc_sptr self, long max_output_buffer)
        set_max_output_buffer(corr_est_cc_sptr self, int port, long max_output_buffer)
        """
        return _ais_swig.corr_est_cc_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(corr_est_cc_sptr self, int i) -> long"""
        return _ais_swig.corr_est_cc_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(corr_est_cc_sptr self, long min_output_buffer)
        set_min_output_buffer(corr_est_cc_sptr self, int port, long min_output_buffer)
        """
        return _ais_swig.corr_est_cc_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(corr_est_cc_sptr self) -> float"""
        return _ais_swig.corr_est_cc_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(corr_est_cc_sptr self) -> float"""
        return _ais_swig.corr_est_cc_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(corr_est_cc_sptr self) -> float"""
        return _ais_swig.corr_est_cc_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(corr_est_cc_sptr self) -> float"""
        return _ais_swig.corr_est_cc_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(corr_est_cc_sptr self) -> float"""
        return _ais_swig.corr_est_cc_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(corr_est_cc_sptr self) -> float"""
        return _ais_swig.corr_est_cc_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(corr_est_cc_sptr self, int which) -> float
        pc_input_buffers_full(corr_est_cc_sptr self) -> pmt_vector_float
        """
        return _ais_swig.corr_est_cc_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(corr_est_cc_sptr self, int which) -> float
        pc_input_buffers_full_avg(corr_est_cc_sptr self) -> pmt_vector_float
        """
        return _ais_swig.corr_est_cc_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(corr_est_cc_sptr self, int which) -> float
        pc_input_buffers_full_var(corr_est_cc_sptr self) -> pmt_vector_float
        """
        return _ais_swig.corr_est_cc_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(corr_est_cc_sptr self, int which) -> float
        pc_output_buffers_full(corr_est_cc_sptr self) -> pmt_vector_float
        """
        return _ais_swig.corr_est_cc_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(corr_est_cc_sptr self, int which) -> float
        pc_output_buffers_full_avg(corr_est_cc_sptr self) -> pmt_vector_float
        """
        return _ais_swig.corr_est_cc_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(corr_est_cc_sptr self, int which) -> float
        pc_output_buffers_full_var(corr_est_cc_sptr self) -> pmt_vector_float
        """
        return _ais_swig.corr_est_cc_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(corr_est_cc_sptr self) -> float"""
        return _ais_swig.corr_est_cc_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(corr_est_cc_sptr self) -> float"""
        return _ais_swig.corr_est_cc_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(corr_est_cc_sptr self) -> float"""
        return _ais_swig.corr_est_cc_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(corr_est_cc_sptr self) -> float"""
        return _ais_swig.corr_est_cc_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(corr_est_cc_sptr self) -> float"""
        return _ais_swig.corr_est_cc_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(corr_est_cc_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _ais_swig.corr_est_cc_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(corr_est_cc_sptr self)"""
        return _ais_swig.corr_est_cc_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(corr_est_cc_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _ais_swig.corr_est_cc_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(corr_est_cc_sptr self) -> int"""
        return _ais_swig.corr_est_cc_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(corr_est_cc_sptr self) -> int"""
        return _ais_swig.corr_est_cc_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(corr_est_cc_sptr self, int priority) -> int"""
        return _ais_swig.corr_est_cc_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(corr_est_cc_sptr self) -> std::string"""
        return _ais_swig.corr_est_cc_sptr_name(self)


    def symbol_name(self):
        """symbol_name(corr_est_cc_sptr self) -> std::string"""
        return _ais_swig.corr_est_cc_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(corr_est_cc_sptr self) -> io_signature_sptr"""
        return _ais_swig.corr_est_cc_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(corr_est_cc_sptr self) -> io_signature_sptr"""
        return _ais_swig.corr_est_cc_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(corr_est_cc_sptr self) -> long"""
        return _ais_swig.corr_est_cc_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(corr_est_cc_sptr self) -> basic_block_sptr"""
        return _ais_swig.corr_est_cc_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(corr_est_cc_sptr self, int ninputs, int noutputs) -> bool"""
        return _ais_swig.corr_est_cc_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(corr_est_cc_sptr self) -> std::string"""
        return _ais_swig.corr_est_cc_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(corr_est_cc_sptr self, std::string name)"""
        return _ais_swig.corr_est_cc_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(corr_est_cc_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _ais_swig.corr_est_cc_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(corr_est_cc_sptr self) -> swig_int_ptr"""
        return _ais_swig.corr_est_cc_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(corr_est_cc_sptr self) -> swig_int_ptr"""
        return _ais_swig.corr_est_cc_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(corr_est_cc_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _ais_swig.corr_est_cc_sptr_message_subscribers(self, which_port)

corr_est_cc_sptr_swigregister = _ais_swig.corr_est_cc_sptr_swigregister
corr_est_cc_sptr_swigregister(corr_est_cc_sptr)


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


def modulate_vector_bc(modulator, data, taps):
    """modulate_vector_bc(basic_block_sptr modulator, std::vector< uint8_t,std::allocator< uint8_t > > data, pmt_vector_float taps) -> pmt_vector_cfloat"""
    return _ais_swig.modulate_vector_bc(modulator, data, taps)
class pdu_to_nmea(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 to_nmea(self, arg2):
        """
        to_nmea(pdu_to_nmea self, swig_int_ptr arg2)



        Params: ()
        """
        return _ais_swig.pdu_to_nmea_to_nmea(self, arg2)


    def _print(self, arg2):
        """
        _print(pdu_to_nmea self, swig_int_ptr arg2)



        Params: ()
        """
        return _ais_swig.pdu_to_nmea__print(self, arg2)


    def make(designator):
        """
        make(std::string designator) -> pdu_to_nmea_sptr

        Return a shared_ptr to a new instance of ais::pdu_to_nmea.

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

        Params: (designator)
        """
        return _ais_swig.pdu_to_nmea_make(designator)

    make = staticmethod(make)
    __swig_destroy__ = _ais_swig.delete_pdu_to_nmea
    __del__ = lambda self: None
pdu_to_nmea_swigregister = _ais_swig.pdu_to_nmea_swigregister
pdu_to_nmea_swigregister(pdu_to_nmea)

def pdu_to_nmea_make(designator):
    """
    pdu_to_nmea_make(std::string designator) -> pdu_to_nmea_sptr

    Return a shared_ptr to a new instance of ais::pdu_to_nmea.

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

    Params: (designator)
    """
    return _ais_swig.pdu_to_nmea_make(designator)

class pdu_to_nmea_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::ais::pdu_to_nmea)> 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::ais::pdu_to_nmea)> self) -> pdu_to_nmea_sptr
        __init__(boost::shared_ptr<(gr::ais::pdu_to_nmea)> self, pdu_to_nmea p) -> pdu_to_nmea_sptr
        """
        this = _ais_swig.new_pdu_to_nmea_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(pdu_to_nmea_sptr self) -> pdu_to_nmea"""
        return _ais_swig.pdu_to_nmea_sptr___deref__(self)

    __swig_destroy__ = _ais_swig.delete_pdu_to_nmea_sptr
    __del__ = lambda self: None

    def to_nmea(self, arg2):
        """
        to_nmea(pdu_to_nmea_sptr self, swig_int_ptr arg2)



        Params: ()
        """
        return _ais_swig.pdu_to_nmea_sptr_to_nmea(self, arg2)


    def _print(self, arg2):
        """
        _print(pdu_to_nmea_sptr self, swig_int_ptr arg2)



        Params: ()
        """
        return _ais_swig.pdu_to_nmea_sptr__print(self, arg2)


    def make(self, designator):
        """
        make(pdu_to_nmea_sptr self, std::string designator) -> pdu_to_nmea_sptr

        Return a shared_ptr to a new instance of ais::pdu_to_nmea.

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

        Params: (designator)
        """
        return _ais_swig.pdu_to_nmea_sptr_make(self, designator)


    def history(self):
        """history(pdu_to_nmea_sptr self) -> unsigned int"""
        return _ais_swig.pdu_to_nmea_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(pdu_to_nmea_sptr self, int which, int delay)
        declare_sample_delay(pdu_to_nmea_sptr self, unsigned int delay)
        """
        return _ais_swig.pdu_to_nmea_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(pdu_to_nmea_sptr self, int which) -> unsigned int"""
        return _ais_swig.pdu_to_nmea_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(pdu_to_nmea_sptr self) -> int"""
        return _ais_swig.pdu_to_nmea_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(pdu_to_nmea_sptr self) -> double"""
        return _ais_swig.pdu_to_nmea_sptr_relative_rate(self)


    def start(self):
        """start(pdu_to_nmea_sptr self) -> bool"""
        return _ais_swig.pdu_to_nmea_sptr_start(self)


    def stop(self):
        """stop(pdu_to_nmea_sptr self) -> bool"""
        return _ais_swig.pdu_to_nmea_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(pdu_to_nmea_sptr self, unsigned int which_input) -> uint64_t"""
        return _ais_swig.pdu_to_nmea_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(pdu_to_nmea_sptr self, unsigned int which_output) -> uint64_t"""
        return _ais_swig.pdu_to_nmea_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(pdu_to_nmea_sptr self) -> int"""
        return _ais_swig.pdu_to_nmea_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(pdu_to_nmea_sptr self, int m)"""
        return _ais_swig.pdu_to_nmea_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(pdu_to_nmea_sptr self)"""
        return _ais_swig.pdu_to_nmea_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(pdu_to_nmea_sptr self) -> bool"""
        return _ais_swig.pdu_to_nmea_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(pdu_to_nmea_sptr self, int m)"""
        return _ais_swig.pdu_to_nmea_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(pdu_to_nmea_sptr self) -> int"""
        return _ais_swig.pdu_to_nmea_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(pdu_to_nmea_sptr self, int i) -> long"""
        return _ais_swig.pdu_to_nmea_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(pdu_to_nmea_sptr self, long max_output_buffer)
        set_max_output_buffer(pdu_to_nmea_sptr self, int port, long max_output_buffer)
        """
        return _ais_swig.pdu_to_nmea_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(pdu_to_nmea_sptr self, int i) -> long"""
        return _ais_swig.pdu_to_nmea_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(pdu_to_nmea_sptr self, long min_output_buffer)
        set_min_output_buffer(pdu_to_nmea_sptr self, int port, long min_output_buffer)
        """
        return _ais_swig.pdu_to_nmea_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(pdu_to_nmea_sptr self) -> float"""
        return _ais_swig.pdu_to_nmea_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(pdu_to_nmea_sptr self) -> float"""
        return _ais_swig.pdu_to_nmea_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(pdu_to_nmea_sptr self) -> float"""
        return _ais_swig.pdu_to_nmea_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(pdu_to_nmea_sptr self) -> float"""
        return _ais_swig.pdu_to_nmea_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(pdu_to_nmea_sptr self) -> float"""
        return _ais_swig.pdu_to_nmea_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(pdu_to_nmea_sptr self) -> float"""
        return _ais_swig.pdu_to_nmea_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(pdu_to_nmea_sptr self, int which) -> float
        pc_input_buffers_full(pdu_to_nmea_sptr self) -> pmt_vector_float
        """
        return _ais_swig.pdu_to_nmea_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(pdu_to_nmea_sptr self, int which) -> float
        pc_input_buffers_full_avg(pdu_to_nmea_sptr self) -> pmt_vector_float
        """
        return _ais_swig.pdu_to_nmea_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(pdu_to_nmea_sptr self, int which) -> float
        pc_input_buffers_full_var(pdu_to_nmea_sptr self) -> pmt_vector_float
        """
        return _ais_swig.pdu_to_nmea_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(pdu_to_nmea_sptr self, int which) -> float
        pc_output_buffers_full(pdu_to_nmea_sptr self) -> pmt_vector_float
        """
        return _ais_swig.pdu_to_nmea_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(pdu_to_nmea_sptr self, int which) -> float
        pc_output_buffers_full_avg(pdu_to_nmea_sptr self) -> pmt_vector_float
        """
        return _ais_swig.pdu_to_nmea_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(pdu_to_nmea_sptr self, int which) -> float
        pc_output_buffers_full_var(pdu_to_nmea_sptr self) -> pmt_vector_float
        """
        return _ais_swig.pdu_to_nmea_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(pdu_to_nmea_sptr self) -> float"""
        return _ais_swig.pdu_to_nmea_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(pdu_to_nmea_sptr self) -> float"""
        return _ais_swig.pdu_to_nmea_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(pdu_to_nmea_sptr self) -> float"""
        return _ais_swig.pdu_to_nmea_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(pdu_to_nmea_sptr self) -> float"""
        return _ais_swig.pdu_to_nmea_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(pdu_to_nmea_sptr self) -> float"""
        return _ais_swig.pdu_to_nmea_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(pdu_to_nmea_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _ais_swig.pdu_to_nmea_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(pdu_to_nmea_sptr self)"""
        return _ais_swig.pdu_to_nmea_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(pdu_to_nmea_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _ais_swig.pdu_to_nmea_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(pdu_to_nmea_sptr self) -> int"""
        return _ais_swig.pdu_to_nmea_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(pdu_to_nmea_sptr self) -> int"""
        return _ais_swig.pdu_to_nmea_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(pdu_to_nmea_sptr self, int priority) -> int"""
        return _ais_swig.pdu_to_nmea_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(pdu_to_nmea_sptr self) -> std::string"""
        return _ais_swig.pdu_to_nmea_sptr_name(self)


    def symbol_name(self):
        """symbol_name(pdu_to_nmea_sptr self) -> std::string"""
        return _ais_swig.pdu_to_nmea_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(pdu_to_nmea_sptr self) -> io_signature_sptr"""
        return _ais_swig.pdu_to_nmea_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(pdu_to_nmea_sptr self) -> io_signature_sptr"""
        return _ais_swig.pdu_to_nmea_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(pdu_to_nmea_sptr self) -> long"""
        return _ais_swig.pdu_to_nmea_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(pdu_to_nmea_sptr self) -> basic_block_sptr"""
        return _ais_swig.pdu_to_nmea_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(pdu_to_nmea_sptr self, int ninputs, int noutputs) -> bool"""
        return _ais_swig.pdu_to_nmea_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(pdu_to_nmea_sptr self) -> std::string"""
        return _ais_swig.pdu_to_nmea_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(pdu_to_nmea_sptr self, std::string name)"""
        return _ais_swig.pdu_to_nmea_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(pdu_to_nmea_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _ais_swig.pdu_to_nmea_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(pdu_to_nmea_sptr self) -> swig_int_ptr"""
        return _ais_swig.pdu_to_nmea_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(pdu_to_nmea_sptr self) -> swig_int_ptr"""
        return _ais_swig.pdu_to_nmea_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(pdu_to_nmea_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _ais_swig.pdu_to_nmea_sptr_message_subscribers(self, which_port)

pdu_to_nmea_sptr_swigregister = _ais_swig.pdu_to_nmea_sptr_swigregister
pdu_to_nmea_sptr_swigregister(pdu_to_nmea_sptr)


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



