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

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _iio_swig
else:
    import _iio_swig

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


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


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


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



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

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

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

def high_res_timer_epoch() -> "gr::high_res_timer_type":
    r"""high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _iio_swig.high_res_timer_epoch()
DEFAULT_BUFFER_SIZE = _iio_swig.DEFAULT_BUFFER_SIZE

class device_source(object):
    r"""Proxy of C++ gr::iio::device_source class."""

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

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

    @staticmethod
    def make(uri: "std::string const &", device: "std::string const &", channels: "std::vector< std::string,std::allocator< std::string > > const &", device_phy: "std::string const &", params: "std::vector< std::string,std::allocator< std::string > > const &", buffer_size: "unsigned int"=0x8000, decimation: "unsigned int"=0) -> "gr::iio::device_source::sptr":
        r"""make(std::string const & uri, std::string const & device, std::vector< std::string,std::allocator< std::string > > const & channels, std::string const & device_phy, std::vector< std::string,std::allocator< std::string > > const & params, unsigned int buffer_size=0x8000, unsigned int decimation=0) -> device_source_sptr"""
        return _iio_swig.device_source_make(uri, device, channels, device_phy, params, buffer_size, decimation)

    @staticmethod
    def make_from(ctx: "iio_context *", device: "std::string const &", channels: "std::vector< std::string,std::allocator< std::string > > const &", device_phy: "std::string const &", params: "std::vector< std::string,std::allocator< std::string > > const &", buffer_size: "unsigned int"=0x8000, decimation: "unsigned int"=0) -> "gr::iio::device_source::sptr":
        r"""make_from(iio_context * ctx, std::string const & device, std::vector< std::string,std::allocator< std::string > > const & channels, std::string const & device_phy, std::vector< std::string,std::allocator< std::string > > const & params, unsigned int buffer_size=0x8000, unsigned int decimation=0) -> device_source_sptr"""
        return _iio_swig.device_source_make_from(ctx, device, channels, device_phy, params, buffer_size, decimation)

    def set_buffer_size(self, buffer_size: "unsigned int") -> "void":
        r"""set_buffer_size(device_source self, unsigned int buffer_size)"""
        return _iio_swig.device_source_set_buffer_size(self, buffer_size)

    def set_timeout_ms(self, timeout: "unsigned long") -> "void":
        r"""set_timeout_ms(device_source self, unsigned long timeout)"""
        return _iio_swig.device_source_set_timeout_ms(self, timeout)
    __swig_destroy__ = _iio_swig.delete_device_source

# Register device_source in _iio_swig:
_iio_swig.device_source_swigregister(device_source)
class device_sink(object):
    r"""Proxy of C++ gr::iio::device_sink class."""

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

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

    @staticmethod
    def make(uri: "std::string const &", device: "std::string const &", channels: "std::vector< std::string,std::allocator< std::string > > const &", device_phy: "std::string const &", params: "std::vector< std::string,std::allocator< std::string > > const &", buffer_size: "unsigned int"=0x8000, interpolation: "unsigned int"=0, cyclic: "bool"=False) -> "gr::iio::device_sink::sptr":
        r"""make(std::string const & uri, std::string const & device, std::vector< std::string,std::allocator< std::string > > const & channels, std::string const & device_phy, std::vector< std::string,std::allocator< std::string > > const & params, unsigned int buffer_size=0x8000, unsigned int interpolation=0, bool cyclic=False) -> device_sink_sptr"""
        return _iio_swig.device_sink_make(uri, device, channels, device_phy, params, buffer_size, interpolation, cyclic)

    @staticmethod
    def make_from(ctx: "iio_context *", device: "std::string const &", channels: "std::vector< std::string,std::allocator< std::string > > const &", device_phy: "std::string const &", params: "std::vector< std::string,std::allocator< std::string > > const &", buffer_size: "unsigned int"=0x8000, interpolation: "unsigned int"=0, cyclic: "bool"=False) -> "gr::iio::device_sink::sptr":
        r"""make_from(iio_context * ctx, std::string const & device, std::vector< std::string,std::allocator< std::string > > const & channels, std::string const & device_phy, std::vector< std::string,std::allocator< std::string > > const & params, unsigned int buffer_size=0x8000, unsigned int interpolation=0, bool cyclic=False) -> device_sink_sptr"""
        return _iio_swig.device_sink_make_from(ctx, device, channels, device_phy, params, buffer_size, interpolation, cyclic)
    __swig_destroy__ = _iio_swig.delete_device_sink

# Register device_sink in _iio_swig:
_iio_swig.device_sink_swigregister(device_sink)
class fmcomms2_source(object):
    r"""Proxy of C++ gr::iio::fmcomms2_source class."""

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

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

    @staticmethod
    def make(*args, **kwargs) -> "gr::iio::fmcomms2_source::sptr":
        r"""make(std::string const & uri, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, bool ch1_en, bool ch2_en, bool ch3_en, bool ch4_en, unsigned long buffer_size, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * rf_port_select, char const * filter="", bool auto_filter=True) -> fmcomms2_source_sptr"""
        return _iio_swig.fmcomms2_source_make(*args, **kwargs)

    @staticmethod
    def make_from(*args, **kwargs) -> "gr::iio::fmcomms2_source::sptr":
        r"""make_from(iio_context * ctx, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, bool ch1_en, bool ch2_en, bool ch3_en, bool ch4_en, unsigned long buffer_size, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * rf_port_select, char const * filter="", bool auto_filter=True) -> fmcomms2_source_sptr"""
        return _iio_swig.fmcomms2_source_make_from(*args, **kwargs)

    def set_params(self, *args, **kwargs) -> "void":
        r"""set_params(fmcomms2_source self, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * rf_port_select, char const * filter="", bool auto_filter=True)"""
        return _iio_swig.fmcomms2_source_set_params(self, *args, **kwargs)
    __swig_destroy__ = _iio_swig.delete_fmcomms2_source

# Register fmcomms2_source in _iio_swig:
_iio_swig.fmcomms2_source_swigregister(fmcomms2_source)
class fmcomms2_source_f32c(object):
    r"""Proxy of C++ gr::iio::fmcomms2_source_f32c class."""

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

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

    @staticmethod
    def make(*args, **kwargs) -> "gr::iio::fmcomms2_source_f32c::sptr":
        r"""make(std::string const & uri, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, bool rx1_en, bool rx2_en, unsigned long buffer_size, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * rf_port_select, char const * filter="", bool auto_filter=True) -> fmcomms2_source_f32c_sptr"""
        return _iio_swig.fmcomms2_source_f32c_make(*args, **kwargs)

    def set_params(self, *args, **kwargs) -> "void":
        r"""set_params(fmcomms2_source_f32c self, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * rf_port_select, char const * filter="", bool auto_filter=True)"""
        return _iio_swig.fmcomms2_source_f32c_set_params(self, *args, **kwargs)
    __swig_destroy__ = _iio_swig.delete_fmcomms2_source_f32c

# Register fmcomms2_source_f32c in _iio_swig:
_iio_swig.fmcomms2_source_f32c_swigregister(fmcomms2_source_f32c)
class fmcomms2_sink(object):
    r"""Proxy of C++ gr::iio::fmcomms2_sink class."""

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

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

    @staticmethod
    def make(*args, **kwargs) -> "gr::iio::fmcomms2_sink::sptr":
        r"""make(std::string const & uri, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, bool ch1_en, bool ch2_en, bool ch3_en, bool ch4_en, unsigned long buffer_size, bool cyclic, char const * rf_port_select, double attenuation1, double attenuation2, char const * filter="", bool auto_filter=True) -> fmcomms2_sink_sptr"""
        return _iio_swig.fmcomms2_sink_make(*args, **kwargs)

    @staticmethod
    def make_from(*args, **kwargs) -> "gr::iio::fmcomms2_sink::sptr":
        r"""make_from(iio_context * ctx, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, bool ch1_en, bool ch2_en, bool ch3_en, bool ch4_en, unsigned long buffer_size, bool cyclic, char const * rf_port_select, double attenuation1, double attenuation2, char const * filter="", bool auto_filter=True) -> fmcomms2_sink_sptr"""
        return _iio_swig.fmcomms2_sink_make_from(*args, **kwargs)

    def set_params(self, *args, **kwargs) -> "void":
        r"""set_params(fmcomms2_sink self, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, char const * rf_port_select, double attenuation1, double attenuation2, char const * filter="", bool auto_filter=True)"""
        return _iio_swig.fmcomms2_sink_set_params(self, *args, **kwargs)
    __swig_destroy__ = _iio_swig.delete_fmcomms2_sink

# Register fmcomms2_sink in _iio_swig:
_iio_swig.fmcomms2_sink_swigregister(fmcomms2_sink)
class fmcomms2_sink_f32c(object):
    r"""Proxy of C++ gr::iio::fmcomms2_sink_f32c class."""

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

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

    @staticmethod
    def make(*args, **kwargs) -> "gr::iio::fmcomms2_sink_f32c::sptr":
        r"""make(std::string const & uri, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, bool rx1_en, bool rx2_en, unsigned long buffer_size, bool cyclic, char const * rf_port_select, double attenuation1, double attenuation2, char const * filter="", bool auto_filter=True) -> fmcomms2_sink_f32c_sptr"""
        return _iio_swig.fmcomms2_sink_f32c_make(*args, **kwargs)

    def set_params(self, *args, **kwargs) -> "void":
        r"""set_params(fmcomms2_sink_f32c self, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, char const * rf_port_select, double attenuation1, double attenuation2, char const * filter="", bool auto_filter=True)"""
        return _iio_swig.fmcomms2_sink_f32c_set_params(self, *args, **kwargs)
    __swig_destroy__ = _iio_swig.delete_fmcomms2_sink_f32c

# Register fmcomms2_sink_f32c in _iio_swig:
_iio_swig.fmcomms2_sink_f32c_swigregister(fmcomms2_sink_f32c)
class fmcomms5_source(object):
    r"""Proxy of C++ gr::iio::fmcomms5_source class."""

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

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

    @staticmethod
    def make(*args, **kwargs) -> "gr::iio::fmcomms5_source::sptr":
        r"""make(std::string const & uri, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, bool ch1_en, bool ch2_en, bool ch3_en, bool ch4_en, bool ch5_en, bool ch6_en, bool ch7_en, bool ch8_en, unsigned long buffer_size, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * gain3, double gain3_value, char const * gain4, double gain4_value, char const * rf_port_select, char const * filter="") -> fmcomms5_source_sptr"""
        return _iio_swig.fmcomms5_source_make(*args, **kwargs)

    @staticmethod
    def make_from(*args, **kwargs) -> "gr::iio::fmcomms5_source::sptr":
        r"""make_from(iio_context * ctx, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, bool ch1_en, bool ch2_en, bool ch3_en, bool ch4_en, bool ch5_en, bool ch6_en, bool ch7_en, bool ch8_en, unsigned long buffer_size, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * gain3, double gain3_value, char const * gain4, double gain4_value, char const * rf_port_select, char const * filter="") -> fmcomms5_source_sptr"""
        return _iio_swig.fmcomms5_source_make_from(*args, **kwargs)

    def set_params(self, frequency1: "unsigned long long", frequency2: "unsigned long long", samplerate: "unsigned long", bandwidth: "unsigned long", quadrature: "bool", rfdc: "bool", bbdc: "bool", gain1: "char const *", gain1_value: "double", gain2: "char const *", gain2_value: "double", gain3: "char const *", gain3_value: "double", gain4: "char const *", gain4_value: "double", rf_port_select: "char const *") -> "void":
        r"""set_params(fmcomms5_source self, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * gain3, double gain3_value, char const * gain4, double gain4_value, char const * rf_port_select)"""
        return _iio_swig.fmcomms5_source_set_params(self, frequency1, frequency2, samplerate, bandwidth, quadrature, rfdc, bbdc, gain1, gain1_value, gain2, gain2_value, gain3, gain3_value, gain4, gain4_value, rf_port_select)
    __swig_destroy__ = _iio_swig.delete_fmcomms5_source

# Register fmcomms5_source in _iio_swig:
_iio_swig.fmcomms5_source_swigregister(fmcomms5_source)
class fmcomms5_source_f32c(object):
    r"""Proxy of C++ gr::iio::fmcomms5_source_f32c class."""

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

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

    @staticmethod
    def make(*args, **kwargs) -> "gr::iio::fmcomms5_source_f32c::sptr":
        r"""make(std::string const & uri, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, bool rx1_en, bool rx2_en, bool rx3_en, bool rx4_en, unsigned long buffer_size, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * gain3, double gain3_value, char const * gain4, double gain4_value, char const * rf_port_select, char const * filter="") -> fmcomms5_source_f32c_sptr"""
        return _iio_swig.fmcomms5_source_f32c_make(*args, **kwargs)

    def set_params(self, frequency1: "unsigned long long", frequency2: "unsigned long long", samplerate: "unsigned long", bandwidth: "unsigned long", quadrature: "bool", rfdc: "bool", bbdc: "bool", gain1: "char const *", gain1_value: "double", gain2: "char const *", gain2_value: "double", gain3: "char const *", gain3_value: "double", gain4: "char const *", gain4_value: "double", rf_port_select: "char const *") -> "void":
        r"""set_params(fmcomms5_source_f32c self, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * gain3, double gain3_value, char const * gain4, double gain4_value, char const * rf_port_select)"""
        return _iio_swig.fmcomms5_source_f32c_set_params(self, frequency1, frequency2, samplerate, bandwidth, quadrature, rfdc, bbdc, gain1, gain1_value, gain2, gain2_value, gain3, gain3_value, gain4, gain4_value, rf_port_select)
    __swig_destroy__ = _iio_swig.delete_fmcomms5_source_f32c

# Register fmcomms5_source_f32c in _iio_swig:
_iio_swig.fmcomms5_source_f32c_swigregister(fmcomms5_source_f32c)
class fmcomms5_sink(object):
    r"""Proxy of C++ gr::iio::fmcomms5_sink class."""

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

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

    @staticmethod
    def make(*args, **kwargs) -> "gr::iio::fmcomms5_sink::sptr":
        r"""make(std::string const & uri, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, bool ch1_en, bool ch2_en, bool ch3_en, bool ch4_en, bool ch5_en, bool ch6_en, bool ch7_en, bool ch8_en, unsigned long buffer_size, bool cyclic, char const * rf_port_select, double attenuation1, double attenuation2, double attenuation3, double attenuation4, char const * filter="") -> fmcomms5_sink_sptr"""
        return _iio_swig.fmcomms5_sink_make(*args, **kwargs)

    @staticmethod
    def make_from(*args, **kwargs) -> "gr::iio::fmcomms5_sink::sptr":
        r"""make_from(iio_context * ctx, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, bool ch1_en, bool ch2_en, bool ch3_en, bool ch4_en, bool ch5_en, bool ch6_en, bool ch7_en, bool ch8_en, unsigned long buffer_size, bool cyclic, char const * rf_port_select, double attenuation1, double attenuation2, double attenuation3, double attenuation4, char const * filter="") -> fmcomms5_sink_sptr"""
        return _iio_swig.fmcomms5_sink_make_from(*args, **kwargs)

    def set_params(self, frequency1: "unsigned long long", frequency2: "unsigned long long", samplerate: "unsigned long", bandwidth: "unsigned long", rf_port_select: "char const *", attenuation1: "double", attenuation2: "double", attenuation3: "double", attenuation4: "double") -> "void":
        r"""set_params(fmcomms5_sink self, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, char const * rf_port_select, double attenuation1, double attenuation2, double attenuation3, double attenuation4)"""
        return _iio_swig.fmcomms5_sink_set_params(self, frequency1, frequency2, samplerate, bandwidth, rf_port_select, attenuation1, attenuation2, attenuation3, attenuation4)
    __swig_destroy__ = _iio_swig.delete_fmcomms5_sink

# Register fmcomms5_sink in _iio_swig:
_iio_swig.fmcomms5_sink_swigregister(fmcomms5_sink)
class fmcomms5_sink_f32c(object):
    r"""Proxy of C++ gr::iio::fmcomms5_sink_f32c class."""

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

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

    @staticmethod
    def make(*args, **kwargs) -> "gr::iio::fmcomms5_sink_f32c::sptr":
        r"""make(std::string const & uri, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, bool rx1_en, bool rx2_en, bool rx3_en, bool rx4_en, unsigned long buffer_size, bool cyclic, char const * rf_port_select, double attenuation1, double attenuation2, double attenuation3, double attenuation4, char const * filter="") -> fmcomms5_sink_f32c_sptr"""
        return _iio_swig.fmcomms5_sink_f32c_make(*args, **kwargs)

    def set_params(self, frequency1: "unsigned long long", frequency2: "unsigned long long", samplerate: "unsigned long", bandwidth: "unsigned long", rf_port_select: "char const *", attenuation1: "double", attenuation2: "double", attenuation3: "double", attenuation4: "double") -> "void":
        r"""set_params(fmcomms5_sink_f32c self, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, char const * rf_port_select, double attenuation1, double attenuation2, double attenuation3, double attenuation4)"""
        return _iio_swig.fmcomms5_sink_f32c_set_params(self, frequency1, frequency2, samplerate, bandwidth, rf_port_select, attenuation1, attenuation2, attenuation3, attenuation4)
    __swig_destroy__ = _iio_swig.delete_fmcomms5_sink_f32c

# Register fmcomms5_sink_f32c in _iio_swig:
_iio_swig.fmcomms5_sink_f32c_swigregister(fmcomms5_sink_f32c)
class iio_math(object):
    r"""Proxy of C++ gr::iio::iio_math class."""

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

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

    @staticmethod
    def make(function: "std::string const &", ninputs: "int"=1) -> "gr::iio::iio_math::sptr":
        r"""make(std::string const & function, int ninputs=1) -> iio_math_sptr"""
        return _iio_swig.iio_math_make(function, ninputs)
    __swig_destroy__ = _iio_swig.delete_iio_math

# Register iio_math in _iio_swig:
_iio_swig.iio_math_swigregister(iio_math)
class iio_math_gen(object):
    r"""Proxy of C++ gr::iio::iio_math_gen class."""

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

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

    @staticmethod
    def make(sampling_freq: "double", wav_freq: "double", function: "std::string const &") -> "gr::iio::iio_math_gen::sptr":
        r"""make(double sampling_freq, double wav_freq, std::string const & function) -> iio_math_gen_sptr"""
        return _iio_swig.iio_math_gen_make(sampling_freq, wav_freq, function)
    __swig_destroy__ = _iio_swig.delete_iio_math_gen

# Register iio_math_gen in _iio_swig:
_iio_swig.iio_math_gen_swigregister(iio_math_gen)
class power_ff(object):
    r"""Proxy of C++ gr::iio::power_ff class."""

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

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

    @staticmethod
    def make(vlen: "size_t"=1) -> "gr::iio::power_ff::sptr":
        r"""make(size_t vlen=1) -> power_ff_sptr"""
        return _iio_swig.power_ff_make(vlen)
    __swig_destroy__ = _iio_swig.delete_power_ff

# Register power_ff in _iio_swig:
_iio_swig.power_ff_swigregister(power_ff)
class modulo_ff(object):
    r"""Proxy of C++ gr::iio::modulo_ff class."""

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

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

    @staticmethod
    def make(vlen: "size_t"=1) -> "gr::iio::modulo_ff::sptr":
        r"""make(size_t vlen=1) -> modulo_ff_sptr"""
        return _iio_swig.modulo_ff_make(vlen)
    __swig_destroy__ = _iio_swig.delete_modulo_ff

# Register modulo_ff in _iio_swig:
_iio_swig.modulo_ff_swigregister(modulo_ff)
class modulo_const_ff(object):
    r"""Proxy of C++ gr::iio::modulo_const_ff class."""

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

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

    @staticmethod
    def make(modulo: "float", vlen: "size_t"=1) -> "gr::iio::modulo_const_ff::sptr":
        r"""make(float modulo, size_t vlen=1) -> modulo_const_ff_sptr"""
        return _iio_swig.modulo_const_ff_make(modulo, vlen)
    __swig_destroy__ = _iio_swig.delete_modulo_const_ff

# Register modulo_const_ff in _iio_swig:
_iio_swig.modulo_const_ff_swigregister(modulo_const_ff)
class attr_sink(object):
    r"""Proxy of C++ gr::iio::attr_sink class."""

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

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

    @staticmethod
    def make(uri: "std::string const &", device: "std::string const &", channel: "std::string const &", type: "int", output: "bool", required_enable: "bool") -> "gr::iio::attr_sink::sptr":
        r"""make(std::string const & uri, std::string const & device, std::string const & channel, int type, bool output, bool required_enable) -> attr_sink_sptr"""
        return _iio_swig.attr_sink_make(uri, device, channel, type, output, required_enable)
    __swig_destroy__ = _iio_swig.delete_attr_sink

# Register attr_sink in _iio_swig:
_iio_swig.attr_sink_swigregister(attr_sink)
class attr_source(object):
    r"""Proxy of C++ gr::iio::attr_source class."""

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

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

    @staticmethod
    def make(uri: "std::string const &", device: "std::string const &", channel: "std::string const &", attribute: "std::string const &", update_interval_ms: "int", samples_per_update: "int", data_type: "int", attr_type: "int", output: "bool", address: "uint32_t", required_enable: "bool") -> "gr::iio::attr_source::sptr":
        r"""make(std::string const & uri, std::string const & device, std::string const & channel, std::string const & attribute, int update_interval_ms, int samples_per_update, int data_type, int attr_type, bool output, uint32_t address, bool required_enable) -> attr_source_sptr"""
        return _iio_swig.attr_source_make(uri, device, channel, attribute, update_interval_ms, samples_per_update, data_type, attr_type, output, address, required_enable)
    __swig_destroy__ = _iio_swig.delete_attr_source

# Register attr_source in _iio_swig:
_iio_swig.attr_source_swigregister(attr_source)
class device_source_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::iio::device_source > class."""

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

    def __init__(self, *args):
        r"""
        __init__(device_source_sptr self) -> device_source_sptr
        __init__(device_source_sptr self, device_source p) -> device_source_sptr
        """
        _iio_swig.device_source_sptr_swiginit(self, _iio_swig.new_device_source_sptr(*args))

    def __deref__(self) -> "gr::iio::device_source *":
        r"""__deref__(device_source_sptr self) -> device_source"""
        return _iio_swig.device_source_sptr___deref__(self)
    __swig_destroy__ = _iio_swig.delete_device_source_sptr

    def make(self, uri: "std::string const &", device: "std::string const &", channels: "std::vector< std::string,std::allocator< std::string > > const &", device_phy: "std::string const &", params: "std::vector< std::string,std::allocator< std::string > > const &", buffer_size: "unsigned int"=0x8000, decimation: "unsigned int"=0) -> "gr::iio::device_source::sptr":
        r"""make(device_source_sptr self, std::string const & uri, std::string const & device, std::vector< std::string,std::allocator< std::string > > const & channels, std::string const & device_phy, std::vector< std::string,std::allocator< std::string > > const & params, unsigned int buffer_size=0x8000, unsigned int decimation=0) -> device_source_sptr"""
        return _iio_swig.device_source_sptr_make(self, uri, device, channels, device_phy, params, buffer_size, decimation)

    def make_from(self, ctx: "iio_context *", device: "std::string const &", channels: "std::vector< std::string,std::allocator< std::string > > const &", device_phy: "std::string const &", params: "std::vector< std::string,std::allocator< std::string > > const &", buffer_size: "unsigned int"=0x8000, decimation: "unsigned int"=0) -> "gr::iio::device_source::sptr":
        r"""make_from(device_source_sptr self, iio_context * ctx, std::string const & device, std::vector< std::string,std::allocator< std::string > > const & channels, std::string const & device_phy, std::vector< std::string,std::allocator< std::string > > const & params, unsigned int buffer_size=0x8000, unsigned int decimation=0) -> device_source_sptr"""
        return _iio_swig.device_source_sptr_make_from(self, ctx, device, channels, device_phy, params, buffer_size, decimation)

    def set_buffer_size(self, buffer_size: "unsigned int") -> "void":
        r"""set_buffer_size(device_source_sptr self, unsigned int buffer_size)"""
        return _iio_swig.device_source_sptr_set_buffer_size(self, buffer_size)

    def set_timeout_ms(self, timeout: "unsigned long") -> "void":
        r"""set_timeout_ms(device_source_sptr self, unsigned long timeout)"""
        return _iio_swig.device_source_sptr_set_timeout_ms(self, timeout)

    def history(self) -> "unsigned int":
        r"""history(device_source_sptr self) -> unsigned int"""
        return _iio_swig.device_source_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(device_source_sptr self, int which, int delay)
        declare_sample_delay(device_source_sptr self, unsigned int delay)
        """
        return _iio_swig.device_source_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(device_source_sptr self, int which) -> unsigned int"""
        return _iio_swig.device_source_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(device_source_sptr self, int multiple)"""
        return _iio_swig.device_source_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(device_source_sptr self) -> int"""
        return _iio_swig.device_source_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(device_source_sptr self) -> double"""
        return _iio_swig.device_source_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(device_source_sptr self) -> uint64_t"""
        return _iio_swig.device_source_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(device_source_sptr self) -> uint64_t"""
        return _iio_swig.device_source_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(device_source_sptr self) -> bool"""
        return _iio_swig.device_source_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(device_source_sptr self) -> bool"""
        return _iio_swig.device_source_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(device_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _iio_swig.device_source_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(device_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _iio_swig.device_source_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(device_source_sptr self, std::string level)"""
        return _iio_swig.device_source_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(device_source_sptr self) -> std::string"""
        return _iio_swig.device_source_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(device_source_sptr self) -> int"""
        return _iio_swig.device_source_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(device_source_sptr self, int m)"""
        return _iio_swig.device_source_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(device_source_sptr self)"""
        return _iio_swig.device_source_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(device_source_sptr self) -> bool"""
        return _iio_swig.device_source_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(device_source_sptr self, int m)"""
        return _iio_swig.device_source_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(device_source_sptr self) -> int"""
        return _iio_swig.device_source_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(device_source_sptr self, int i) -> long"""
        return _iio_swig.device_source_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(device_source_sptr self, long max_output_buffer)
        set_max_output_buffer(device_source_sptr self, int port, long max_output_buffer)
        """
        return _iio_swig.device_source_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(device_source_sptr self, int i) -> long"""
        return _iio_swig.device_source_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(device_source_sptr self, long min_output_buffer)
        set_min_output_buffer(device_source_sptr self, int port, long min_output_buffer)
        """
        return _iio_swig.device_source_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(device_source_sptr self) -> float"""
        return _iio_swig.device_source_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(device_source_sptr self) -> float"""
        return _iio_swig.device_source_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(device_source_sptr self) -> float"""
        return _iio_swig.device_source_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(device_source_sptr self) -> float"""
        return _iio_swig.device_source_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(device_source_sptr self) -> float"""
        return _iio_swig.device_source_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(device_source_sptr self) -> float"""
        return _iio_swig.device_source_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(device_source_sptr self, int which) -> float
        pc_input_buffers_full(device_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.device_source_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(device_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(device_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.device_source_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(device_source_sptr self, int which) -> float
        pc_input_buffers_full_var(device_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.device_source_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(device_source_sptr self, int which) -> float
        pc_output_buffers_full(device_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.device_source_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(device_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(device_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.device_source_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(device_source_sptr self, int which) -> float
        pc_output_buffers_full_var(device_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.device_source_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(device_source_sptr self) -> float"""
        return _iio_swig.device_source_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(device_source_sptr self) -> float"""
        return _iio_swig.device_source_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(device_source_sptr self) -> float"""
        return _iio_swig.device_source_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(device_source_sptr self) -> float"""
        return _iio_swig.device_source_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(device_source_sptr self) -> float"""
        return _iio_swig.device_source_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(device_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _iio_swig.device_source_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(device_source_sptr self)"""
        return _iio_swig.device_source_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(device_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _iio_swig.device_source_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(device_source_sptr self) -> int"""
        return _iio_swig.device_source_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(device_source_sptr self) -> int"""
        return _iio_swig.device_source_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(device_source_sptr self, int priority) -> int"""
        return _iio_swig.device_source_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(device_source_sptr self) -> std::string"""
        return _iio_swig.device_source_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(device_source_sptr self) -> std::string"""
        return _iio_swig.device_source_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(device_source_sptr self) -> io_signature_sptr"""
        return _iio_swig.device_source_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(device_source_sptr self) -> io_signature_sptr"""
        return _iio_swig.device_source_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(device_source_sptr self) -> long"""
        return _iio_swig.device_source_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(device_source_sptr self) -> basic_block_sptr"""
        return _iio_swig.device_source_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(device_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _iio_swig.device_source_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(device_source_sptr self) -> std::string"""
        return _iio_swig.device_source_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(device_source_sptr self, std::string name)"""
        return _iio_swig.device_source_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(device_source_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _iio_swig.device_source_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(device_source_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.device_source_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(device_source_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.device_source_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(device_source_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _iio_swig.device_source_sptr_message_subscribers(self, which_port)

# Register device_source_sptr in _iio_swig:
_iio_swig.device_source_sptr_swigregister(device_source_sptr)

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

class device_sink_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::iio::device_sink > class."""

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

    def __init__(self, *args):
        r"""
        __init__(device_sink_sptr self) -> device_sink_sptr
        __init__(device_sink_sptr self, device_sink p) -> device_sink_sptr
        """
        _iio_swig.device_sink_sptr_swiginit(self, _iio_swig.new_device_sink_sptr(*args))

    def __deref__(self) -> "gr::iio::device_sink *":
        r"""__deref__(device_sink_sptr self) -> device_sink"""
        return _iio_swig.device_sink_sptr___deref__(self)
    __swig_destroy__ = _iio_swig.delete_device_sink_sptr

    def make(self, uri: "std::string const &", device: "std::string const &", channels: "std::vector< std::string,std::allocator< std::string > > const &", device_phy: "std::string const &", params: "std::vector< std::string,std::allocator< std::string > > const &", buffer_size: "unsigned int"=0x8000, interpolation: "unsigned int"=0, cyclic: "bool"=False) -> "gr::iio::device_sink::sptr":
        r"""make(device_sink_sptr self, std::string const & uri, std::string const & device, std::vector< std::string,std::allocator< std::string > > const & channels, std::string const & device_phy, std::vector< std::string,std::allocator< std::string > > const & params, unsigned int buffer_size=0x8000, unsigned int interpolation=0, bool cyclic=False) -> device_sink_sptr"""
        return _iio_swig.device_sink_sptr_make(self, uri, device, channels, device_phy, params, buffer_size, interpolation, cyclic)

    def make_from(self, ctx: "iio_context *", device: "std::string const &", channels: "std::vector< std::string,std::allocator< std::string > > const &", device_phy: "std::string const &", params: "std::vector< std::string,std::allocator< std::string > > const &", buffer_size: "unsigned int"=0x8000, interpolation: "unsigned int"=0, cyclic: "bool"=False) -> "gr::iio::device_sink::sptr":
        r"""make_from(device_sink_sptr self, iio_context * ctx, std::string const & device, std::vector< std::string,std::allocator< std::string > > const & channels, std::string const & device_phy, std::vector< std::string,std::allocator< std::string > > const & params, unsigned int buffer_size=0x8000, unsigned int interpolation=0, bool cyclic=False) -> device_sink_sptr"""
        return _iio_swig.device_sink_sptr_make_from(self, ctx, device, channels, device_phy, params, buffer_size, interpolation, cyclic)

    def history(self) -> "unsigned int":
        r"""history(device_sink_sptr self) -> unsigned int"""
        return _iio_swig.device_sink_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(device_sink_sptr self, int which, int delay)
        declare_sample_delay(device_sink_sptr self, unsigned int delay)
        """
        return _iio_swig.device_sink_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(device_sink_sptr self, int which) -> unsigned int"""
        return _iio_swig.device_sink_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(device_sink_sptr self, int multiple)"""
        return _iio_swig.device_sink_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(device_sink_sptr self) -> int"""
        return _iio_swig.device_sink_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(device_sink_sptr self) -> double"""
        return _iio_swig.device_sink_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(device_sink_sptr self) -> uint64_t"""
        return _iio_swig.device_sink_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(device_sink_sptr self) -> uint64_t"""
        return _iio_swig.device_sink_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(device_sink_sptr self) -> bool"""
        return _iio_swig.device_sink_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(device_sink_sptr self) -> bool"""
        return _iio_swig.device_sink_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(device_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _iio_swig.device_sink_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(device_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _iio_swig.device_sink_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(device_sink_sptr self, std::string level)"""
        return _iio_swig.device_sink_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(device_sink_sptr self) -> std::string"""
        return _iio_swig.device_sink_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(device_sink_sptr self) -> int"""
        return _iio_swig.device_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(device_sink_sptr self, int m)"""
        return _iio_swig.device_sink_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(device_sink_sptr self)"""
        return _iio_swig.device_sink_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(device_sink_sptr self) -> bool"""
        return _iio_swig.device_sink_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(device_sink_sptr self, int m)"""
        return _iio_swig.device_sink_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(device_sink_sptr self) -> int"""
        return _iio_swig.device_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(device_sink_sptr self, int i) -> long"""
        return _iio_swig.device_sink_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(device_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(device_sink_sptr self, int port, long max_output_buffer)
        """
        return _iio_swig.device_sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(device_sink_sptr self, int i) -> long"""
        return _iio_swig.device_sink_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(device_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(device_sink_sptr self, int port, long min_output_buffer)
        """
        return _iio_swig.device_sink_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(device_sink_sptr self) -> float"""
        return _iio_swig.device_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(device_sink_sptr self) -> float"""
        return _iio_swig.device_sink_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(device_sink_sptr self) -> float"""
        return _iio_swig.device_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(device_sink_sptr self) -> float"""
        return _iio_swig.device_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(device_sink_sptr self) -> float"""
        return _iio_swig.device_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(device_sink_sptr self) -> float"""
        return _iio_swig.device_sink_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(device_sink_sptr self, int which) -> float
        pc_input_buffers_full(device_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.device_sink_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(device_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(device_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.device_sink_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(device_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(device_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.device_sink_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(device_sink_sptr self, int which) -> float
        pc_output_buffers_full(device_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.device_sink_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(device_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(device_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.device_sink_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(device_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(device_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.device_sink_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(device_sink_sptr self) -> float"""
        return _iio_swig.device_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(device_sink_sptr self) -> float"""
        return _iio_swig.device_sink_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(device_sink_sptr self) -> float"""
        return _iio_swig.device_sink_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(device_sink_sptr self) -> float"""
        return _iio_swig.device_sink_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(device_sink_sptr self) -> float"""
        return _iio_swig.device_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(device_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _iio_swig.device_sink_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(device_sink_sptr self)"""
        return _iio_swig.device_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(device_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _iio_swig.device_sink_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(device_sink_sptr self) -> int"""
        return _iio_swig.device_sink_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(device_sink_sptr self) -> int"""
        return _iio_swig.device_sink_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(device_sink_sptr self, int priority) -> int"""
        return _iio_swig.device_sink_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(device_sink_sptr self) -> std::string"""
        return _iio_swig.device_sink_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(device_sink_sptr self) -> std::string"""
        return _iio_swig.device_sink_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(device_sink_sptr self) -> io_signature_sptr"""
        return _iio_swig.device_sink_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(device_sink_sptr self) -> io_signature_sptr"""
        return _iio_swig.device_sink_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(device_sink_sptr self) -> long"""
        return _iio_swig.device_sink_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(device_sink_sptr self) -> basic_block_sptr"""
        return _iio_swig.device_sink_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(device_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _iio_swig.device_sink_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(device_sink_sptr self) -> std::string"""
        return _iio_swig.device_sink_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(device_sink_sptr self, std::string name)"""
        return _iio_swig.device_sink_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(device_sink_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _iio_swig.device_sink_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(device_sink_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.device_sink_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(device_sink_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.device_sink_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(device_sink_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _iio_swig.device_sink_sptr_message_subscribers(self, which_port)

# Register device_sink_sptr in _iio_swig:
_iio_swig.device_sink_sptr_swigregister(device_sink_sptr)

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

class fmcomms2_source_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::iio::fmcomms2_source > class."""

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

    def __init__(self, *args):
        r"""
        __init__(fmcomms2_source_sptr self) -> fmcomms2_source_sptr
        __init__(fmcomms2_source_sptr self, fmcomms2_source p) -> fmcomms2_source_sptr
        """
        _iio_swig.fmcomms2_source_sptr_swiginit(self, _iio_swig.new_fmcomms2_source_sptr(*args))

    def __deref__(self) -> "gr::iio::fmcomms2_source *":
        r"""__deref__(fmcomms2_source_sptr self) -> fmcomms2_source"""
        return _iio_swig.fmcomms2_source_sptr___deref__(self)
    __swig_destroy__ = _iio_swig.delete_fmcomms2_source_sptr

    def make(self, *args, **kwargs) -> "gr::iio::fmcomms2_source::sptr":
        r"""make(fmcomms2_source_sptr self, std::string const & uri, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, bool ch1_en, bool ch2_en, bool ch3_en, bool ch4_en, unsigned long buffer_size, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * rf_port_select, char const * filter="", bool auto_filter=True) -> fmcomms2_source_sptr"""
        return _iio_swig.fmcomms2_source_sptr_make(self, *args, **kwargs)

    def make_from(self, *args, **kwargs) -> "gr::iio::fmcomms2_source::sptr":
        r"""make_from(fmcomms2_source_sptr self, iio_context * ctx, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, bool ch1_en, bool ch2_en, bool ch3_en, bool ch4_en, unsigned long buffer_size, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * rf_port_select, char const * filter="", bool auto_filter=True) -> fmcomms2_source_sptr"""
        return _iio_swig.fmcomms2_source_sptr_make_from(self, *args, **kwargs)

    def set_params(self, *args, **kwargs) -> "void":
        r"""set_params(fmcomms2_source_sptr self, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * rf_port_select, char const * filter="", bool auto_filter=True)"""
        return _iio_swig.fmcomms2_source_sptr_set_params(self, *args, **kwargs)

    def history(self) -> "unsigned int":
        r"""history(fmcomms2_source_sptr self) -> unsigned int"""
        return _iio_swig.fmcomms2_source_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(fmcomms2_source_sptr self, int which, int delay)
        declare_sample_delay(fmcomms2_source_sptr self, unsigned int delay)
        """
        return _iio_swig.fmcomms2_source_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(fmcomms2_source_sptr self, int which) -> unsigned int"""
        return _iio_swig.fmcomms2_source_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(fmcomms2_source_sptr self, int multiple)"""
        return _iio_swig.fmcomms2_source_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(fmcomms2_source_sptr self) -> int"""
        return _iio_swig.fmcomms2_source_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(fmcomms2_source_sptr self) -> double"""
        return _iio_swig.fmcomms2_source_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(fmcomms2_source_sptr self) -> uint64_t"""
        return _iio_swig.fmcomms2_source_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(fmcomms2_source_sptr self) -> uint64_t"""
        return _iio_swig.fmcomms2_source_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(fmcomms2_source_sptr self) -> bool"""
        return _iio_swig.fmcomms2_source_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(fmcomms2_source_sptr self) -> bool"""
        return _iio_swig.fmcomms2_source_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(fmcomms2_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _iio_swig.fmcomms2_source_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(fmcomms2_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _iio_swig.fmcomms2_source_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(fmcomms2_source_sptr self, std::string level)"""
        return _iio_swig.fmcomms2_source_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(fmcomms2_source_sptr self) -> std::string"""
        return _iio_swig.fmcomms2_source_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(fmcomms2_source_sptr self) -> int"""
        return _iio_swig.fmcomms2_source_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(fmcomms2_source_sptr self, int m)"""
        return _iio_swig.fmcomms2_source_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(fmcomms2_source_sptr self)"""
        return _iio_swig.fmcomms2_source_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(fmcomms2_source_sptr self) -> bool"""
        return _iio_swig.fmcomms2_source_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(fmcomms2_source_sptr self, int m)"""
        return _iio_swig.fmcomms2_source_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(fmcomms2_source_sptr self) -> int"""
        return _iio_swig.fmcomms2_source_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(fmcomms2_source_sptr self, int i) -> long"""
        return _iio_swig.fmcomms2_source_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(fmcomms2_source_sptr self, long max_output_buffer)
        set_max_output_buffer(fmcomms2_source_sptr self, int port, long max_output_buffer)
        """
        return _iio_swig.fmcomms2_source_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(fmcomms2_source_sptr self, int i) -> long"""
        return _iio_swig.fmcomms2_source_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(fmcomms2_source_sptr self, long min_output_buffer)
        set_min_output_buffer(fmcomms2_source_sptr self, int port, long min_output_buffer)
        """
        return _iio_swig.fmcomms2_source_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(fmcomms2_source_sptr self) -> float"""
        return _iio_swig.fmcomms2_source_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(fmcomms2_source_sptr self) -> float"""
        return _iio_swig.fmcomms2_source_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(fmcomms2_source_sptr self) -> float"""
        return _iio_swig.fmcomms2_source_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(fmcomms2_source_sptr self) -> float"""
        return _iio_swig.fmcomms2_source_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(fmcomms2_source_sptr self) -> float"""
        return _iio_swig.fmcomms2_source_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(fmcomms2_source_sptr self) -> float"""
        return _iio_swig.fmcomms2_source_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(fmcomms2_source_sptr self, int which) -> float
        pc_input_buffers_full(fmcomms2_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms2_source_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(fmcomms2_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(fmcomms2_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms2_source_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(fmcomms2_source_sptr self, int which) -> float
        pc_input_buffers_full_var(fmcomms2_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms2_source_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(fmcomms2_source_sptr self, int which) -> float
        pc_output_buffers_full(fmcomms2_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms2_source_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(fmcomms2_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(fmcomms2_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms2_source_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(fmcomms2_source_sptr self, int which) -> float
        pc_output_buffers_full_var(fmcomms2_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms2_source_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(fmcomms2_source_sptr self) -> float"""
        return _iio_swig.fmcomms2_source_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(fmcomms2_source_sptr self) -> float"""
        return _iio_swig.fmcomms2_source_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(fmcomms2_source_sptr self) -> float"""
        return _iio_swig.fmcomms2_source_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(fmcomms2_source_sptr self) -> float"""
        return _iio_swig.fmcomms2_source_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(fmcomms2_source_sptr self) -> float"""
        return _iio_swig.fmcomms2_source_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(fmcomms2_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _iio_swig.fmcomms2_source_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(fmcomms2_source_sptr self)"""
        return _iio_swig.fmcomms2_source_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(fmcomms2_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _iio_swig.fmcomms2_source_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(fmcomms2_source_sptr self) -> int"""
        return _iio_swig.fmcomms2_source_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(fmcomms2_source_sptr self) -> int"""
        return _iio_swig.fmcomms2_source_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(fmcomms2_source_sptr self, int priority) -> int"""
        return _iio_swig.fmcomms2_source_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(fmcomms2_source_sptr self) -> std::string"""
        return _iio_swig.fmcomms2_source_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(fmcomms2_source_sptr self) -> std::string"""
        return _iio_swig.fmcomms2_source_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(fmcomms2_source_sptr self) -> io_signature_sptr"""
        return _iio_swig.fmcomms2_source_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(fmcomms2_source_sptr self) -> io_signature_sptr"""
        return _iio_swig.fmcomms2_source_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(fmcomms2_source_sptr self) -> long"""
        return _iio_swig.fmcomms2_source_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(fmcomms2_source_sptr self) -> basic_block_sptr"""
        return _iio_swig.fmcomms2_source_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(fmcomms2_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _iio_swig.fmcomms2_source_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(fmcomms2_source_sptr self) -> std::string"""
        return _iio_swig.fmcomms2_source_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(fmcomms2_source_sptr self, std::string name)"""
        return _iio_swig.fmcomms2_source_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(fmcomms2_source_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _iio_swig.fmcomms2_source_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(fmcomms2_source_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms2_source_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(fmcomms2_source_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms2_source_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(fmcomms2_source_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms2_source_sptr_message_subscribers(self, which_port)

# Register fmcomms2_source_sptr in _iio_swig:
_iio_swig.fmcomms2_source_sptr_swigregister(fmcomms2_source_sptr)

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

class fmcomms2_source_f32c_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::iio::fmcomms2_source_f32c > class."""

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

    def __init__(self, *args):
        r"""
        __init__(fmcomms2_source_f32c_sptr self) -> fmcomms2_source_f32c_sptr
        __init__(fmcomms2_source_f32c_sptr self, fmcomms2_source_f32c p) -> fmcomms2_source_f32c_sptr
        """
        _iio_swig.fmcomms2_source_f32c_sptr_swiginit(self, _iio_swig.new_fmcomms2_source_f32c_sptr(*args))

    def __deref__(self) -> "gr::iio::fmcomms2_source_f32c *":
        r"""__deref__(fmcomms2_source_f32c_sptr self) -> fmcomms2_source_f32c"""
        return _iio_swig.fmcomms2_source_f32c_sptr___deref__(self)
    __swig_destroy__ = _iio_swig.delete_fmcomms2_source_f32c_sptr

    def make(self, *args, **kwargs) -> "gr::iio::fmcomms2_source_f32c::sptr":
        r"""make(fmcomms2_source_f32c_sptr self, std::string const & uri, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, bool rx1_en, bool rx2_en, unsigned long buffer_size, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * rf_port_select, char const * filter="", bool auto_filter=True) -> fmcomms2_source_f32c_sptr"""
        return _iio_swig.fmcomms2_source_f32c_sptr_make(self, *args, **kwargs)

    def set_params(self, *args, **kwargs) -> "void":
        r"""set_params(fmcomms2_source_f32c_sptr self, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * rf_port_select, char const * filter="", bool auto_filter=True)"""
        return _iio_swig.fmcomms2_source_f32c_sptr_set_params(self, *args, **kwargs)

    def primitive_connect(self, *args) -> "void":
        r"""
        primitive_connect(fmcomms2_source_f32c_sptr self, basic_block_sptr block)
        primitive_connect(fmcomms2_source_f32c_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _iio_swig.fmcomms2_source_f32c_sptr_primitive_connect(self, *args)

    def primitive_msg_connect(self, *args) -> "void":
        r"""
        primitive_msg_connect(fmcomms2_source_f32c_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_connect(fmcomms2_source_f32c_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _iio_swig.fmcomms2_source_f32c_sptr_primitive_msg_connect(self, *args)

    def primitive_msg_disconnect(self, *args) -> "void":
        r"""
        primitive_msg_disconnect(fmcomms2_source_f32c_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_disconnect(fmcomms2_source_f32c_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _iio_swig.fmcomms2_source_f32c_sptr_primitive_msg_disconnect(self, *args)

    def primitive_disconnect(self, *args) -> "void":
        r"""
        primitive_disconnect(fmcomms2_source_f32c_sptr self, basic_block_sptr block)
        primitive_disconnect(fmcomms2_source_f32c_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _iio_swig.fmcomms2_source_f32c_sptr_primitive_disconnect(self, *args)

    def disconnect_all(self) -> "void":
        r"""disconnect_all(fmcomms2_source_f32c_sptr self)"""
        return _iio_swig.fmcomms2_source_f32c_sptr_disconnect_all(self)

    def lock(self) -> "void":
        r"""lock(fmcomms2_source_f32c_sptr self)"""
        return _iio_swig.fmcomms2_source_f32c_sptr_lock(self)

    def unlock(self) -> "void":
        r"""unlock(fmcomms2_source_f32c_sptr self)"""
        return _iio_swig.fmcomms2_source_f32c_sptr_unlock(self)

    def primitive_message_port_register_hier_in(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_in(fmcomms2_source_f32c_sptr self, swig_pmt_ptr port_id)"""
        return _iio_swig.fmcomms2_source_f32c_sptr_primitive_message_port_register_hier_in(self, port_id)

    def primitive_message_port_register_hier_out(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_out(fmcomms2_source_f32c_sptr self, swig_pmt_ptr port_id)"""
        return _iio_swig.fmcomms2_source_f32c_sptr_primitive_message_port_register_hier_out(self, port_id)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(fmcomms2_source_f32c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _iio_swig.fmcomms2_source_f32c_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(fmcomms2_source_f32c_sptr self)"""
        return _iio_swig.fmcomms2_source_f32c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(fmcomms2_source_f32c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _iio_swig.fmcomms2_source_f32c_sptr_processor_affinity(self)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(fmcomms2_source_f32c_sptr self, std::string level)"""
        return _iio_swig.fmcomms2_source_f32c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(fmcomms2_source_f32c_sptr self) -> std::string"""
        return _iio_swig.fmcomms2_source_f32c_sptr_log_level(self)

    def max_output_buffer(self, i: "int") -> "size_t":
        r"""max_output_buffer(fmcomms2_source_f32c_sptr self, int i) -> size_t"""
        return _iio_swig.fmcomms2_source_f32c_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(fmcomms2_source_f32c_sptr self, size_t max_output_buffer)
        set_max_output_buffer(fmcomms2_source_f32c_sptr self, int port, size_t max_output_buffer)
        """
        return _iio_swig.fmcomms2_source_f32c_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "size_t":
        r"""min_output_buffer(fmcomms2_source_f32c_sptr self, int i) -> size_t"""
        return _iio_swig.fmcomms2_source_f32c_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(fmcomms2_source_f32c_sptr self, size_t min_output_buffer)
        set_min_output_buffer(fmcomms2_source_f32c_sptr self, int port, size_t min_output_buffer)
        """
        return _iio_swig.fmcomms2_source_f32c_sptr_set_min_output_buffer(self, *args)

    def to_hier_block2(self) -> "gr::hier_block2_sptr":
        r"""to_hier_block2(fmcomms2_source_f32c_sptr self) -> hier_block2_sptr"""
        return _iio_swig.fmcomms2_source_f32c_sptr_to_hier_block2(self)

    def name(self) -> "std::string":
        r"""name(fmcomms2_source_f32c_sptr self) -> std::string"""
        return _iio_swig.fmcomms2_source_f32c_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(fmcomms2_source_f32c_sptr self) -> std::string"""
        return _iio_swig.fmcomms2_source_f32c_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(fmcomms2_source_f32c_sptr self) -> io_signature_sptr"""
        return _iio_swig.fmcomms2_source_f32c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(fmcomms2_source_f32c_sptr self) -> io_signature_sptr"""
        return _iio_swig.fmcomms2_source_f32c_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(fmcomms2_source_f32c_sptr self) -> long"""
        return _iio_swig.fmcomms2_source_f32c_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(fmcomms2_source_f32c_sptr self) -> basic_block_sptr"""
        return _iio_swig.fmcomms2_source_f32c_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(fmcomms2_source_f32c_sptr self, int ninputs, int noutputs) -> bool"""
        return _iio_swig.fmcomms2_source_f32c_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(fmcomms2_source_f32c_sptr self) -> std::string"""
        return _iio_swig.fmcomms2_source_f32c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(fmcomms2_source_f32c_sptr self, std::string name)"""
        return _iio_swig.fmcomms2_source_f32c_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(fmcomms2_source_f32c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _iio_swig.fmcomms2_source_f32c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(fmcomms2_source_f32c_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms2_source_f32c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(fmcomms2_source_f32c_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms2_source_f32c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(fmcomms2_source_f32c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms2_source_f32c_sptr_message_subscribers(self, which_port)

# Register fmcomms2_source_f32c_sptr in _iio_swig:
_iio_swig.fmcomms2_source_f32c_sptr_swigregister(fmcomms2_source_f32c_sptr)

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

class fmcomms2_sink_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::iio::fmcomms2_sink > class."""

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

    def __init__(self, *args):
        r"""
        __init__(fmcomms2_sink_sptr self) -> fmcomms2_sink_sptr
        __init__(fmcomms2_sink_sptr self, fmcomms2_sink p) -> fmcomms2_sink_sptr
        """
        _iio_swig.fmcomms2_sink_sptr_swiginit(self, _iio_swig.new_fmcomms2_sink_sptr(*args))

    def __deref__(self) -> "gr::iio::fmcomms2_sink *":
        r"""__deref__(fmcomms2_sink_sptr self) -> fmcomms2_sink"""
        return _iio_swig.fmcomms2_sink_sptr___deref__(self)
    __swig_destroy__ = _iio_swig.delete_fmcomms2_sink_sptr

    def make(self, *args, **kwargs) -> "gr::iio::fmcomms2_sink::sptr":
        r"""make(fmcomms2_sink_sptr self, std::string const & uri, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, bool ch1_en, bool ch2_en, bool ch3_en, bool ch4_en, unsigned long buffer_size, bool cyclic, char const * rf_port_select, double attenuation1, double attenuation2, char const * filter="", bool auto_filter=True) -> fmcomms2_sink_sptr"""
        return _iio_swig.fmcomms2_sink_sptr_make(self, *args, **kwargs)

    def make_from(self, *args, **kwargs) -> "gr::iio::fmcomms2_sink::sptr":
        r"""make_from(fmcomms2_sink_sptr self, iio_context * ctx, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, bool ch1_en, bool ch2_en, bool ch3_en, bool ch4_en, unsigned long buffer_size, bool cyclic, char const * rf_port_select, double attenuation1, double attenuation2, char const * filter="", bool auto_filter=True) -> fmcomms2_sink_sptr"""
        return _iio_swig.fmcomms2_sink_sptr_make_from(self, *args, **kwargs)

    def set_params(self, *args, **kwargs) -> "void":
        r"""set_params(fmcomms2_sink_sptr self, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, char const * rf_port_select, double attenuation1, double attenuation2, char const * filter="", bool auto_filter=True)"""
        return _iio_swig.fmcomms2_sink_sptr_set_params(self, *args, **kwargs)

    def history(self) -> "unsigned int":
        r"""history(fmcomms2_sink_sptr self) -> unsigned int"""
        return _iio_swig.fmcomms2_sink_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(fmcomms2_sink_sptr self, int which, int delay)
        declare_sample_delay(fmcomms2_sink_sptr self, unsigned int delay)
        """
        return _iio_swig.fmcomms2_sink_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(fmcomms2_sink_sptr self, int which) -> unsigned int"""
        return _iio_swig.fmcomms2_sink_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(fmcomms2_sink_sptr self, int multiple)"""
        return _iio_swig.fmcomms2_sink_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(fmcomms2_sink_sptr self) -> int"""
        return _iio_swig.fmcomms2_sink_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(fmcomms2_sink_sptr self) -> double"""
        return _iio_swig.fmcomms2_sink_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(fmcomms2_sink_sptr self) -> uint64_t"""
        return _iio_swig.fmcomms2_sink_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(fmcomms2_sink_sptr self) -> uint64_t"""
        return _iio_swig.fmcomms2_sink_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(fmcomms2_sink_sptr self) -> bool"""
        return _iio_swig.fmcomms2_sink_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(fmcomms2_sink_sptr self) -> bool"""
        return _iio_swig.fmcomms2_sink_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(fmcomms2_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _iio_swig.fmcomms2_sink_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(fmcomms2_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _iio_swig.fmcomms2_sink_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(fmcomms2_sink_sptr self, std::string level)"""
        return _iio_swig.fmcomms2_sink_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(fmcomms2_sink_sptr self) -> std::string"""
        return _iio_swig.fmcomms2_sink_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(fmcomms2_sink_sptr self) -> int"""
        return _iio_swig.fmcomms2_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(fmcomms2_sink_sptr self, int m)"""
        return _iio_swig.fmcomms2_sink_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(fmcomms2_sink_sptr self)"""
        return _iio_swig.fmcomms2_sink_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(fmcomms2_sink_sptr self) -> bool"""
        return _iio_swig.fmcomms2_sink_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(fmcomms2_sink_sptr self, int m)"""
        return _iio_swig.fmcomms2_sink_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(fmcomms2_sink_sptr self) -> int"""
        return _iio_swig.fmcomms2_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(fmcomms2_sink_sptr self, int i) -> long"""
        return _iio_swig.fmcomms2_sink_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(fmcomms2_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(fmcomms2_sink_sptr self, int port, long max_output_buffer)
        """
        return _iio_swig.fmcomms2_sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(fmcomms2_sink_sptr self, int i) -> long"""
        return _iio_swig.fmcomms2_sink_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(fmcomms2_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(fmcomms2_sink_sptr self, int port, long min_output_buffer)
        """
        return _iio_swig.fmcomms2_sink_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(fmcomms2_sink_sptr self) -> float"""
        return _iio_swig.fmcomms2_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(fmcomms2_sink_sptr self) -> float"""
        return _iio_swig.fmcomms2_sink_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(fmcomms2_sink_sptr self) -> float"""
        return _iio_swig.fmcomms2_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(fmcomms2_sink_sptr self) -> float"""
        return _iio_swig.fmcomms2_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(fmcomms2_sink_sptr self) -> float"""
        return _iio_swig.fmcomms2_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(fmcomms2_sink_sptr self) -> float"""
        return _iio_swig.fmcomms2_sink_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(fmcomms2_sink_sptr self, int which) -> float
        pc_input_buffers_full(fmcomms2_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms2_sink_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(fmcomms2_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(fmcomms2_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms2_sink_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(fmcomms2_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(fmcomms2_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms2_sink_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(fmcomms2_sink_sptr self, int which) -> float
        pc_output_buffers_full(fmcomms2_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms2_sink_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(fmcomms2_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(fmcomms2_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms2_sink_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(fmcomms2_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(fmcomms2_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms2_sink_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(fmcomms2_sink_sptr self) -> float"""
        return _iio_swig.fmcomms2_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(fmcomms2_sink_sptr self) -> float"""
        return _iio_swig.fmcomms2_sink_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(fmcomms2_sink_sptr self) -> float"""
        return _iio_swig.fmcomms2_sink_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(fmcomms2_sink_sptr self) -> float"""
        return _iio_swig.fmcomms2_sink_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(fmcomms2_sink_sptr self) -> float"""
        return _iio_swig.fmcomms2_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(fmcomms2_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _iio_swig.fmcomms2_sink_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(fmcomms2_sink_sptr self)"""
        return _iio_swig.fmcomms2_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(fmcomms2_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _iio_swig.fmcomms2_sink_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(fmcomms2_sink_sptr self) -> int"""
        return _iio_swig.fmcomms2_sink_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(fmcomms2_sink_sptr self) -> int"""
        return _iio_swig.fmcomms2_sink_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(fmcomms2_sink_sptr self, int priority) -> int"""
        return _iio_swig.fmcomms2_sink_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(fmcomms2_sink_sptr self) -> std::string"""
        return _iio_swig.fmcomms2_sink_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(fmcomms2_sink_sptr self) -> std::string"""
        return _iio_swig.fmcomms2_sink_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(fmcomms2_sink_sptr self) -> io_signature_sptr"""
        return _iio_swig.fmcomms2_sink_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(fmcomms2_sink_sptr self) -> io_signature_sptr"""
        return _iio_swig.fmcomms2_sink_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(fmcomms2_sink_sptr self) -> long"""
        return _iio_swig.fmcomms2_sink_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(fmcomms2_sink_sptr self) -> basic_block_sptr"""
        return _iio_swig.fmcomms2_sink_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(fmcomms2_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _iio_swig.fmcomms2_sink_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(fmcomms2_sink_sptr self) -> std::string"""
        return _iio_swig.fmcomms2_sink_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(fmcomms2_sink_sptr self, std::string name)"""
        return _iio_swig.fmcomms2_sink_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(fmcomms2_sink_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _iio_swig.fmcomms2_sink_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(fmcomms2_sink_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms2_sink_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(fmcomms2_sink_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms2_sink_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(fmcomms2_sink_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms2_sink_sptr_message_subscribers(self, which_port)

# Register fmcomms2_sink_sptr in _iio_swig:
_iio_swig.fmcomms2_sink_sptr_swigregister(fmcomms2_sink_sptr)

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

class fmcomms2_sink_f32c_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::iio::fmcomms2_sink_f32c > class."""

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

    def __init__(self, *args):
        r"""
        __init__(fmcomms2_sink_f32c_sptr self) -> fmcomms2_sink_f32c_sptr
        __init__(fmcomms2_sink_f32c_sptr self, fmcomms2_sink_f32c p) -> fmcomms2_sink_f32c_sptr
        """
        _iio_swig.fmcomms2_sink_f32c_sptr_swiginit(self, _iio_swig.new_fmcomms2_sink_f32c_sptr(*args))

    def __deref__(self) -> "gr::iio::fmcomms2_sink_f32c *":
        r"""__deref__(fmcomms2_sink_f32c_sptr self) -> fmcomms2_sink_f32c"""
        return _iio_swig.fmcomms2_sink_f32c_sptr___deref__(self)
    __swig_destroy__ = _iio_swig.delete_fmcomms2_sink_f32c_sptr

    def make(self, *args, **kwargs) -> "gr::iio::fmcomms2_sink_f32c::sptr":
        r"""make(fmcomms2_sink_f32c_sptr self, std::string const & uri, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, bool rx1_en, bool rx2_en, unsigned long buffer_size, bool cyclic, char const * rf_port_select, double attenuation1, double attenuation2, char const * filter="", bool auto_filter=True) -> fmcomms2_sink_f32c_sptr"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_make(self, *args, **kwargs)

    def set_params(self, *args, **kwargs) -> "void":
        r"""set_params(fmcomms2_sink_f32c_sptr self, unsigned long long frequency, unsigned long samplerate, unsigned long bandwidth, char const * rf_port_select, double attenuation1, double attenuation2, char const * filter="", bool auto_filter=True)"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_set_params(self, *args, **kwargs)

    def primitive_connect(self, *args) -> "void":
        r"""
        primitive_connect(fmcomms2_sink_f32c_sptr self, basic_block_sptr block)
        primitive_connect(fmcomms2_sink_f32c_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _iio_swig.fmcomms2_sink_f32c_sptr_primitive_connect(self, *args)

    def primitive_msg_connect(self, *args) -> "void":
        r"""
        primitive_msg_connect(fmcomms2_sink_f32c_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_connect(fmcomms2_sink_f32c_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _iio_swig.fmcomms2_sink_f32c_sptr_primitive_msg_connect(self, *args)

    def primitive_msg_disconnect(self, *args) -> "void":
        r"""
        primitive_msg_disconnect(fmcomms2_sink_f32c_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_disconnect(fmcomms2_sink_f32c_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _iio_swig.fmcomms2_sink_f32c_sptr_primitive_msg_disconnect(self, *args)

    def primitive_disconnect(self, *args) -> "void":
        r"""
        primitive_disconnect(fmcomms2_sink_f32c_sptr self, basic_block_sptr block)
        primitive_disconnect(fmcomms2_sink_f32c_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _iio_swig.fmcomms2_sink_f32c_sptr_primitive_disconnect(self, *args)

    def disconnect_all(self) -> "void":
        r"""disconnect_all(fmcomms2_sink_f32c_sptr self)"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_disconnect_all(self)

    def lock(self) -> "void":
        r"""lock(fmcomms2_sink_f32c_sptr self)"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_lock(self)

    def unlock(self) -> "void":
        r"""unlock(fmcomms2_sink_f32c_sptr self)"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_unlock(self)

    def primitive_message_port_register_hier_in(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_in(fmcomms2_sink_f32c_sptr self, swig_pmt_ptr port_id)"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_primitive_message_port_register_hier_in(self, port_id)

    def primitive_message_port_register_hier_out(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_out(fmcomms2_sink_f32c_sptr self, swig_pmt_ptr port_id)"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_primitive_message_port_register_hier_out(self, port_id)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(fmcomms2_sink_f32c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(fmcomms2_sink_f32c_sptr self)"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(fmcomms2_sink_f32c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_processor_affinity(self)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(fmcomms2_sink_f32c_sptr self, std::string level)"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(fmcomms2_sink_f32c_sptr self) -> std::string"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_log_level(self)

    def max_output_buffer(self, i: "int") -> "size_t":
        r"""max_output_buffer(fmcomms2_sink_f32c_sptr self, int i) -> size_t"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(fmcomms2_sink_f32c_sptr self, size_t max_output_buffer)
        set_max_output_buffer(fmcomms2_sink_f32c_sptr self, int port, size_t max_output_buffer)
        """
        return _iio_swig.fmcomms2_sink_f32c_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "size_t":
        r"""min_output_buffer(fmcomms2_sink_f32c_sptr self, int i) -> size_t"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(fmcomms2_sink_f32c_sptr self, size_t min_output_buffer)
        set_min_output_buffer(fmcomms2_sink_f32c_sptr self, int port, size_t min_output_buffer)
        """
        return _iio_swig.fmcomms2_sink_f32c_sptr_set_min_output_buffer(self, *args)

    def to_hier_block2(self) -> "gr::hier_block2_sptr":
        r"""to_hier_block2(fmcomms2_sink_f32c_sptr self) -> hier_block2_sptr"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_to_hier_block2(self)

    def name(self) -> "std::string":
        r"""name(fmcomms2_sink_f32c_sptr self) -> std::string"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(fmcomms2_sink_f32c_sptr self) -> std::string"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(fmcomms2_sink_f32c_sptr self) -> io_signature_sptr"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(fmcomms2_sink_f32c_sptr self) -> io_signature_sptr"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(fmcomms2_sink_f32c_sptr self) -> long"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(fmcomms2_sink_f32c_sptr self) -> basic_block_sptr"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(fmcomms2_sink_f32c_sptr self, int ninputs, int noutputs) -> bool"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(fmcomms2_sink_f32c_sptr self) -> std::string"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(fmcomms2_sink_f32c_sptr self, std::string name)"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(fmcomms2_sink_f32c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _iio_swig.fmcomms2_sink_f32c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(fmcomms2_sink_f32c_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(fmcomms2_sink_f32c_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(fmcomms2_sink_f32c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms2_sink_f32c_sptr_message_subscribers(self, which_port)

# Register fmcomms2_sink_f32c_sptr in _iio_swig:
_iio_swig.fmcomms2_sink_f32c_sptr_swigregister(fmcomms2_sink_f32c_sptr)

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

class fmcomms5_source_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::iio::fmcomms5_source > class."""

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

    def __init__(self, *args):
        r"""
        __init__(fmcomms5_source_sptr self) -> fmcomms5_source_sptr
        __init__(fmcomms5_source_sptr self, fmcomms5_source p) -> fmcomms5_source_sptr
        """
        _iio_swig.fmcomms5_source_sptr_swiginit(self, _iio_swig.new_fmcomms5_source_sptr(*args))

    def __deref__(self) -> "gr::iio::fmcomms5_source *":
        r"""__deref__(fmcomms5_source_sptr self) -> fmcomms5_source"""
        return _iio_swig.fmcomms5_source_sptr___deref__(self)
    __swig_destroy__ = _iio_swig.delete_fmcomms5_source_sptr

    def make(self, *args, **kwargs) -> "gr::iio::fmcomms5_source::sptr":
        r"""make(fmcomms5_source_sptr self, std::string const & uri, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, bool ch1_en, bool ch2_en, bool ch3_en, bool ch4_en, bool ch5_en, bool ch6_en, bool ch7_en, bool ch8_en, unsigned long buffer_size, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * gain3, double gain3_value, char const * gain4, double gain4_value, char const * rf_port_select, char const * filter="") -> fmcomms5_source_sptr"""
        return _iio_swig.fmcomms5_source_sptr_make(self, *args, **kwargs)

    def make_from(self, *args, **kwargs) -> "gr::iio::fmcomms5_source::sptr":
        r"""make_from(fmcomms5_source_sptr self, iio_context * ctx, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, bool ch1_en, bool ch2_en, bool ch3_en, bool ch4_en, bool ch5_en, bool ch6_en, bool ch7_en, bool ch8_en, unsigned long buffer_size, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * gain3, double gain3_value, char const * gain4, double gain4_value, char const * rf_port_select, char const * filter="") -> fmcomms5_source_sptr"""
        return _iio_swig.fmcomms5_source_sptr_make_from(self, *args, **kwargs)

    def set_params(self, frequency1: "unsigned long long", frequency2: "unsigned long long", samplerate: "unsigned long", bandwidth: "unsigned long", quadrature: "bool", rfdc: "bool", bbdc: "bool", gain1: "char const *", gain1_value: "double", gain2: "char const *", gain2_value: "double", gain3: "char const *", gain3_value: "double", gain4: "char const *", gain4_value: "double", rf_port_select: "char const *") -> "void":
        r"""set_params(fmcomms5_source_sptr self, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * gain3, double gain3_value, char const * gain4, double gain4_value, char const * rf_port_select)"""
        return _iio_swig.fmcomms5_source_sptr_set_params(self, frequency1, frequency2, samplerate, bandwidth, quadrature, rfdc, bbdc, gain1, gain1_value, gain2, gain2_value, gain3, gain3_value, gain4, gain4_value, rf_port_select)

    def history(self) -> "unsigned int":
        r"""history(fmcomms5_source_sptr self) -> unsigned int"""
        return _iio_swig.fmcomms5_source_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(fmcomms5_source_sptr self, int which, int delay)
        declare_sample_delay(fmcomms5_source_sptr self, unsigned int delay)
        """
        return _iio_swig.fmcomms5_source_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(fmcomms5_source_sptr self, int which) -> unsigned int"""
        return _iio_swig.fmcomms5_source_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(fmcomms5_source_sptr self, int multiple)"""
        return _iio_swig.fmcomms5_source_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(fmcomms5_source_sptr self) -> int"""
        return _iio_swig.fmcomms5_source_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(fmcomms5_source_sptr self) -> double"""
        return _iio_swig.fmcomms5_source_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(fmcomms5_source_sptr self) -> uint64_t"""
        return _iio_swig.fmcomms5_source_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(fmcomms5_source_sptr self) -> uint64_t"""
        return _iio_swig.fmcomms5_source_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(fmcomms5_source_sptr self) -> bool"""
        return _iio_swig.fmcomms5_source_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(fmcomms5_source_sptr self) -> bool"""
        return _iio_swig.fmcomms5_source_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(fmcomms5_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _iio_swig.fmcomms5_source_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(fmcomms5_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _iio_swig.fmcomms5_source_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(fmcomms5_source_sptr self, std::string level)"""
        return _iio_swig.fmcomms5_source_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(fmcomms5_source_sptr self) -> std::string"""
        return _iio_swig.fmcomms5_source_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(fmcomms5_source_sptr self) -> int"""
        return _iio_swig.fmcomms5_source_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(fmcomms5_source_sptr self, int m)"""
        return _iio_swig.fmcomms5_source_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(fmcomms5_source_sptr self)"""
        return _iio_swig.fmcomms5_source_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(fmcomms5_source_sptr self) -> bool"""
        return _iio_swig.fmcomms5_source_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(fmcomms5_source_sptr self, int m)"""
        return _iio_swig.fmcomms5_source_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(fmcomms5_source_sptr self) -> int"""
        return _iio_swig.fmcomms5_source_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(fmcomms5_source_sptr self, int i) -> long"""
        return _iio_swig.fmcomms5_source_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(fmcomms5_source_sptr self, long max_output_buffer)
        set_max_output_buffer(fmcomms5_source_sptr self, int port, long max_output_buffer)
        """
        return _iio_swig.fmcomms5_source_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(fmcomms5_source_sptr self, int i) -> long"""
        return _iio_swig.fmcomms5_source_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(fmcomms5_source_sptr self, long min_output_buffer)
        set_min_output_buffer(fmcomms5_source_sptr self, int port, long min_output_buffer)
        """
        return _iio_swig.fmcomms5_source_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(fmcomms5_source_sptr self) -> float"""
        return _iio_swig.fmcomms5_source_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(fmcomms5_source_sptr self) -> float"""
        return _iio_swig.fmcomms5_source_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(fmcomms5_source_sptr self) -> float"""
        return _iio_swig.fmcomms5_source_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(fmcomms5_source_sptr self) -> float"""
        return _iio_swig.fmcomms5_source_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(fmcomms5_source_sptr self) -> float"""
        return _iio_swig.fmcomms5_source_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(fmcomms5_source_sptr self) -> float"""
        return _iio_swig.fmcomms5_source_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(fmcomms5_source_sptr self, int which) -> float
        pc_input_buffers_full(fmcomms5_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms5_source_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(fmcomms5_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(fmcomms5_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms5_source_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(fmcomms5_source_sptr self, int which) -> float
        pc_input_buffers_full_var(fmcomms5_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms5_source_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(fmcomms5_source_sptr self, int which) -> float
        pc_output_buffers_full(fmcomms5_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms5_source_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(fmcomms5_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(fmcomms5_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms5_source_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(fmcomms5_source_sptr self, int which) -> float
        pc_output_buffers_full_var(fmcomms5_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms5_source_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(fmcomms5_source_sptr self) -> float"""
        return _iio_swig.fmcomms5_source_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(fmcomms5_source_sptr self) -> float"""
        return _iio_swig.fmcomms5_source_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(fmcomms5_source_sptr self) -> float"""
        return _iio_swig.fmcomms5_source_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(fmcomms5_source_sptr self) -> float"""
        return _iio_swig.fmcomms5_source_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(fmcomms5_source_sptr self) -> float"""
        return _iio_swig.fmcomms5_source_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(fmcomms5_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _iio_swig.fmcomms5_source_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(fmcomms5_source_sptr self)"""
        return _iio_swig.fmcomms5_source_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(fmcomms5_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _iio_swig.fmcomms5_source_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(fmcomms5_source_sptr self) -> int"""
        return _iio_swig.fmcomms5_source_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(fmcomms5_source_sptr self) -> int"""
        return _iio_swig.fmcomms5_source_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(fmcomms5_source_sptr self, int priority) -> int"""
        return _iio_swig.fmcomms5_source_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(fmcomms5_source_sptr self) -> std::string"""
        return _iio_swig.fmcomms5_source_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(fmcomms5_source_sptr self) -> std::string"""
        return _iio_swig.fmcomms5_source_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(fmcomms5_source_sptr self) -> io_signature_sptr"""
        return _iio_swig.fmcomms5_source_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(fmcomms5_source_sptr self) -> io_signature_sptr"""
        return _iio_swig.fmcomms5_source_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(fmcomms5_source_sptr self) -> long"""
        return _iio_swig.fmcomms5_source_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(fmcomms5_source_sptr self) -> basic_block_sptr"""
        return _iio_swig.fmcomms5_source_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(fmcomms5_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _iio_swig.fmcomms5_source_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(fmcomms5_source_sptr self) -> std::string"""
        return _iio_swig.fmcomms5_source_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(fmcomms5_source_sptr self, std::string name)"""
        return _iio_swig.fmcomms5_source_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(fmcomms5_source_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _iio_swig.fmcomms5_source_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(fmcomms5_source_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms5_source_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(fmcomms5_source_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms5_source_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(fmcomms5_source_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms5_source_sptr_message_subscribers(self, which_port)

# Register fmcomms5_source_sptr in _iio_swig:
_iio_swig.fmcomms5_source_sptr_swigregister(fmcomms5_source_sptr)

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

class fmcomms5_source_f32c_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::iio::fmcomms5_source_f32c > class."""

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

    def __init__(self, *args):
        r"""
        __init__(fmcomms5_source_f32c_sptr self) -> fmcomms5_source_f32c_sptr
        __init__(fmcomms5_source_f32c_sptr self, fmcomms5_source_f32c p) -> fmcomms5_source_f32c_sptr
        """
        _iio_swig.fmcomms5_source_f32c_sptr_swiginit(self, _iio_swig.new_fmcomms5_source_f32c_sptr(*args))

    def __deref__(self) -> "gr::iio::fmcomms5_source_f32c *":
        r"""__deref__(fmcomms5_source_f32c_sptr self) -> fmcomms5_source_f32c"""
        return _iio_swig.fmcomms5_source_f32c_sptr___deref__(self)
    __swig_destroy__ = _iio_swig.delete_fmcomms5_source_f32c_sptr

    def make(self, *args, **kwargs) -> "gr::iio::fmcomms5_source_f32c::sptr":
        r"""make(fmcomms5_source_f32c_sptr self, std::string const & uri, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, bool rx1_en, bool rx2_en, bool rx3_en, bool rx4_en, unsigned long buffer_size, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * gain3, double gain3_value, char const * gain4, double gain4_value, char const * rf_port_select, char const * filter="") -> fmcomms5_source_f32c_sptr"""
        return _iio_swig.fmcomms5_source_f32c_sptr_make(self, *args, **kwargs)

    def set_params(self, frequency1: "unsigned long long", frequency2: "unsigned long long", samplerate: "unsigned long", bandwidth: "unsigned long", quadrature: "bool", rfdc: "bool", bbdc: "bool", gain1: "char const *", gain1_value: "double", gain2: "char const *", gain2_value: "double", gain3: "char const *", gain3_value: "double", gain4: "char const *", gain4_value: "double", rf_port_select: "char const *") -> "void":
        r"""set_params(fmcomms5_source_f32c_sptr self, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, bool quadrature, bool rfdc, bool bbdc, char const * gain1, double gain1_value, char const * gain2, double gain2_value, char const * gain3, double gain3_value, char const * gain4, double gain4_value, char const * rf_port_select)"""
        return _iio_swig.fmcomms5_source_f32c_sptr_set_params(self, frequency1, frequency2, samplerate, bandwidth, quadrature, rfdc, bbdc, gain1, gain1_value, gain2, gain2_value, gain3, gain3_value, gain4, gain4_value, rf_port_select)

    def primitive_connect(self, *args) -> "void":
        r"""
        primitive_connect(fmcomms5_source_f32c_sptr self, basic_block_sptr block)
        primitive_connect(fmcomms5_source_f32c_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _iio_swig.fmcomms5_source_f32c_sptr_primitive_connect(self, *args)

    def primitive_msg_connect(self, *args) -> "void":
        r"""
        primitive_msg_connect(fmcomms5_source_f32c_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_connect(fmcomms5_source_f32c_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _iio_swig.fmcomms5_source_f32c_sptr_primitive_msg_connect(self, *args)

    def primitive_msg_disconnect(self, *args) -> "void":
        r"""
        primitive_msg_disconnect(fmcomms5_source_f32c_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_disconnect(fmcomms5_source_f32c_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _iio_swig.fmcomms5_source_f32c_sptr_primitive_msg_disconnect(self, *args)

    def primitive_disconnect(self, *args) -> "void":
        r"""
        primitive_disconnect(fmcomms5_source_f32c_sptr self, basic_block_sptr block)
        primitive_disconnect(fmcomms5_source_f32c_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _iio_swig.fmcomms5_source_f32c_sptr_primitive_disconnect(self, *args)

    def disconnect_all(self) -> "void":
        r"""disconnect_all(fmcomms5_source_f32c_sptr self)"""
        return _iio_swig.fmcomms5_source_f32c_sptr_disconnect_all(self)

    def lock(self) -> "void":
        r"""lock(fmcomms5_source_f32c_sptr self)"""
        return _iio_swig.fmcomms5_source_f32c_sptr_lock(self)

    def unlock(self) -> "void":
        r"""unlock(fmcomms5_source_f32c_sptr self)"""
        return _iio_swig.fmcomms5_source_f32c_sptr_unlock(self)

    def primitive_message_port_register_hier_in(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_in(fmcomms5_source_f32c_sptr self, swig_pmt_ptr port_id)"""
        return _iio_swig.fmcomms5_source_f32c_sptr_primitive_message_port_register_hier_in(self, port_id)

    def primitive_message_port_register_hier_out(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_out(fmcomms5_source_f32c_sptr self, swig_pmt_ptr port_id)"""
        return _iio_swig.fmcomms5_source_f32c_sptr_primitive_message_port_register_hier_out(self, port_id)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(fmcomms5_source_f32c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _iio_swig.fmcomms5_source_f32c_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(fmcomms5_source_f32c_sptr self)"""
        return _iio_swig.fmcomms5_source_f32c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(fmcomms5_source_f32c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _iio_swig.fmcomms5_source_f32c_sptr_processor_affinity(self)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(fmcomms5_source_f32c_sptr self, std::string level)"""
        return _iio_swig.fmcomms5_source_f32c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(fmcomms5_source_f32c_sptr self) -> std::string"""
        return _iio_swig.fmcomms5_source_f32c_sptr_log_level(self)

    def max_output_buffer(self, i: "int") -> "size_t":
        r"""max_output_buffer(fmcomms5_source_f32c_sptr self, int i) -> size_t"""
        return _iio_swig.fmcomms5_source_f32c_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(fmcomms5_source_f32c_sptr self, size_t max_output_buffer)
        set_max_output_buffer(fmcomms5_source_f32c_sptr self, int port, size_t max_output_buffer)
        """
        return _iio_swig.fmcomms5_source_f32c_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "size_t":
        r"""min_output_buffer(fmcomms5_source_f32c_sptr self, int i) -> size_t"""
        return _iio_swig.fmcomms5_source_f32c_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(fmcomms5_source_f32c_sptr self, size_t min_output_buffer)
        set_min_output_buffer(fmcomms5_source_f32c_sptr self, int port, size_t min_output_buffer)
        """
        return _iio_swig.fmcomms5_source_f32c_sptr_set_min_output_buffer(self, *args)

    def to_hier_block2(self) -> "gr::hier_block2_sptr":
        r"""to_hier_block2(fmcomms5_source_f32c_sptr self) -> hier_block2_sptr"""
        return _iio_swig.fmcomms5_source_f32c_sptr_to_hier_block2(self)

    def name(self) -> "std::string":
        r"""name(fmcomms5_source_f32c_sptr self) -> std::string"""
        return _iio_swig.fmcomms5_source_f32c_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(fmcomms5_source_f32c_sptr self) -> std::string"""
        return _iio_swig.fmcomms5_source_f32c_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(fmcomms5_source_f32c_sptr self) -> io_signature_sptr"""
        return _iio_swig.fmcomms5_source_f32c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(fmcomms5_source_f32c_sptr self) -> io_signature_sptr"""
        return _iio_swig.fmcomms5_source_f32c_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(fmcomms5_source_f32c_sptr self) -> long"""
        return _iio_swig.fmcomms5_source_f32c_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(fmcomms5_source_f32c_sptr self) -> basic_block_sptr"""
        return _iio_swig.fmcomms5_source_f32c_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(fmcomms5_source_f32c_sptr self, int ninputs, int noutputs) -> bool"""
        return _iio_swig.fmcomms5_source_f32c_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(fmcomms5_source_f32c_sptr self) -> std::string"""
        return _iio_swig.fmcomms5_source_f32c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(fmcomms5_source_f32c_sptr self, std::string name)"""
        return _iio_swig.fmcomms5_source_f32c_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(fmcomms5_source_f32c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _iio_swig.fmcomms5_source_f32c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(fmcomms5_source_f32c_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms5_source_f32c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(fmcomms5_source_f32c_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms5_source_f32c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(fmcomms5_source_f32c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms5_source_f32c_sptr_message_subscribers(self, which_port)

# Register fmcomms5_source_f32c_sptr in _iio_swig:
_iio_swig.fmcomms5_source_f32c_sptr_swigregister(fmcomms5_source_f32c_sptr)

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

class fmcomms5_sink_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::iio::fmcomms5_sink > class."""

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

    def __init__(self, *args):
        r"""
        __init__(fmcomms5_sink_sptr self) -> fmcomms5_sink_sptr
        __init__(fmcomms5_sink_sptr self, fmcomms5_sink p) -> fmcomms5_sink_sptr
        """
        _iio_swig.fmcomms5_sink_sptr_swiginit(self, _iio_swig.new_fmcomms5_sink_sptr(*args))

    def __deref__(self) -> "gr::iio::fmcomms5_sink *":
        r"""__deref__(fmcomms5_sink_sptr self) -> fmcomms5_sink"""
        return _iio_swig.fmcomms5_sink_sptr___deref__(self)
    __swig_destroy__ = _iio_swig.delete_fmcomms5_sink_sptr

    def make(self, *args, **kwargs) -> "gr::iio::fmcomms5_sink::sptr":
        r"""make(fmcomms5_sink_sptr self, std::string const & uri, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, bool ch1_en, bool ch2_en, bool ch3_en, bool ch4_en, bool ch5_en, bool ch6_en, bool ch7_en, bool ch8_en, unsigned long buffer_size, bool cyclic, char const * rf_port_select, double attenuation1, double attenuation2, double attenuation3, double attenuation4, char const * filter="") -> fmcomms5_sink_sptr"""
        return _iio_swig.fmcomms5_sink_sptr_make(self, *args, **kwargs)

    def make_from(self, *args, **kwargs) -> "gr::iio::fmcomms5_sink::sptr":
        r"""make_from(fmcomms5_sink_sptr self, iio_context * ctx, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, bool ch1_en, bool ch2_en, bool ch3_en, bool ch4_en, bool ch5_en, bool ch6_en, bool ch7_en, bool ch8_en, unsigned long buffer_size, bool cyclic, char const * rf_port_select, double attenuation1, double attenuation2, double attenuation3, double attenuation4, char const * filter="") -> fmcomms5_sink_sptr"""
        return _iio_swig.fmcomms5_sink_sptr_make_from(self, *args, **kwargs)

    def set_params(self, frequency1: "unsigned long long", frequency2: "unsigned long long", samplerate: "unsigned long", bandwidth: "unsigned long", rf_port_select: "char const *", attenuation1: "double", attenuation2: "double", attenuation3: "double", attenuation4: "double") -> "void":
        r"""set_params(fmcomms5_sink_sptr self, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, char const * rf_port_select, double attenuation1, double attenuation2, double attenuation3, double attenuation4)"""
        return _iio_swig.fmcomms5_sink_sptr_set_params(self, frequency1, frequency2, samplerate, bandwidth, rf_port_select, attenuation1, attenuation2, attenuation3, attenuation4)

    def history(self) -> "unsigned int":
        r"""history(fmcomms5_sink_sptr self) -> unsigned int"""
        return _iio_swig.fmcomms5_sink_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(fmcomms5_sink_sptr self, int which, int delay)
        declare_sample_delay(fmcomms5_sink_sptr self, unsigned int delay)
        """
        return _iio_swig.fmcomms5_sink_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(fmcomms5_sink_sptr self, int which) -> unsigned int"""
        return _iio_swig.fmcomms5_sink_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(fmcomms5_sink_sptr self, int multiple)"""
        return _iio_swig.fmcomms5_sink_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(fmcomms5_sink_sptr self) -> int"""
        return _iio_swig.fmcomms5_sink_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(fmcomms5_sink_sptr self) -> double"""
        return _iio_swig.fmcomms5_sink_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(fmcomms5_sink_sptr self) -> uint64_t"""
        return _iio_swig.fmcomms5_sink_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(fmcomms5_sink_sptr self) -> uint64_t"""
        return _iio_swig.fmcomms5_sink_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(fmcomms5_sink_sptr self) -> bool"""
        return _iio_swig.fmcomms5_sink_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(fmcomms5_sink_sptr self) -> bool"""
        return _iio_swig.fmcomms5_sink_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(fmcomms5_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _iio_swig.fmcomms5_sink_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(fmcomms5_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _iio_swig.fmcomms5_sink_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(fmcomms5_sink_sptr self, std::string level)"""
        return _iio_swig.fmcomms5_sink_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(fmcomms5_sink_sptr self) -> std::string"""
        return _iio_swig.fmcomms5_sink_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(fmcomms5_sink_sptr self) -> int"""
        return _iio_swig.fmcomms5_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(fmcomms5_sink_sptr self, int m)"""
        return _iio_swig.fmcomms5_sink_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(fmcomms5_sink_sptr self)"""
        return _iio_swig.fmcomms5_sink_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(fmcomms5_sink_sptr self) -> bool"""
        return _iio_swig.fmcomms5_sink_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(fmcomms5_sink_sptr self, int m)"""
        return _iio_swig.fmcomms5_sink_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(fmcomms5_sink_sptr self) -> int"""
        return _iio_swig.fmcomms5_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(fmcomms5_sink_sptr self, int i) -> long"""
        return _iio_swig.fmcomms5_sink_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(fmcomms5_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(fmcomms5_sink_sptr self, int port, long max_output_buffer)
        """
        return _iio_swig.fmcomms5_sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(fmcomms5_sink_sptr self, int i) -> long"""
        return _iio_swig.fmcomms5_sink_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(fmcomms5_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(fmcomms5_sink_sptr self, int port, long min_output_buffer)
        """
        return _iio_swig.fmcomms5_sink_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(fmcomms5_sink_sptr self) -> float"""
        return _iio_swig.fmcomms5_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(fmcomms5_sink_sptr self) -> float"""
        return _iio_swig.fmcomms5_sink_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(fmcomms5_sink_sptr self) -> float"""
        return _iio_swig.fmcomms5_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(fmcomms5_sink_sptr self) -> float"""
        return _iio_swig.fmcomms5_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(fmcomms5_sink_sptr self) -> float"""
        return _iio_swig.fmcomms5_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(fmcomms5_sink_sptr self) -> float"""
        return _iio_swig.fmcomms5_sink_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(fmcomms5_sink_sptr self, int which) -> float
        pc_input_buffers_full(fmcomms5_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms5_sink_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(fmcomms5_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(fmcomms5_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms5_sink_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(fmcomms5_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(fmcomms5_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms5_sink_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(fmcomms5_sink_sptr self, int which) -> float
        pc_output_buffers_full(fmcomms5_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms5_sink_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(fmcomms5_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(fmcomms5_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms5_sink_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(fmcomms5_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(fmcomms5_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.fmcomms5_sink_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(fmcomms5_sink_sptr self) -> float"""
        return _iio_swig.fmcomms5_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(fmcomms5_sink_sptr self) -> float"""
        return _iio_swig.fmcomms5_sink_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(fmcomms5_sink_sptr self) -> float"""
        return _iio_swig.fmcomms5_sink_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(fmcomms5_sink_sptr self) -> float"""
        return _iio_swig.fmcomms5_sink_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(fmcomms5_sink_sptr self) -> float"""
        return _iio_swig.fmcomms5_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(fmcomms5_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _iio_swig.fmcomms5_sink_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(fmcomms5_sink_sptr self)"""
        return _iio_swig.fmcomms5_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(fmcomms5_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _iio_swig.fmcomms5_sink_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(fmcomms5_sink_sptr self) -> int"""
        return _iio_swig.fmcomms5_sink_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(fmcomms5_sink_sptr self) -> int"""
        return _iio_swig.fmcomms5_sink_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(fmcomms5_sink_sptr self, int priority) -> int"""
        return _iio_swig.fmcomms5_sink_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(fmcomms5_sink_sptr self) -> std::string"""
        return _iio_swig.fmcomms5_sink_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(fmcomms5_sink_sptr self) -> std::string"""
        return _iio_swig.fmcomms5_sink_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(fmcomms5_sink_sptr self) -> io_signature_sptr"""
        return _iio_swig.fmcomms5_sink_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(fmcomms5_sink_sptr self) -> io_signature_sptr"""
        return _iio_swig.fmcomms5_sink_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(fmcomms5_sink_sptr self) -> long"""
        return _iio_swig.fmcomms5_sink_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(fmcomms5_sink_sptr self) -> basic_block_sptr"""
        return _iio_swig.fmcomms5_sink_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(fmcomms5_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _iio_swig.fmcomms5_sink_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(fmcomms5_sink_sptr self) -> std::string"""
        return _iio_swig.fmcomms5_sink_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(fmcomms5_sink_sptr self, std::string name)"""
        return _iio_swig.fmcomms5_sink_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(fmcomms5_sink_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _iio_swig.fmcomms5_sink_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(fmcomms5_sink_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms5_sink_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(fmcomms5_sink_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms5_sink_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(fmcomms5_sink_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms5_sink_sptr_message_subscribers(self, which_port)

# Register fmcomms5_sink_sptr in _iio_swig:
_iio_swig.fmcomms5_sink_sptr_swigregister(fmcomms5_sink_sptr)

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

class fmcomms5_sink_f32c_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::iio::fmcomms5_sink_f32c > class."""

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

    def __init__(self, *args):
        r"""
        __init__(fmcomms5_sink_f32c_sptr self) -> fmcomms5_sink_f32c_sptr
        __init__(fmcomms5_sink_f32c_sptr self, fmcomms5_sink_f32c p) -> fmcomms5_sink_f32c_sptr
        """
        _iio_swig.fmcomms5_sink_f32c_sptr_swiginit(self, _iio_swig.new_fmcomms5_sink_f32c_sptr(*args))

    def __deref__(self) -> "gr::iio::fmcomms5_sink_f32c *":
        r"""__deref__(fmcomms5_sink_f32c_sptr self) -> fmcomms5_sink_f32c"""
        return _iio_swig.fmcomms5_sink_f32c_sptr___deref__(self)
    __swig_destroy__ = _iio_swig.delete_fmcomms5_sink_f32c_sptr

    def make(self, *args, **kwargs) -> "gr::iio::fmcomms5_sink_f32c::sptr":
        r"""make(fmcomms5_sink_f32c_sptr self, std::string const & uri, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, bool rx1_en, bool rx2_en, bool rx3_en, bool rx4_en, unsigned long buffer_size, bool cyclic, char const * rf_port_select, double attenuation1, double attenuation2, double attenuation3, double attenuation4, char const * filter="") -> fmcomms5_sink_f32c_sptr"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_make(self, *args, **kwargs)

    def set_params(self, frequency1: "unsigned long long", frequency2: "unsigned long long", samplerate: "unsigned long", bandwidth: "unsigned long", rf_port_select: "char const *", attenuation1: "double", attenuation2: "double", attenuation3: "double", attenuation4: "double") -> "void":
        r"""set_params(fmcomms5_sink_f32c_sptr self, unsigned long long frequency1, unsigned long long frequency2, unsigned long samplerate, unsigned long bandwidth, char const * rf_port_select, double attenuation1, double attenuation2, double attenuation3, double attenuation4)"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_set_params(self, frequency1, frequency2, samplerate, bandwidth, rf_port_select, attenuation1, attenuation2, attenuation3, attenuation4)

    def primitive_connect(self, *args) -> "void":
        r"""
        primitive_connect(fmcomms5_sink_f32c_sptr self, basic_block_sptr block)
        primitive_connect(fmcomms5_sink_f32c_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _iio_swig.fmcomms5_sink_f32c_sptr_primitive_connect(self, *args)

    def primitive_msg_connect(self, *args) -> "void":
        r"""
        primitive_msg_connect(fmcomms5_sink_f32c_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_connect(fmcomms5_sink_f32c_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _iio_swig.fmcomms5_sink_f32c_sptr_primitive_msg_connect(self, *args)

    def primitive_msg_disconnect(self, *args) -> "void":
        r"""
        primitive_msg_disconnect(fmcomms5_sink_f32c_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_disconnect(fmcomms5_sink_f32c_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _iio_swig.fmcomms5_sink_f32c_sptr_primitive_msg_disconnect(self, *args)

    def primitive_disconnect(self, *args) -> "void":
        r"""
        primitive_disconnect(fmcomms5_sink_f32c_sptr self, basic_block_sptr block)
        primitive_disconnect(fmcomms5_sink_f32c_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _iio_swig.fmcomms5_sink_f32c_sptr_primitive_disconnect(self, *args)

    def disconnect_all(self) -> "void":
        r"""disconnect_all(fmcomms5_sink_f32c_sptr self)"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_disconnect_all(self)

    def lock(self) -> "void":
        r"""lock(fmcomms5_sink_f32c_sptr self)"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_lock(self)

    def unlock(self) -> "void":
        r"""unlock(fmcomms5_sink_f32c_sptr self)"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_unlock(self)

    def primitive_message_port_register_hier_in(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_in(fmcomms5_sink_f32c_sptr self, swig_pmt_ptr port_id)"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_primitive_message_port_register_hier_in(self, port_id)

    def primitive_message_port_register_hier_out(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_out(fmcomms5_sink_f32c_sptr self, swig_pmt_ptr port_id)"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_primitive_message_port_register_hier_out(self, port_id)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(fmcomms5_sink_f32c_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(fmcomms5_sink_f32c_sptr self)"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(fmcomms5_sink_f32c_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_processor_affinity(self)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(fmcomms5_sink_f32c_sptr self, std::string level)"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(fmcomms5_sink_f32c_sptr self) -> std::string"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_log_level(self)

    def max_output_buffer(self, i: "int") -> "size_t":
        r"""max_output_buffer(fmcomms5_sink_f32c_sptr self, int i) -> size_t"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(fmcomms5_sink_f32c_sptr self, size_t max_output_buffer)
        set_max_output_buffer(fmcomms5_sink_f32c_sptr self, int port, size_t max_output_buffer)
        """
        return _iio_swig.fmcomms5_sink_f32c_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "size_t":
        r"""min_output_buffer(fmcomms5_sink_f32c_sptr self, int i) -> size_t"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(fmcomms5_sink_f32c_sptr self, size_t min_output_buffer)
        set_min_output_buffer(fmcomms5_sink_f32c_sptr self, int port, size_t min_output_buffer)
        """
        return _iio_swig.fmcomms5_sink_f32c_sptr_set_min_output_buffer(self, *args)

    def to_hier_block2(self) -> "gr::hier_block2_sptr":
        r"""to_hier_block2(fmcomms5_sink_f32c_sptr self) -> hier_block2_sptr"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_to_hier_block2(self)

    def name(self) -> "std::string":
        r"""name(fmcomms5_sink_f32c_sptr self) -> std::string"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(fmcomms5_sink_f32c_sptr self) -> std::string"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(fmcomms5_sink_f32c_sptr self) -> io_signature_sptr"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(fmcomms5_sink_f32c_sptr self) -> io_signature_sptr"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(fmcomms5_sink_f32c_sptr self) -> long"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(fmcomms5_sink_f32c_sptr self) -> basic_block_sptr"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(fmcomms5_sink_f32c_sptr self, int ninputs, int noutputs) -> bool"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(fmcomms5_sink_f32c_sptr self) -> std::string"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(fmcomms5_sink_f32c_sptr self, std::string name)"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(fmcomms5_sink_f32c_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _iio_swig.fmcomms5_sink_f32c_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(fmcomms5_sink_f32c_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(fmcomms5_sink_f32c_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(fmcomms5_sink_f32c_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _iio_swig.fmcomms5_sink_f32c_sptr_message_subscribers(self, which_port)

# Register fmcomms5_sink_f32c_sptr in _iio_swig:
_iio_swig.fmcomms5_sink_f32c_sptr_swigregister(fmcomms5_sink_f32c_sptr)

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

class iio_math_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::iio::iio_math > class."""

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

    def __init__(self, *args):
        r"""
        __init__(iio_math_sptr self) -> iio_math_sptr
        __init__(iio_math_sptr self, iio_math p) -> iio_math_sptr
        """
        _iio_swig.iio_math_sptr_swiginit(self, _iio_swig.new_iio_math_sptr(*args))

    def __deref__(self) -> "gr::iio::iio_math *":
        r"""__deref__(iio_math_sptr self) -> iio_math"""
        return _iio_swig.iio_math_sptr___deref__(self)
    __swig_destroy__ = _iio_swig.delete_iio_math_sptr

    def make(self, function: "std::string const &", ninputs: "int"=1) -> "gr::iio::iio_math::sptr":
        r"""make(iio_math_sptr self, std::string const & function, int ninputs=1) -> iio_math_sptr"""
        return _iio_swig.iio_math_sptr_make(self, function, ninputs)

    def primitive_connect(self, *args) -> "void":
        r"""
        primitive_connect(iio_math_sptr self, basic_block_sptr block)
        primitive_connect(iio_math_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _iio_swig.iio_math_sptr_primitive_connect(self, *args)

    def primitive_msg_connect(self, *args) -> "void":
        r"""
        primitive_msg_connect(iio_math_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_connect(iio_math_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _iio_swig.iio_math_sptr_primitive_msg_connect(self, *args)

    def primitive_msg_disconnect(self, *args) -> "void":
        r"""
        primitive_msg_disconnect(iio_math_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_disconnect(iio_math_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _iio_swig.iio_math_sptr_primitive_msg_disconnect(self, *args)

    def primitive_disconnect(self, *args) -> "void":
        r"""
        primitive_disconnect(iio_math_sptr self, basic_block_sptr block)
        primitive_disconnect(iio_math_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _iio_swig.iio_math_sptr_primitive_disconnect(self, *args)

    def disconnect_all(self) -> "void":
        r"""disconnect_all(iio_math_sptr self)"""
        return _iio_swig.iio_math_sptr_disconnect_all(self)

    def lock(self) -> "void":
        r"""lock(iio_math_sptr self)"""
        return _iio_swig.iio_math_sptr_lock(self)

    def unlock(self) -> "void":
        r"""unlock(iio_math_sptr self)"""
        return _iio_swig.iio_math_sptr_unlock(self)

    def primitive_message_port_register_hier_in(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_in(iio_math_sptr self, swig_pmt_ptr port_id)"""
        return _iio_swig.iio_math_sptr_primitive_message_port_register_hier_in(self, port_id)

    def primitive_message_port_register_hier_out(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_out(iio_math_sptr self, swig_pmt_ptr port_id)"""
        return _iio_swig.iio_math_sptr_primitive_message_port_register_hier_out(self, port_id)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(iio_math_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _iio_swig.iio_math_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(iio_math_sptr self)"""
        return _iio_swig.iio_math_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(iio_math_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _iio_swig.iio_math_sptr_processor_affinity(self)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(iio_math_sptr self, std::string level)"""
        return _iio_swig.iio_math_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(iio_math_sptr self) -> std::string"""
        return _iio_swig.iio_math_sptr_log_level(self)

    def max_output_buffer(self, i: "int") -> "size_t":
        r"""max_output_buffer(iio_math_sptr self, int i) -> size_t"""
        return _iio_swig.iio_math_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(iio_math_sptr self, size_t max_output_buffer)
        set_max_output_buffer(iio_math_sptr self, int port, size_t max_output_buffer)
        """
        return _iio_swig.iio_math_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "size_t":
        r"""min_output_buffer(iio_math_sptr self, int i) -> size_t"""
        return _iio_swig.iio_math_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(iio_math_sptr self, size_t min_output_buffer)
        set_min_output_buffer(iio_math_sptr self, int port, size_t min_output_buffer)
        """
        return _iio_swig.iio_math_sptr_set_min_output_buffer(self, *args)

    def to_hier_block2(self) -> "gr::hier_block2_sptr":
        r"""to_hier_block2(iio_math_sptr self) -> hier_block2_sptr"""
        return _iio_swig.iio_math_sptr_to_hier_block2(self)

    def name(self) -> "std::string":
        r"""name(iio_math_sptr self) -> std::string"""
        return _iio_swig.iio_math_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(iio_math_sptr self) -> std::string"""
        return _iio_swig.iio_math_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(iio_math_sptr self) -> io_signature_sptr"""
        return _iio_swig.iio_math_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(iio_math_sptr self) -> io_signature_sptr"""
        return _iio_swig.iio_math_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(iio_math_sptr self) -> long"""
        return _iio_swig.iio_math_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(iio_math_sptr self) -> basic_block_sptr"""
        return _iio_swig.iio_math_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(iio_math_sptr self, int ninputs, int noutputs) -> bool"""
        return _iio_swig.iio_math_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(iio_math_sptr self) -> std::string"""
        return _iio_swig.iio_math_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(iio_math_sptr self, std::string name)"""
        return _iio_swig.iio_math_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(iio_math_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _iio_swig.iio_math_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(iio_math_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.iio_math_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(iio_math_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.iio_math_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(iio_math_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _iio_swig.iio_math_sptr_message_subscribers(self, which_port)

# Register iio_math_sptr in _iio_swig:
_iio_swig.iio_math_sptr_swigregister(iio_math_sptr)

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

class iio_math_gen_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::iio::iio_math_gen > class."""

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

    def __init__(self, *args):
        r"""
        __init__(iio_math_gen_sptr self) -> iio_math_gen_sptr
        __init__(iio_math_gen_sptr self, iio_math_gen p) -> iio_math_gen_sptr
        """
        _iio_swig.iio_math_gen_sptr_swiginit(self, _iio_swig.new_iio_math_gen_sptr(*args))

    def __deref__(self) -> "gr::iio::iio_math_gen *":
        r"""__deref__(iio_math_gen_sptr self) -> iio_math_gen"""
        return _iio_swig.iio_math_gen_sptr___deref__(self)
    __swig_destroy__ = _iio_swig.delete_iio_math_gen_sptr

    def make(self, sampling_freq: "double", wav_freq: "double", function: "std::string const &") -> "gr::iio::iio_math_gen::sptr":
        r"""make(iio_math_gen_sptr self, double sampling_freq, double wav_freq, std::string const & function) -> iio_math_gen_sptr"""
        return _iio_swig.iio_math_gen_sptr_make(self, sampling_freq, wav_freq, function)

    def primitive_connect(self, *args) -> "void":
        r"""
        primitive_connect(iio_math_gen_sptr self, basic_block_sptr block)
        primitive_connect(iio_math_gen_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _iio_swig.iio_math_gen_sptr_primitive_connect(self, *args)

    def primitive_msg_connect(self, *args) -> "void":
        r"""
        primitive_msg_connect(iio_math_gen_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_connect(iio_math_gen_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _iio_swig.iio_math_gen_sptr_primitive_msg_connect(self, *args)

    def primitive_msg_disconnect(self, *args) -> "void":
        r"""
        primitive_msg_disconnect(iio_math_gen_sptr self, basic_block_sptr src, swig_pmt_ptr srcport, basic_block_sptr dst, swig_pmt_ptr dstport)
        primitive_msg_disconnect(iio_math_gen_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _iio_swig.iio_math_gen_sptr_primitive_msg_disconnect(self, *args)

    def primitive_disconnect(self, *args) -> "void":
        r"""
        primitive_disconnect(iio_math_gen_sptr self, basic_block_sptr block)
        primitive_disconnect(iio_math_gen_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _iio_swig.iio_math_gen_sptr_primitive_disconnect(self, *args)

    def disconnect_all(self) -> "void":
        r"""disconnect_all(iio_math_gen_sptr self)"""
        return _iio_swig.iio_math_gen_sptr_disconnect_all(self)

    def lock(self) -> "void":
        r"""lock(iio_math_gen_sptr self)"""
        return _iio_swig.iio_math_gen_sptr_lock(self)

    def unlock(self) -> "void":
        r"""unlock(iio_math_gen_sptr self)"""
        return _iio_swig.iio_math_gen_sptr_unlock(self)

    def primitive_message_port_register_hier_in(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_in(iio_math_gen_sptr self, swig_pmt_ptr port_id)"""
        return _iio_swig.iio_math_gen_sptr_primitive_message_port_register_hier_in(self, port_id)

    def primitive_message_port_register_hier_out(self, port_id: "swig_pmt_ptr") -> "void":
        r"""primitive_message_port_register_hier_out(iio_math_gen_sptr self, swig_pmt_ptr port_id)"""
        return _iio_swig.iio_math_gen_sptr_primitive_message_port_register_hier_out(self, port_id)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(iio_math_gen_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _iio_swig.iio_math_gen_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(iio_math_gen_sptr self)"""
        return _iio_swig.iio_math_gen_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(iio_math_gen_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _iio_swig.iio_math_gen_sptr_processor_affinity(self)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(iio_math_gen_sptr self, std::string level)"""
        return _iio_swig.iio_math_gen_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(iio_math_gen_sptr self) -> std::string"""
        return _iio_swig.iio_math_gen_sptr_log_level(self)

    def max_output_buffer(self, i: "int") -> "size_t":
        r"""max_output_buffer(iio_math_gen_sptr self, int i) -> size_t"""
        return _iio_swig.iio_math_gen_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(iio_math_gen_sptr self, size_t max_output_buffer)
        set_max_output_buffer(iio_math_gen_sptr self, int port, size_t max_output_buffer)
        """
        return _iio_swig.iio_math_gen_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "size_t":
        r"""min_output_buffer(iio_math_gen_sptr self, int i) -> size_t"""
        return _iio_swig.iio_math_gen_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(iio_math_gen_sptr self, size_t min_output_buffer)
        set_min_output_buffer(iio_math_gen_sptr self, int port, size_t min_output_buffer)
        """
        return _iio_swig.iio_math_gen_sptr_set_min_output_buffer(self, *args)

    def to_hier_block2(self) -> "gr::hier_block2_sptr":
        r"""to_hier_block2(iio_math_gen_sptr self) -> hier_block2_sptr"""
        return _iio_swig.iio_math_gen_sptr_to_hier_block2(self)

    def name(self) -> "std::string":
        r"""name(iio_math_gen_sptr self) -> std::string"""
        return _iio_swig.iio_math_gen_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(iio_math_gen_sptr self) -> std::string"""
        return _iio_swig.iio_math_gen_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(iio_math_gen_sptr self) -> io_signature_sptr"""
        return _iio_swig.iio_math_gen_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(iio_math_gen_sptr self) -> io_signature_sptr"""
        return _iio_swig.iio_math_gen_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(iio_math_gen_sptr self) -> long"""
        return _iio_swig.iio_math_gen_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(iio_math_gen_sptr self) -> basic_block_sptr"""
        return _iio_swig.iio_math_gen_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(iio_math_gen_sptr self, int ninputs, int noutputs) -> bool"""
        return _iio_swig.iio_math_gen_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(iio_math_gen_sptr self) -> std::string"""
        return _iio_swig.iio_math_gen_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(iio_math_gen_sptr self, std::string name)"""
        return _iio_swig.iio_math_gen_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(iio_math_gen_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _iio_swig.iio_math_gen_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(iio_math_gen_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.iio_math_gen_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(iio_math_gen_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.iio_math_gen_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(iio_math_gen_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _iio_swig.iio_math_gen_sptr_message_subscribers(self, which_port)

# Register iio_math_gen_sptr in _iio_swig:
_iio_swig.iio_math_gen_sptr_swigregister(iio_math_gen_sptr)

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

class power_ff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::iio::power_ff > class."""

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

    def __init__(self, *args):
        r"""
        __init__(power_ff_sptr self) -> power_ff_sptr
        __init__(power_ff_sptr self, power_ff p) -> power_ff_sptr
        """
        _iio_swig.power_ff_sptr_swiginit(self, _iio_swig.new_power_ff_sptr(*args))

    def __deref__(self) -> "gr::iio::power_ff *":
        r"""__deref__(power_ff_sptr self) -> power_ff"""
        return _iio_swig.power_ff_sptr___deref__(self)
    __swig_destroy__ = _iio_swig.delete_power_ff_sptr

    def make(self, vlen: "size_t"=1) -> "gr::iio::power_ff::sptr":
        r"""make(power_ff_sptr self, size_t vlen=1) -> power_ff_sptr"""
        return _iio_swig.power_ff_sptr_make(self, vlen)

    def history(self) -> "unsigned int":
        r"""history(power_ff_sptr self) -> unsigned int"""
        return _iio_swig.power_ff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(power_ff_sptr self, int which, int delay)
        declare_sample_delay(power_ff_sptr self, unsigned int delay)
        """
        return _iio_swig.power_ff_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(power_ff_sptr self, int which) -> unsigned int"""
        return _iio_swig.power_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(power_ff_sptr self, int multiple)"""
        return _iio_swig.power_ff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(power_ff_sptr self) -> int"""
        return _iio_swig.power_ff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(power_ff_sptr self) -> double"""
        return _iio_swig.power_ff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(power_ff_sptr self) -> uint64_t"""
        return _iio_swig.power_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(power_ff_sptr self) -> uint64_t"""
        return _iio_swig.power_ff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(power_ff_sptr self) -> bool"""
        return _iio_swig.power_ff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(power_ff_sptr self) -> bool"""
        return _iio_swig.power_ff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(power_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _iio_swig.power_ff_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(power_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _iio_swig.power_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(power_ff_sptr self, std::string level)"""
        return _iio_swig.power_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(power_ff_sptr self) -> std::string"""
        return _iio_swig.power_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(power_ff_sptr self) -> int"""
        return _iio_swig.power_ff_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(power_ff_sptr self, int m)"""
        return _iio_swig.power_ff_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(power_ff_sptr self)"""
        return _iio_swig.power_ff_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(power_ff_sptr self) -> bool"""
        return _iio_swig.power_ff_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(power_ff_sptr self, int m)"""
        return _iio_swig.power_ff_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(power_ff_sptr self) -> int"""
        return _iio_swig.power_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(power_ff_sptr self, int i) -> long"""
        return _iio_swig.power_ff_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(power_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(power_ff_sptr self, int port, long max_output_buffer)
        """
        return _iio_swig.power_ff_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(power_ff_sptr self, int i) -> long"""
        return _iio_swig.power_ff_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(power_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(power_ff_sptr self, int port, long min_output_buffer)
        """
        return _iio_swig.power_ff_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(power_ff_sptr self) -> float"""
        return _iio_swig.power_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(power_ff_sptr self) -> float"""
        return _iio_swig.power_ff_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(power_ff_sptr self) -> float"""
        return _iio_swig.power_ff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(power_ff_sptr self) -> float"""
        return _iio_swig.power_ff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(power_ff_sptr self) -> float"""
        return _iio_swig.power_ff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(power_ff_sptr self) -> float"""
        return _iio_swig.power_ff_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(power_ff_sptr self, int which) -> float
        pc_input_buffers_full(power_ff_sptr self) -> pmt_vector_float
        """
        return _iio_swig.power_ff_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(power_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(power_ff_sptr self) -> pmt_vector_float
        """
        return _iio_swig.power_ff_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(power_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(power_ff_sptr self) -> pmt_vector_float
        """
        return _iio_swig.power_ff_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(power_ff_sptr self, int which) -> float
        pc_output_buffers_full(power_ff_sptr self) -> pmt_vector_float
        """
        return _iio_swig.power_ff_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(power_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(power_ff_sptr self) -> pmt_vector_float
        """
        return _iio_swig.power_ff_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(power_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(power_ff_sptr self) -> pmt_vector_float
        """
        return _iio_swig.power_ff_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(power_ff_sptr self) -> float"""
        return _iio_swig.power_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(power_ff_sptr self) -> float"""
        return _iio_swig.power_ff_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(power_ff_sptr self) -> float"""
        return _iio_swig.power_ff_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(power_ff_sptr self) -> float"""
        return _iio_swig.power_ff_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(power_ff_sptr self) -> float"""
        return _iio_swig.power_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(power_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _iio_swig.power_ff_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(power_ff_sptr self)"""
        return _iio_swig.power_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(power_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _iio_swig.power_ff_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(power_ff_sptr self) -> int"""
        return _iio_swig.power_ff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(power_ff_sptr self) -> int"""
        return _iio_swig.power_ff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(power_ff_sptr self, int priority) -> int"""
        return _iio_swig.power_ff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(power_ff_sptr self) -> std::string"""
        return _iio_swig.power_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(power_ff_sptr self) -> std::string"""
        return _iio_swig.power_ff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(power_ff_sptr self) -> io_signature_sptr"""
        return _iio_swig.power_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(power_ff_sptr self) -> io_signature_sptr"""
        return _iio_swig.power_ff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(power_ff_sptr self) -> long"""
        return _iio_swig.power_ff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(power_ff_sptr self) -> basic_block_sptr"""
        return _iio_swig.power_ff_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(power_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _iio_swig.power_ff_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(power_ff_sptr self) -> std::string"""
        return _iio_swig.power_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(power_ff_sptr self, std::string name)"""
        return _iio_swig.power_ff_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(power_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _iio_swig.power_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(power_ff_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.power_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(power_ff_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.power_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(power_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _iio_swig.power_ff_sptr_message_subscribers(self, which_port)

# Register power_ff_sptr in _iio_swig:
_iio_swig.power_ff_sptr_swigregister(power_ff_sptr)

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

class modulo_ff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::iio::modulo_ff > class."""

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

    def __init__(self, *args):
        r"""
        __init__(modulo_ff_sptr self) -> modulo_ff_sptr
        __init__(modulo_ff_sptr self, modulo_ff p) -> modulo_ff_sptr
        """
        _iio_swig.modulo_ff_sptr_swiginit(self, _iio_swig.new_modulo_ff_sptr(*args))

    def __deref__(self) -> "gr::iio::modulo_ff *":
        r"""__deref__(modulo_ff_sptr self) -> modulo_ff"""
        return _iio_swig.modulo_ff_sptr___deref__(self)
    __swig_destroy__ = _iio_swig.delete_modulo_ff_sptr

    def make(self, vlen: "size_t"=1) -> "gr::iio::modulo_ff::sptr":
        r"""make(modulo_ff_sptr self, size_t vlen=1) -> modulo_ff_sptr"""
        return _iio_swig.modulo_ff_sptr_make(self, vlen)

    def history(self) -> "unsigned int":
        r"""history(modulo_ff_sptr self) -> unsigned int"""
        return _iio_swig.modulo_ff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(modulo_ff_sptr self, int which, int delay)
        declare_sample_delay(modulo_ff_sptr self, unsigned int delay)
        """
        return _iio_swig.modulo_ff_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(modulo_ff_sptr self, int which) -> unsigned int"""
        return _iio_swig.modulo_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(modulo_ff_sptr self, int multiple)"""
        return _iio_swig.modulo_ff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(modulo_ff_sptr self) -> int"""
        return _iio_swig.modulo_ff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(modulo_ff_sptr self) -> double"""
        return _iio_swig.modulo_ff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(modulo_ff_sptr self) -> uint64_t"""
        return _iio_swig.modulo_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(modulo_ff_sptr self) -> uint64_t"""
        return _iio_swig.modulo_ff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(modulo_ff_sptr self) -> bool"""
        return _iio_swig.modulo_ff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(modulo_ff_sptr self) -> bool"""
        return _iio_swig.modulo_ff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(modulo_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _iio_swig.modulo_ff_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(modulo_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _iio_swig.modulo_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(modulo_ff_sptr self, std::string level)"""
        return _iio_swig.modulo_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(modulo_ff_sptr self) -> std::string"""
        return _iio_swig.modulo_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(modulo_ff_sptr self) -> int"""
        return _iio_swig.modulo_ff_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(modulo_ff_sptr self, int m)"""
        return _iio_swig.modulo_ff_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(modulo_ff_sptr self)"""
        return _iio_swig.modulo_ff_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(modulo_ff_sptr self) -> bool"""
        return _iio_swig.modulo_ff_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(modulo_ff_sptr self, int m)"""
        return _iio_swig.modulo_ff_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(modulo_ff_sptr self) -> int"""
        return _iio_swig.modulo_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(modulo_ff_sptr self, int i) -> long"""
        return _iio_swig.modulo_ff_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(modulo_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(modulo_ff_sptr self, int port, long max_output_buffer)
        """
        return _iio_swig.modulo_ff_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(modulo_ff_sptr self, int i) -> long"""
        return _iio_swig.modulo_ff_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(modulo_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(modulo_ff_sptr self, int port, long min_output_buffer)
        """
        return _iio_swig.modulo_ff_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(modulo_ff_sptr self) -> float"""
        return _iio_swig.modulo_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(modulo_ff_sptr self) -> float"""
        return _iio_swig.modulo_ff_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(modulo_ff_sptr self) -> float"""
        return _iio_swig.modulo_ff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(modulo_ff_sptr self) -> float"""
        return _iio_swig.modulo_ff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(modulo_ff_sptr self) -> float"""
        return _iio_swig.modulo_ff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(modulo_ff_sptr self) -> float"""
        return _iio_swig.modulo_ff_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(modulo_ff_sptr self, int which) -> float
        pc_input_buffers_full(modulo_ff_sptr self) -> pmt_vector_float
        """
        return _iio_swig.modulo_ff_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(modulo_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(modulo_ff_sptr self) -> pmt_vector_float
        """
        return _iio_swig.modulo_ff_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(modulo_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(modulo_ff_sptr self) -> pmt_vector_float
        """
        return _iio_swig.modulo_ff_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(modulo_ff_sptr self, int which) -> float
        pc_output_buffers_full(modulo_ff_sptr self) -> pmt_vector_float
        """
        return _iio_swig.modulo_ff_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(modulo_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(modulo_ff_sptr self) -> pmt_vector_float
        """
        return _iio_swig.modulo_ff_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(modulo_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(modulo_ff_sptr self) -> pmt_vector_float
        """
        return _iio_swig.modulo_ff_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(modulo_ff_sptr self) -> float"""
        return _iio_swig.modulo_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(modulo_ff_sptr self) -> float"""
        return _iio_swig.modulo_ff_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(modulo_ff_sptr self) -> float"""
        return _iio_swig.modulo_ff_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(modulo_ff_sptr self) -> float"""
        return _iio_swig.modulo_ff_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(modulo_ff_sptr self) -> float"""
        return _iio_swig.modulo_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(modulo_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _iio_swig.modulo_ff_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(modulo_ff_sptr self)"""
        return _iio_swig.modulo_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(modulo_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _iio_swig.modulo_ff_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(modulo_ff_sptr self) -> int"""
        return _iio_swig.modulo_ff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(modulo_ff_sptr self) -> int"""
        return _iio_swig.modulo_ff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(modulo_ff_sptr self, int priority) -> int"""
        return _iio_swig.modulo_ff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(modulo_ff_sptr self) -> std::string"""
        return _iio_swig.modulo_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(modulo_ff_sptr self) -> std::string"""
        return _iio_swig.modulo_ff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(modulo_ff_sptr self) -> io_signature_sptr"""
        return _iio_swig.modulo_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(modulo_ff_sptr self) -> io_signature_sptr"""
        return _iio_swig.modulo_ff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(modulo_ff_sptr self) -> long"""
        return _iio_swig.modulo_ff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(modulo_ff_sptr self) -> basic_block_sptr"""
        return _iio_swig.modulo_ff_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(modulo_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _iio_swig.modulo_ff_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(modulo_ff_sptr self) -> std::string"""
        return _iio_swig.modulo_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(modulo_ff_sptr self, std::string name)"""
        return _iio_swig.modulo_ff_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(modulo_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _iio_swig.modulo_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(modulo_ff_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.modulo_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(modulo_ff_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.modulo_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(modulo_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _iio_swig.modulo_ff_sptr_message_subscribers(self, which_port)

# Register modulo_ff_sptr in _iio_swig:
_iio_swig.modulo_ff_sptr_swigregister(modulo_ff_sptr)

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

class modulo_const_ff_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::iio::modulo_const_ff > class."""

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

    def __init__(self, *args):
        r"""
        __init__(modulo_const_ff_sptr self) -> modulo_const_ff_sptr
        __init__(modulo_const_ff_sptr self, modulo_const_ff p) -> modulo_const_ff_sptr
        """
        _iio_swig.modulo_const_ff_sptr_swiginit(self, _iio_swig.new_modulo_const_ff_sptr(*args))

    def __deref__(self) -> "gr::iio::modulo_const_ff *":
        r"""__deref__(modulo_const_ff_sptr self) -> modulo_const_ff"""
        return _iio_swig.modulo_const_ff_sptr___deref__(self)
    __swig_destroy__ = _iio_swig.delete_modulo_const_ff_sptr

    def make(self, modulo: "float", vlen: "size_t"=1) -> "gr::iio::modulo_const_ff::sptr":
        r"""make(modulo_const_ff_sptr self, float modulo, size_t vlen=1) -> modulo_const_ff_sptr"""
        return _iio_swig.modulo_const_ff_sptr_make(self, modulo, vlen)

    def history(self) -> "unsigned int":
        r"""history(modulo_const_ff_sptr self) -> unsigned int"""
        return _iio_swig.modulo_const_ff_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(modulo_const_ff_sptr self, int which, int delay)
        declare_sample_delay(modulo_const_ff_sptr self, unsigned int delay)
        """
        return _iio_swig.modulo_const_ff_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(modulo_const_ff_sptr self, int which) -> unsigned int"""
        return _iio_swig.modulo_const_ff_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(modulo_const_ff_sptr self, int multiple)"""
        return _iio_swig.modulo_const_ff_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(modulo_const_ff_sptr self) -> int"""
        return _iio_swig.modulo_const_ff_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(modulo_const_ff_sptr self) -> double"""
        return _iio_swig.modulo_const_ff_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(modulo_const_ff_sptr self) -> uint64_t"""
        return _iio_swig.modulo_const_ff_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(modulo_const_ff_sptr self) -> uint64_t"""
        return _iio_swig.modulo_const_ff_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(modulo_const_ff_sptr self) -> bool"""
        return _iio_swig.modulo_const_ff_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(modulo_const_ff_sptr self) -> bool"""
        return _iio_swig.modulo_const_ff_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(modulo_const_ff_sptr self, unsigned int which_input) -> uint64_t"""
        return _iio_swig.modulo_const_ff_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(modulo_const_ff_sptr self, unsigned int which_output) -> uint64_t"""
        return _iio_swig.modulo_const_ff_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(modulo_const_ff_sptr self, std::string level)"""
        return _iio_swig.modulo_const_ff_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(modulo_const_ff_sptr self) -> std::string"""
        return _iio_swig.modulo_const_ff_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(modulo_const_ff_sptr self) -> int"""
        return _iio_swig.modulo_const_ff_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(modulo_const_ff_sptr self, int m)"""
        return _iio_swig.modulo_const_ff_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(modulo_const_ff_sptr self)"""
        return _iio_swig.modulo_const_ff_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(modulo_const_ff_sptr self) -> bool"""
        return _iio_swig.modulo_const_ff_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(modulo_const_ff_sptr self, int m)"""
        return _iio_swig.modulo_const_ff_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(modulo_const_ff_sptr self) -> int"""
        return _iio_swig.modulo_const_ff_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(modulo_const_ff_sptr self, int i) -> long"""
        return _iio_swig.modulo_const_ff_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(modulo_const_ff_sptr self, long max_output_buffer)
        set_max_output_buffer(modulo_const_ff_sptr self, int port, long max_output_buffer)
        """
        return _iio_swig.modulo_const_ff_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(modulo_const_ff_sptr self, int i) -> long"""
        return _iio_swig.modulo_const_ff_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(modulo_const_ff_sptr self, long min_output_buffer)
        set_min_output_buffer(modulo_const_ff_sptr self, int port, long min_output_buffer)
        """
        return _iio_swig.modulo_const_ff_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(modulo_const_ff_sptr self) -> float"""
        return _iio_swig.modulo_const_ff_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(modulo_const_ff_sptr self) -> float"""
        return _iio_swig.modulo_const_ff_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(modulo_const_ff_sptr self) -> float"""
        return _iio_swig.modulo_const_ff_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(modulo_const_ff_sptr self) -> float"""
        return _iio_swig.modulo_const_ff_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(modulo_const_ff_sptr self) -> float"""
        return _iio_swig.modulo_const_ff_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(modulo_const_ff_sptr self) -> float"""
        return _iio_swig.modulo_const_ff_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(modulo_const_ff_sptr self, int which) -> float
        pc_input_buffers_full(modulo_const_ff_sptr self) -> pmt_vector_float
        """
        return _iio_swig.modulo_const_ff_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(modulo_const_ff_sptr self, int which) -> float
        pc_input_buffers_full_avg(modulo_const_ff_sptr self) -> pmt_vector_float
        """
        return _iio_swig.modulo_const_ff_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(modulo_const_ff_sptr self, int which) -> float
        pc_input_buffers_full_var(modulo_const_ff_sptr self) -> pmt_vector_float
        """
        return _iio_swig.modulo_const_ff_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(modulo_const_ff_sptr self, int which) -> float
        pc_output_buffers_full(modulo_const_ff_sptr self) -> pmt_vector_float
        """
        return _iio_swig.modulo_const_ff_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(modulo_const_ff_sptr self, int which) -> float
        pc_output_buffers_full_avg(modulo_const_ff_sptr self) -> pmt_vector_float
        """
        return _iio_swig.modulo_const_ff_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(modulo_const_ff_sptr self, int which) -> float
        pc_output_buffers_full_var(modulo_const_ff_sptr self) -> pmt_vector_float
        """
        return _iio_swig.modulo_const_ff_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(modulo_const_ff_sptr self) -> float"""
        return _iio_swig.modulo_const_ff_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(modulo_const_ff_sptr self) -> float"""
        return _iio_swig.modulo_const_ff_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(modulo_const_ff_sptr self) -> float"""
        return _iio_swig.modulo_const_ff_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(modulo_const_ff_sptr self) -> float"""
        return _iio_swig.modulo_const_ff_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(modulo_const_ff_sptr self) -> float"""
        return _iio_swig.modulo_const_ff_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(modulo_const_ff_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _iio_swig.modulo_const_ff_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(modulo_const_ff_sptr self)"""
        return _iio_swig.modulo_const_ff_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(modulo_const_ff_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _iio_swig.modulo_const_ff_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(modulo_const_ff_sptr self) -> int"""
        return _iio_swig.modulo_const_ff_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(modulo_const_ff_sptr self) -> int"""
        return _iio_swig.modulo_const_ff_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(modulo_const_ff_sptr self, int priority) -> int"""
        return _iio_swig.modulo_const_ff_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(modulo_const_ff_sptr self) -> std::string"""
        return _iio_swig.modulo_const_ff_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(modulo_const_ff_sptr self) -> std::string"""
        return _iio_swig.modulo_const_ff_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(modulo_const_ff_sptr self) -> io_signature_sptr"""
        return _iio_swig.modulo_const_ff_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(modulo_const_ff_sptr self) -> io_signature_sptr"""
        return _iio_swig.modulo_const_ff_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(modulo_const_ff_sptr self) -> long"""
        return _iio_swig.modulo_const_ff_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(modulo_const_ff_sptr self) -> basic_block_sptr"""
        return _iio_swig.modulo_const_ff_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(modulo_const_ff_sptr self, int ninputs, int noutputs) -> bool"""
        return _iio_swig.modulo_const_ff_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(modulo_const_ff_sptr self) -> std::string"""
        return _iio_swig.modulo_const_ff_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(modulo_const_ff_sptr self, std::string name)"""
        return _iio_swig.modulo_const_ff_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(modulo_const_ff_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _iio_swig.modulo_const_ff_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(modulo_const_ff_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.modulo_const_ff_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(modulo_const_ff_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.modulo_const_ff_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(modulo_const_ff_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _iio_swig.modulo_const_ff_sptr_message_subscribers(self, which_port)

# Register modulo_const_ff_sptr in _iio_swig:
_iio_swig.modulo_const_ff_sptr_swigregister(modulo_const_ff_sptr)

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

class attr_sink_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::iio::attr_sink > class."""

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

    def __init__(self, *args):
        r"""
        __init__(attr_sink_sptr self) -> attr_sink_sptr
        __init__(attr_sink_sptr self, attr_sink p) -> attr_sink_sptr
        """
        _iio_swig.attr_sink_sptr_swiginit(self, _iio_swig.new_attr_sink_sptr(*args))

    def __deref__(self) -> "gr::iio::attr_sink *":
        r"""__deref__(attr_sink_sptr self) -> attr_sink"""
        return _iio_swig.attr_sink_sptr___deref__(self)
    __swig_destroy__ = _iio_swig.delete_attr_sink_sptr

    def make(self, uri: "std::string const &", device: "std::string const &", channel: "std::string const &", type: "int", output: "bool", required_enable: "bool") -> "gr::iio::attr_sink::sptr":
        r"""make(attr_sink_sptr self, std::string const & uri, std::string const & device, std::string const & channel, int type, bool output, bool required_enable) -> attr_sink_sptr"""
        return _iio_swig.attr_sink_sptr_make(self, uri, device, channel, type, output, required_enable)

    def history(self) -> "unsigned int":
        r"""history(attr_sink_sptr self) -> unsigned int"""
        return _iio_swig.attr_sink_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(attr_sink_sptr self, int which, int delay)
        declare_sample_delay(attr_sink_sptr self, unsigned int delay)
        """
        return _iio_swig.attr_sink_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(attr_sink_sptr self, int which) -> unsigned int"""
        return _iio_swig.attr_sink_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(attr_sink_sptr self, int multiple)"""
        return _iio_swig.attr_sink_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(attr_sink_sptr self) -> int"""
        return _iio_swig.attr_sink_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(attr_sink_sptr self) -> double"""
        return _iio_swig.attr_sink_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(attr_sink_sptr self) -> uint64_t"""
        return _iio_swig.attr_sink_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(attr_sink_sptr self) -> uint64_t"""
        return _iio_swig.attr_sink_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(attr_sink_sptr self) -> bool"""
        return _iio_swig.attr_sink_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(attr_sink_sptr self) -> bool"""
        return _iio_swig.attr_sink_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(attr_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _iio_swig.attr_sink_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(attr_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _iio_swig.attr_sink_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(attr_sink_sptr self, std::string level)"""
        return _iio_swig.attr_sink_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(attr_sink_sptr self) -> std::string"""
        return _iio_swig.attr_sink_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(attr_sink_sptr self) -> int"""
        return _iio_swig.attr_sink_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(attr_sink_sptr self, int m)"""
        return _iio_swig.attr_sink_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(attr_sink_sptr self)"""
        return _iio_swig.attr_sink_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(attr_sink_sptr self) -> bool"""
        return _iio_swig.attr_sink_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(attr_sink_sptr self, int m)"""
        return _iio_swig.attr_sink_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(attr_sink_sptr self) -> int"""
        return _iio_swig.attr_sink_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(attr_sink_sptr self, int i) -> long"""
        return _iio_swig.attr_sink_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(attr_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(attr_sink_sptr self, int port, long max_output_buffer)
        """
        return _iio_swig.attr_sink_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(attr_sink_sptr self, int i) -> long"""
        return _iio_swig.attr_sink_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(attr_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(attr_sink_sptr self, int port, long min_output_buffer)
        """
        return _iio_swig.attr_sink_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(attr_sink_sptr self) -> float"""
        return _iio_swig.attr_sink_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(attr_sink_sptr self) -> float"""
        return _iio_swig.attr_sink_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(attr_sink_sptr self) -> float"""
        return _iio_swig.attr_sink_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(attr_sink_sptr self) -> float"""
        return _iio_swig.attr_sink_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(attr_sink_sptr self) -> float"""
        return _iio_swig.attr_sink_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(attr_sink_sptr self) -> float"""
        return _iio_swig.attr_sink_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(attr_sink_sptr self, int which) -> float
        pc_input_buffers_full(attr_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.attr_sink_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(attr_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(attr_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.attr_sink_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(attr_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(attr_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.attr_sink_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(attr_sink_sptr self, int which) -> float
        pc_output_buffers_full(attr_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.attr_sink_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(attr_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(attr_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.attr_sink_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(attr_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(attr_sink_sptr self) -> pmt_vector_float
        """
        return _iio_swig.attr_sink_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(attr_sink_sptr self) -> float"""
        return _iio_swig.attr_sink_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(attr_sink_sptr self) -> float"""
        return _iio_swig.attr_sink_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(attr_sink_sptr self) -> float"""
        return _iio_swig.attr_sink_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(attr_sink_sptr self) -> float"""
        return _iio_swig.attr_sink_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(attr_sink_sptr self) -> float"""
        return _iio_swig.attr_sink_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(attr_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _iio_swig.attr_sink_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(attr_sink_sptr self)"""
        return _iio_swig.attr_sink_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(attr_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _iio_swig.attr_sink_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(attr_sink_sptr self) -> int"""
        return _iio_swig.attr_sink_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(attr_sink_sptr self) -> int"""
        return _iio_swig.attr_sink_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(attr_sink_sptr self, int priority) -> int"""
        return _iio_swig.attr_sink_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(attr_sink_sptr self) -> std::string"""
        return _iio_swig.attr_sink_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(attr_sink_sptr self) -> std::string"""
        return _iio_swig.attr_sink_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(attr_sink_sptr self) -> io_signature_sptr"""
        return _iio_swig.attr_sink_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(attr_sink_sptr self) -> io_signature_sptr"""
        return _iio_swig.attr_sink_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(attr_sink_sptr self) -> long"""
        return _iio_swig.attr_sink_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(attr_sink_sptr self) -> basic_block_sptr"""
        return _iio_swig.attr_sink_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(attr_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _iio_swig.attr_sink_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(attr_sink_sptr self) -> std::string"""
        return _iio_swig.attr_sink_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(attr_sink_sptr self, std::string name)"""
        return _iio_swig.attr_sink_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(attr_sink_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _iio_swig.attr_sink_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(attr_sink_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.attr_sink_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(attr_sink_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.attr_sink_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(attr_sink_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _iio_swig.attr_sink_sptr_message_subscribers(self, which_port)

# Register attr_sink_sptr in _iio_swig:
_iio_swig.attr_sink_sptr_swigregister(attr_sink_sptr)

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

class attr_source_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::iio::attr_source > class."""

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

    def __init__(self, *args):
        r"""
        __init__(attr_source_sptr self) -> attr_source_sptr
        __init__(attr_source_sptr self, attr_source p) -> attr_source_sptr
        """
        _iio_swig.attr_source_sptr_swiginit(self, _iio_swig.new_attr_source_sptr(*args))

    def __deref__(self) -> "gr::iio::attr_source *":
        r"""__deref__(attr_source_sptr self) -> attr_source"""
        return _iio_swig.attr_source_sptr___deref__(self)
    __swig_destroy__ = _iio_swig.delete_attr_source_sptr

    def make(self, uri: "std::string const &", device: "std::string const &", channel: "std::string const &", attribute: "std::string const &", update_interval_ms: "int", samples_per_update: "int", data_type: "int", attr_type: "int", output: "bool", address: "uint32_t", required_enable: "bool") -> "gr::iio::attr_source::sptr":
        r"""make(attr_source_sptr self, std::string const & uri, std::string const & device, std::string const & channel, std::string const & attribute, int update_interval_ms, int samples_per_update, int data_type, int attr_type, bool output, uint32_t address, bool required_enable) -> attr_source_sptr"""
        return _iio_swig.attr_source_sptr_make(self, uri, device, channel, attribute, update_interval_ms, samples_per_update, data_type, attr_type, output, address, required_enable)

    def history(self) -> "unsigned int":
        r"""history(attr_source_sptr self) -> unsigned int"""
        return _iio_swig.attr_source_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(attr_source_sptr self, int which, int delay)
        declare_sample_delay(attr_source_sptr self, unsigned int delay)
        """
        return _iio_swig.attr_source_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(attr_source_sptr self, int which) -> unsigned int"""
        return _iio_swig.attr_source_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(attr_source_sptr self, int multiple)"""
        return _iio_swig.attr_source_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(attr_source_sptr self) -> int"""
        return _iio_swig.attr_source_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(attr_source_sptr self) -> double"""
        return _iio_swig.attr_source_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(attr_source_sptr self) -> uint64_t"""
        return _iio_swig.attr_source_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(attr_source_sptr self) -> uint64_t"""
        return _iio_swig.attr_source_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(attr_source_sptr self) -> bool"""
        return _iio_swig.attr_source_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(attr_source_sptr self) -> bool"""
        return _iio_swig.attr_source_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(attr_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _iio_swig.attr_source_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(attr_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _iio_swig.attr_source_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(attr_source_sptr self, std::string level)"""
        return _iio_swig.attr_source_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(attr_source_sptr self) -> std::string"""
        return _iio_swig.attr_source_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(attr_source_sptr self) -> int"""
        return _iio_swig.attr_source_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(attr_source_sptr self, int m)"""
        return _iio_swig.attr_source_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(attr_source_sptr self)"""
        return _iio_swig.attr_source_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(attr_source_sptr self) -> bool"""
        return _iio_swig.attr_source_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(attr_source_sptr self, int m)"""
        return _iio_swig.attr_source_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(attr_source_sptr self) -> int"""
        return _iio_swig.attr_source_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(attr_source_sptr self, int i) -> long"""
        return _iio_swig.attr_source_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(attr_source_sptr self, long max_output_buffer)
        set_max_output_buffer(attr_source_sptr self, int port, long max_output_buffer)
        """
        return _iio_swig.attr_source_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(attr_source_sptr self, int i) -> long"""
        return _iio_swig.attr_source_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(attr_source_sptr self, long min_output_buffer)
        set_min_output_buffer(attr_source_sptr self, int port, long min_output_buffer)
        """
        return _iio_swig.attr_source_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(attr_source_sptr self) -> float"""
        return _iio_swig.attr_source_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(attr_source_sptr self) -> float"""
        return _iio_swig.attr_source_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(attr_source_sptr self) -> float"""
        return _iio_swig.attr_source_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(attr_source_sptr self) -> float"""
        return _iio_swig.attr_source_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(attr_source_sptr self) -> float"""
        return _iio_swig.attr_source_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(attr_source_sptr self) -> float"""
        return _iio_swig.attr_source_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(attr_source_sptr self, int which) -> float
        pc_input_buffers_full(attr_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.attr_source_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(attr_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(attr_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.attr_source_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(attr_source_sptr self, int which) -> float
        pc_input_buffers_full_var(attr_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.attr_source_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(attr_source_sptr self, int which) -> float
        pc_output_buffers_full(attr_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.attr_source_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(attr_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(attr_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.attr_source_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(attr_source_sptr self, int which) -> float
        pc_output_buffers_full_var(attr_source_sptr self) -> pmt_vector_float
        """
        return _iio_swig.attr_source_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(attr_source_sptr self) -> float"""
        return _iio_swig.attr_source_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(attr_source_sptr self) -> float"""
        return _iio_swig.attr_source_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(attr_source_sptr self) -> float"""
        return _iio_swig.attr_source_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(attr_source_sptr self) -> float"""
        return _iio_swig.attr_source_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(attr_source_sptr self) -> float"""
        return _iio_swig.attr_source_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(attr_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _iio_swig.attr_source_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(attr_source_sptr self)"""
        return _iio_swig.attr_source_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(attr_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _iio_swig.attr_source_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(attr_source_sptr self) -> int"""
        return _iio_swig.attr_source_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(attr_source_sptr self) -> int"""
        return _iio_swig.attr_source_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(attr_source_sptr self, int priority) -> int"""
        return _iio_swig.attr_source_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(attr_source_sptr self) -> std::string"""
        return _iio_swig.attr_source_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(attr_source_sptr self) -> std::string"""
        return _iio_swig.attr_source_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(attr_source_sptr self) -> io_signature_sptr"""
        return _iio_swig.attr_source_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(attr_source_sptr self) -> io_signature_sptr"""
        return _iio_swig.attr_source_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(attr_source_sptr self) -> long"""
        return _iio_swig.attr_source_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(attr_source_sptr self) -> basic_block_sptr"""
        return _iio_swig.attr_source_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(attr_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _iio_swig.attr_source_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(attr_source_sptr self) -> std::string"""
        return _iio_swig.attr_source_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(attr_source_sptr self, std::string name)"""
        return _iio_swig.attr_source_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(attr_source_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _iio_swig.attr_source_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(attr_source_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.attr_source_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(attr_source_sptr self) -> swig_pmt_ptr"""
        return _iio_swig.attr_source_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(attr_source_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _iio_swig.attr_source_sptr_message_subscribers(self, which_port)

# Register attr_source_sptr in _iio_swig:
_iio_swig.attr_source_sptr_swigregister(attr_source_sptr)

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


