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

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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


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

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

    def value(self):
        return _uhd_swig.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _uhd_swig.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _uhd_swig.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _uhd_swig.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _uhd_swig.SwigPyIterator_equal(self, x)

    def copy(self):
        return _uhd_swig.SwigPyIterator_copy(self)

    def next(self):
        return _uhd_swig.SwigPyIterator_next(self)

    def __next__(self):
        return _uhd_swig.SwigPyIterator___next__(self)

    def previous(self):
        return _uhd_swig.SwigPyIterator_previous(self)

    def advance(self, n):
        return _uhd_swig.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _uhd_swig.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _uhd_swig.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _uhd_swig.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _uhd_swig.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _uhd_swig.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _uhd_swig.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _uhd_swig.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)


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

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

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

def high_res_timer_epoch():
    """high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _uhd_swig.high_res_timer_epoch()
class usrp_block(object):
    """Proxy of C++ gr::uhd::usrp_block class."""

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

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

    def set_subdev_spec(self, spec, mboard=0):
        """set_subdev_spec(usrp_block self, std::string const & spec, size_t mboard=0)"""
        return _uhd_swig.usrp_block_set_subdev_spec(self, spec, mboard)


    def get_subdev_spec(self, mboard=0):
        """get_subdev_spec(usrp_block self, size_t mboard=0) -> std::string"""
        return _uhd_swig.usrp_block_get_subdev_spec(self, mboard)


    def get_num_mboards(self):
        """get_num_mboards(usrp_block self) -> size_t"""
        return _uhd_swig.usrp_block_get_num_mboards(self)


    def set_samp_rate(self, rate):
        """set_samp_rate(usrp_block self, double rate)"""
        return _uhd_swig.usrp_block_set_samp_rate(self, rate)


    def get_samp_rate(self):
        """get_samp_rate(usrp_block self) -> double"""
        return _uhd_swig.usrp_block_get_samp_rate(self)


    def get_samp_rates(self):
        """get_samp_rates(usrp_block self) -> meta_range_t"""
        return _uhd_swig.usrp_block_get_samp_rates(self)


    def set_center_freq(self, *args):
        """
        set_center_freq(usrp_block self, tune_request_t tune_request, size_t chan=0) -> tune_result_t
        set_center_freq(usrp_block self, double freq, size_t chan=0) -> tune_result_t
        """
        return _uhd_swig.usrp_block_set_center_freq(self, *args)


    def get_center_freq(self, chan=0):
        """get_center_freq(usrp_block self, size_t chan=0) -> double"""
        return _uhd_swig.usrp_block_get_center_freq(self, chan)


    def get_freq_range(self, chan=0):
        """get_freq_range(usrp_block self, size_t chan=0) -> meta_range_t"""
        return _uhd_swig.usrp_block_get_freq_range(self, chan)


    def set_gain(self, *args):
        """
        set_gain(usrp_block self, double gain, size_t chan=0)
        set_gain(usrp_block self, double gain, std::string const & name, size_t chan=0)
        """
        return _uhd_swig.usrp_block_set_gain(self, *args)


    def set_normalized_gain(self, norm_gain, chan=0):
        """set_normalized_gain(usrp_block self, double norm_gain, size_t chan=0)"""
        return _uhd_swig.usrp_block_set_normalized_gain(self, norm_gain, chan)


    def get_gain(self, *args):
        """
        get_gain(usrp_block self, size_t chan=0) -> double
        get_gain(usrp_block self, std::string const & name, size_t chan=0) -> double
        """
        return _uhd_swig.usrp_block_get_gain(self, *args)


    def get_normalized_gain(self, chan=0):
        """get_normalized_gain(usrp_block self, size_t chan=0) -> double"""
        return _uhd_swig.usrp_block_get_normalized_gain(self, chan)


    def get_gain_names(self, chan=0):
        """get_gain_names(usrp_block self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_block_get_gain_names(self, chan)


    def get_gain_range(self, *args):
        """
        get_gain_range(usrp_block self, size_t chan=0) -> meta_range_t
        get_gain_range(usrp_block self, std::string const & name, size_t chan=0) -> meta_range_t
        """
        return _uhd_swig.usrp_block_get_gain_range(self, *args)


    def set_antenna(self, ant, chan=0):
        """set_antenna(usrp_block self, std::string const & ant, size_t chan=0)"""
        return _uhd_swig.usrp_block_set_antenna(self, ant, chan)


    def get_antenna(self, chan=0):
        """get_antenna(usrp_block self, size_t chan=0) -> std::string"""
        return _uhd_swig.usrp_block_get_antenna(self, chan)


    def get_antennas(self, chan=0):
        """get_antennas(usrp_block self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_block_get_antennas(self, chan)


    def set_bandwidth(self, bandwidth, chan=0):
        """set_bandwidth(usrp_block self, double bandwidth, size_t chan=0)"""
        return _uhd_swig.usrp_block_set_bandwidth(self, bandwidth, chan)


    def get_bandwidth(self, chan=0):
        """get_bandwidth(usrp_block self, size_t chan=0) -> double"""
        return _uhd_swig.usrp_block_get_bandwidth(self, chan)


    def get_bandwidth_range(self, chan=0):
        """get_bandwidth_range(usrp_block self, size_t chan=0) -> meta_range_t"""
        return _uhd_swig.usrp_block_get_bandwidth_range(self, chan)


    def get_sensor(self, name, chan=0):
        """get_sensor(usrp_block self, std::string const & name, size_t chan=0) -> sensor_value_t"""
        return _uhd_swig.usrp_block_get_sensor(self, name, chan)


    def get_sensor_names(self, chan=0):
        """get_sensor_names(usrp_block self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_block_get_sensor_names(self, chan)


    def get_dboard_sensor(self, name, chan=0):
        """get_dboard_sensor(usrp_block self, std::string const & name, size_t chan=0) -> sensor_value_t"""
        return _uhd_swig.usrp_block_get_dboard_sensor(self, name, chan)


    def get_dboard_sensor_names(self, chan=0):
        """get_dboard_sensor_names(usrp_block self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_block_get_dboard_sensor_names(self, chan)


    def get_mboard_sensor(self, name, mboard=0):
        """get_mboard_sensor(usrp_block self, std::string const & name, size_t mboard=0) -> sensor_value_t"""
        return _uhd_swig.usrp_block_get_mboard_sensor(self, name, mboard)


    def get_mboard_sensor_names(self, mboard=0):
        """get_mboard_sensor_names(usrp_block self, size_t mboard=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_block_get_mboard_sensor_names(self, mboard)


    def get_time_source(self, mboard):
        """get_time_source(usrp_block self, size_t const mboard) -> std::string"""
        return _uhd_swig.usrp_block_get_time_source(self, mboard)


    def get_time_sources(self, mboard):
        """get_time_sources(usrp_block self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_block_get_time_sources(self, mboard)


    def set_clock_source(self, source, mboard=0):
        """set_clock_source(usrp_block self, std::string const & source, size_t const mboard=0)"""
        return _uhd_swig.usrp_block_set_clock_source(self, source, mboard)


    def get_clock_source(self, mboard):
        """get_clock_source(usrp_block self, size_t const mboard) -> std::string"""
        return _uhd_swig.usrp_block_get_clock_source(self, mboard)


    def get_clock_sources(self, mboard):
        """get_clock_sources(usrp_block self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_block_get_clock_sources(self, mboard)


    def get_clock_rate(self, mboard=0):
        """get_clock_rate(usrp_block self, size_t mboard=0) -> double"""
        return _uhd_swig.usrp_block_get_clock_rate(self, mboard)


    def set_clock_rate(self, rate, mboard=0):
        """set_clock_rate(usrp_block self, double rate, size_t mboard=0)"""
        return _uhd_swig.usrp_block_set_clock_rate(self, rate, mboard)


    def get_time_now(self, mboard=0):
        """get_time_now(usrp_block self, size_t mboard=0) -> time_spec_t"""
        return _uhd_swig.usrp_block_get_time_now(self, mboard)


    def get_time_last_pps(self, mboard=0):
        """get_time_last_pps(usrp_block self, size_t mboard=0) -> time_spec_t"""
        return _uhd_swig.usrp_block_get_time_last_pps(self, mboard)


    def set_time_now(self, time_spec, mboard=0):
        """set_time_now(usrp_block self, time_spec_t time_spec, size_t mboard=0)"""
        return _uhd_swig.usrp_block_set_time_now(self, time_spec, mboard)


    def set_time_next_pps(self, time_spec):
        """set_time_next_pps(usrp_block self, time_spec_t time_spec)"""
        return _uhd_swig.usrp_block_set_time_next_pps(self, time_spec)


    def set_time_unknown_pps(self, time_spec):
        """set_time_unknown_pps(usrp_block self, time_spec_t time_spec)"""
        return _uhd_swig.usrp_block_set_time_unknown_pps(self, time_spec)


    def set_command_time(self, time_spec, mboard=0):
        """set_command_time(usrp_block self, time_spec_t time_spec, size_t mboard=0)"""
        return _uhd_swig.usrp_block_set_command_time(self, time_spec, mboard)


    def clear_command_time(self, mboard=0):
        """clear_command_time(usrp_block self, size_t mboard=0)"""
        return _uhd_swig.usrp_block_clear_command_time(self, mboard)


    def get_dboard_iface(self, chan=0):
        """get_dboard_iface(usrp_block self, size_t chan=0) -> dboard_iface_sptr"""
        return _uhd_swig.usrp_block_get_dboard_iface(self, chan)


    def get_device(self):
        """get_device(usrp_block self) -> ::uhd::usrp::multi_usrp::sptr"""
        return _uhd_swig.usrp_block_get_device(self)


    def set_user_register(self, addr, data, mboard=0):
        """set_user_register(usrp_block self, uint8_t const addr, uint32_t const data, size_t mboard=0)"""
        return _uhd_swig.usrp_block_set_user_register(self, addr, data, mboard)


    def set_clock_config(self, clock_config, mboard=0):
        """set_clock_config(usrp_block self, clock_config_t clock_config, size_t mboard=0)"""
        return _uhd_swig.usrp_block_set_clock_config(self, clock_config, mboard)


    def set_time_source(self, source, mboard=0):
        """set_time_source(usrp_block self, std::string const & source, size_t const mboard=0)"""
        return _uhd_swig.usrp_block_set_time_source(self, source, mboard)


    def set_stream_args(self, stream_args):
        """set_stream_args(usrp_block self, stream_args_t stream_args)"""
        return _uhd_swig.usrp_block_set_stream_args(self, stream_args)


    def get_gpio_banks(self, mboard):
        """get_gpio_banks(usrp_block self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_block_get_gpio_banks(self, mboard)


    def set_gpio_attr(self, *args, **kwargs):
        """set_gpio_attr(usrp_block self, std::string const & bank, std::string const & attr, boost::uint32_t const value, boost::uint32_t const mask, size_t const mboard)"""
        return _uhd_swig.usrp_block_set_gpio_attr(self, *args, **kwargs)


    def get_gpio_attr(self, *args, **kwargs):
        """get_gpio_attr(usrp_block self, std::string const & bank, std::string const & attr, size_t const mboard) -> boost::uint32_t"""
        return _uhd_swig.usrp_block_get_gpio_attr(self, *args, **kwargs)

    __swig_destroy__ = _uhd_swig.delete_usrp_block
    __del__ = lambda self: None
usrp_block_swigregister = _uhd_swig.usrp_block_swigregister
usrp_block_swigregister(usrp_block)

class uhd_string_vector_t(object):
    """Proxy of C++ std::vector<(std::string)> class."""

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

    def iterator(self):
        """iterator(uhd_string_vector_t self) -> SwigPyIterator"""
        return _uhd_swig.uhd_string_vector_t_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(uhd_string_vector_t self) -> bool"""
        return _uhd_swig.uhd_string_vector_t___nonzero__(self)


    def __bool__(self):
        """__bool__(uhd_string_vector_t self) -> bool"""
        return _uhd_swig.uhd_string_vector_t___bool__(self)


    def __len__(self):
        """__len__(uhd_string_vector_t self) -> std::vector< std::string >::size_type"""
        return _uhd_swig.uhd_string_vector_t___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(uhd_string_vector_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> std::vector< std::string,std::allocator< std::string > > *"""
        return _uhd_swig.uhd_string_vector_t___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(uhd_string_vector_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
        __setslice__(uhd_string_vector_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, std::vector< std::string,std::allocator< std::string > > const & v)
        """
        return _uhd_swig.uhd_string_vector_t___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(uhd_string_vector_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _uhd_swig.uhd_string_vector_t___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(uhd_string_vector_t self, std::vector< std::string >::difference_type i)
        __delitem__(uhd_string_vector_t self, PySliceObject * slice)
        """
        return _uhd_swig.uhd_string_vector_t___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(uhd_string_vector_t self, PySliceObject * slice) -> std::vector< std::string,std::allocator< std::string > >
        __getitem__(uhd_string_vector_t self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
        """
        return _uhd_swig.uhd_string_vector_t___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(uhd_string_vector_t self, PySliceObject * slice, std::vector< std::string,std::allocator< std::string > > const & v)
        __setitem__(uhd_string_vector_t self, PySliceObject * slice)
        __setitem__(uhd_string_vector_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
        """
        return _uhd_swig.uhd_string_vector_t___setitem__(self, *args)


    def pop(self):
        """pop(uhd_string_vector_t self) -> std::vector< std::string >::value_type"""
        return _uhd_swig.uhd_string_vector_t_pop(self)


    def append(self, x):
        """append(uhd_string_vector_t self, std::vector< std::string >::value_type const & x)"""
        return _uhd_swig.uhd_string_vector_t_append(self, x)


    def empty(self):
        """empty(uhd_string_vector_t self) -> bool"""
        return _uhd_swig.uhd_string_vector_t_empty(self)


    def size(self):
        """size(uhd_string_vector_t self) -> std::vector< std::string >::size_type"""
        return _uhd_swig.uhd_string_vector_t_size(self)


    def swap(self, v):
        """swap(uhd_string_vector_t self, std::vector< std::string > & v)"""
        return _uhd_swig.uhd_string_vector_t_swap(self, v)


    def begin(self):
        """begin(uhd_string_vector_t self) -> std::vector< std::string >::iterator"""
        return _uhd_swig.uhd_string_vector_t_begin(self)


    def end(self):
        """end(uhd_string_vector_t self) -> std::vector< std::string >::iterator"""
        return _uhd_swig.uhd_string_vector_t_end(self)


    def rbegin(self):
        """rbegin(uhd_string_vector_t self) -> std::vector< std::string >::reverse_iterator"""
        return _uhd_swig.uhd_string_vector_t_rbegin(self)


    def rend(self):
        """rend(uhd_string_vector_t self) -> std::vector< std::string >::reverse_iterator"""
        return _uhd_swig.uhd_string_vector_t_rend(self)


    def clear(self):
        """clear(uhd_string_vector_t self)"""
        return _uhd_swig.uhd_string_vector_t_clear(self)


    def get_allocator(self):
        """get_allocator(uhd_string_vector_t self) -> std::vector< std::string >::allocator_type"""
        return _uhd_swig.uhd_string_vector_t_get_allocator(self)


    def pop_back(self):
        """pop_back(uhd_string_vector_t self)"""
        return _uhd_swig.uhd_string_vector_t_pop_back(self)


    def erase(self, *args):
        """
        erase(uhd_string_vector_t self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
        erase(uhd_string_vector_t self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
        """
        return _uhd_swig.uhd_string_vector_t_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::string)> self) -> uhd_string_vector_t
        __init__(std::vector<(std::string)> self, std::vector< std::string > const & arg2) -> uhd_string_vector_t
        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size) -> uhd_string_vector_t
        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> uhd_string_vector_t
        """
        this = _uhd_swig.new_uhd_string_vector_t(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(uhd_string_vector_t self, std::vector< std::string >::value_type const & x)"""
        return _uhd_swig.uhd_string_vector_t_push_back(self, x)


    def front(self):
        """front(uhd_string_vector_t self) -> std::vector< std::string >::value_type const &"""
        return _uhd_swig.uhd_string_vector_t_front(self)


    def back(self):
        """back(uhd_string_vector_t self) -> std::vector< std::string >::value_type const &"""
        return _uhd_swig.uhd_string_vector_t_back(self)


    def assign(self, n, x):
        """assign(uhd_string_vector_t self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
        return _uhd_swig.uhd_string_vector_t_assign(self, n, x)


    def resize(self, *args):
        """
        resize(uhd_string_vector_t self, std::vector< std::string >::size_type new_size)
        resize(uhd_string_vector_t self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)
        """
        return _uhd_swig.uhd_string_vector_t_resize(self, *args)


    def insert(self, *args):
        """
        insert(uhd_string_vector_t self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator
        insert(uhd_string_vector_t self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)
        """
        return _uhd_swig.uhd_string_vector_t_insert(self, *args)


    def reserve(self, n):
        """reserve(uhd_string_vector_t self, std::vector< std::string >::size_type n)"""
        return _uhd_swig.uhd_string_vector_t_reserve(self, n)


    def capacity(self):
        """capacity(uhd_string_vector_t self) -> std::vector< std::string >::size_type"""
        return _uhd_swig.uhd_string_vector_t_capacity(self)

    __swig_destroy__ = _uhd_swig.delete_uhd_string_vector_t
    __del__ = lambda self: None
uhd_string_vector_t_swigregister = _uhd_swig.uhd_string_vector_t_swigregister
uhd_string_vector_t_swigregister(uhd_string_vector_t)

class uhd_size_vector_t(object):
    """Proxy of C++ std::vector<(size_t)> class."""

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

    def iterator(self):
        """iterator(uhd_size_vector_t self) -> SwigPyIterator"""
        return _uhd_swig.uhd_size_vector_t_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(uhd_size_vector_t self) -> bool"""
        return _uhd_swig.uhd_size_vector_t___nonzero__(self)


    def __bool__(self):
        """__bool__(uhd_size_vector_t self) -> bool"""
        return _uhd_swig.uhd_size_vector_t___bool__(self)


    def __len__(self):
        """__len__(uhd_size_vector_t self) -> std::vector< size_t >::size_type"""
        return _uhd_swig.uhd_size_vector_t___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(uhd_size_vector_t self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j) -> gr_vsize_t"""
        return _uhd_swig.uhd_size_vector_t___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(uhd_size_vector_t self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j)
        __setslice__(uhd_size_vector_t self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j, gr_vsize_t v)
        """
        return _uhd_swig.uhd_size_vector_t___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(uhd_size_vector_t self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j)"""
        return _uhd_swig.uhd_size_vector_t___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(uhd_size_vector_t self, std::vector< size_t >::difference_type i)
        __delitem__(uhd_size_vector_t self, PySliceObject * slice)
        """
        return _uhd_swig.uhd_size_vector_t___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(uhd_size_vector_t self, PySliceObject * slice) -> gr_vsize_t
        __getitem__(uhd_size_vector_t self, std::vector< size_t >::difference_type i) -> std::vector< size_t >::value_type const &
        """
        return _uhd_swig.uhd_size_vector_t___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(uhd_size_vector_t self, PySliceObject * slice, gr_vsize_t v)
        __setitem__(uhd_size_vector_t self, PySliceObject * slice)
        __setitem__(uhd_size_vector_t self, std::vector< size_t >::difference_type i, std::vector< size_t >::value_type const & x)
        """
        return _uhd_swig.uhd_size_vector_t___setitem__(self, *args)


    def pop(self):
        """pop(uhd_size_vector_t self) -> std::vector< size_t >::value_type"""
        return _uhd_swig.uhd_size_vector_t_pop(self)


    def append(self, x):
        """append(uhd_size_vector_t self, std::vector< size_t >::value_type const & x)"""
        return _uhd_swig.uhd_size_vector_t_append(self, x)


    def empty(self):
        """empty(uhd_size_vector_t self) -> bool"""
        return _uhd_swig.uhd_size_vector_t_empty(self)


    def size(self):
        """size(uhd_size_vector_t self) -> std::vector< size_t >::size_type"""
        return _uhd_swig.uhd_size_vector_t_size(self)


    def swap(self, v):
        """swap(uhd_size_vector_t self, gr_vsize_t v)"""
        return _uhd_swig.uhd_size_vector_t_swap(self, v)


    def begin(self):
        """begin(uhd_size_vector_t self) -> std::vector< size_t >::iterator"""
        return _uhd_swig.uhd_size_vector_t_begin(self)


    def end(self):
        """end(uhd_size_vector_t self) -> std::vector< size_t >::iterator"""
        return _uhd_swig.uhd_size_vector_t_end(self)


    def rbegin(self):
        """rbegin(uhd_size_vector_t self) -> std::vector< size_t >::reverse_iterator"""
        return _uhd_swig.uhd_size_vector_t_rbegin(self)


    def rend(self):
        """rend(uhd_size_vector_t self) -> std::vector< size_t >::reverse_iterator"""
        return _uhd_swig.uhd_size_vector_t_rend(self)


    def clear(self):
        """clear(uhd_size_vector_t self)"""
        return _uhd_swig.uhd_size_vector_t_clear(self)


    def get_allocator(self):
        """get_allocator(uhd_size_vector_t self) -> std::vector< size_t >::allocator_type"""
        return _uhd_swig.uhd_size_vector_t_get_allocator(self)


    def pop_back(self):
        """pop_back(uhd_size_vector_t self)"""
        return _uhd_swig.uhd_size_vector_t_pop_back(self)


    def erase(self, *args):
        """
        erase(uhd_size_vector_t self, std::vector< size_t >::iterator pos) -> std::vector< size_t >::iterator
        erase(uhd_size_vector_t self, std::vector< size_t >::iterator first, std::vector< size_t >::iterator last) -> std::vector< size_t >::iterator
        """
        return _uhd_swig.uhd_size_vector_t_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(size_t)> self) -> uhd_size_vector_t
        __init__(std::vector<(size_t)> self, gr_vsize_t arg2) -> uhd_size_vector_t
        __init__(std::vector<(size_t)> self, std::vector< size_t >::size_type size) -> uhd_size_vector_t
        __init__(std::vector<(size_t)> self, std::vector< size_t >::size_type size, std::vector< size_t >::value_type const & value) -> uhd_size_vector_t
        """
        this = _uhd_swig.new_uhd_size_vector_t(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(uhd_size_vector_t self, std::vector< size_t >::value_type const & x)"""
        return _uhd_swig.uhd_size_vector_t_push_back(self, x)


    def front(self):
        """front(uhd_size_vector_t self) -> std::vector< size_t >::value_type const &"""
        return _uhd_swig.uhd_size_vector_t_front(self)


    def back(self):
        """back(uhd_size_vector_t self) -> std::vector< size_t >::value_type const &"""
        return _uhd_swig.uhd_size_vector_t_back(self)


    def assign(self, n, x):
        """assign(uhd_size_vector_t self, std::vector< size_t >::size_type n, std::vector< size_t >::value_type const & x)"""
        return _uhd_swig.uhd_size_vector_t_assign(self, n, x)


    def resize(self, *args):
        """
        resize(uhd_size_vector_t self, std::vector< size_t >::size_type new_size)
        resize(uhd_size_vector_t self, std::vector< size_t >::size_type new_size, std::vector< size_t >::value_type const & x)
        """
        return _uhd_swig.uhd_size_vector_t_resize(self, *args)


    def insert(self, *args):
        """
        insert(uhd_size_vector_t self, std::vector< size_t >::iterator pos, std::vector< size_t >::value_type const & x) -> std::vector< size_t >::iterator
        insert(uhd_size_vector_t self, std::vector< size_t >::iterator pos, std::vector< size_t >::size_type n, std::vector< size_t >::value_type const & x)
        """
        return _uhd_swig.uhd_size_vector_t_insert(self, *args)


    def reserve(self, n):
        """reserve(uhd_size_vector_t self, std::vector< size_t >::size_type n)"""
        return _uhd_swig.uhd_size_vector_t_reserve(self, n)


    def capacity(self):
        """capacity(uhd_size_vector_t self) -> std::vector< size_t >::size_type"""
        return _uhd_swig.uhd_size_vector_t_capacity(self)

    __swig_destroy__ = _uhd_swig.delete_uhd_size_vector_t
    __del__ = lambda self: None
uhd_size_vector_t_swigregister = _uhd_swig.uhd_size_vector_t_swigregister
uhd_size_vector_t_swigregister(uhd_size_vector_t)

class string_string_dict_t(object):
    """Proxy of C++ uhd::dict<(std::string,std::string)> class."""

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

    def __init__(self):
        """__init__(uhd::dict<(std::string,std::string)> self) -> string_string_dict_t"""
        this = _uhd_swig.new_string_string_dict_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def size(self):
        """size(string_string_dict_t self) -> std::size_t"""
        return _uhd_swig.string_string_dict_t_size(self)


    def keys(self):
        """keys(string_string_dict_t self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.string_string_dict_t_keys(self)


    def vals(self):
        """vals(string_string_dict_t self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.string_string_dict_t_vals(self)


    def has_key(self, key):
        """has_key(string_string_dict_t self, std::string const & key) -> bool"""
        return _uhd_swig.string_string_dict_t_has_key(self, key)


    def get(self, *args):
        """
        get(string_string_dict_t self, std::string const & key, std::string const & other) -> std::string const
        get(string_string_dict_t self, std::string const & key) -> std::string const &
        """
        return _uhd_swig.string_string_dict_t_get(self, *args)


    def set(self, key, val):
        """set(string_string_dict_t self, std::string const & key, std::string const & val)"""
        return _uhd_swig.string_string_dict_t_set(self, key, val)


    def pop(self, key):
        """pop(string_string_dict_t self, std::string const & key) -> std::string"""
        return _uhd_swig.string_string_dict_t_pop(self, key)


    def update(self, new_dict, fail_on_conflict=True):
        """update(string_string_dict_t self, string_string_dict_t new_dict, bool fail_on_conflict=True)"""
        return _uhd_swig.string_string_dict_t_update(self, new_dict, fail_on_conflict)


    def __getitem__(self, key):
        """__getitem__(string_string_dict_t self, std::string key) -> std::string"""
        return _uhd_swig.string_string_dict_t___getitem__(self, key)


    def __setitem__(self, key, val):
        """__setitem__(string_string_dict_t self, std::string key, std::string val)"""
        return _uhd_swig.string_string_dict_t___setitem__(self, key, val)

    __swig_destroy__ = _uhd_swig.delete_string_string_dict_t
    __del__ = lambda self: None
string_string_dict_t_swigregister = _uhd_swig.string_string_dict_t_swigregister
string_string_dict_t_swigregister(string_string_dict_t)

class device_addr_t(string_string_dict_t):
    """Proxy of C++ uhd::device_addr_t class."""

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

    def __init__(self, *args, **kwargs):
        """__init__(uhd::device_addr_t self, std::string const & args) -> device_addr_t"""
        this = _uhd_swig.new_device_addr_t(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def to_pp_string(self):
        """to_pp_string(device_addr_t self) -> std::string"""
        return _uhd_swig.device_addr_t_to_pp_string(self)


    def to_string(self):
        """to_string(device_addr_t self) -> std::string"""
        return _uhd_swig.device_addr_t_to_string(self)

    __swig_destroy__ = _uhd_swig.delete_device_addr_t
    __del__ = lambda self: None
device_addr_t_swigregister = _uhd_swig.device_addr_t_swigregister
device_addr_t_swigregister(device_addr_t)


def separate_device_addr(dev_addr):
    """separate_device_addr(device_addr_t dev_addr) -> device_addr_vector_t"""
    return _uhd_swig.separate_device_addr(dev_addr)

def combine_device_addrs(dev_addrs):
    """combine_device_addrs(device_addr_vector_t dev_addrs) -> device_addr_t"""
    return _uhd_swig.combine_device_addrs(dev_addrs)
class io_type_t(object):
    """Proxy of C++ uhd::io_type_t class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    CUSTOM_TYPE = _uhd_swig.io_type_t_CUSTOM_TYPE
    COMPLEX_FLOAT64 = _uhd_swig.io_type_t_COMPLEX_FLOAT64
    COMPLEX_FLOAT32 = _uhd_swig.io_type_t_COMPLEX_FLOAT32
    COMPLEX_INT16 = _uhd_swig.io_type_t_COMPLEX_INT16
    COMPLEX_INT8 = _uhd_swig.io_type_t_COMPLEX_INT8
    size = _swig_property(_uhd_swig.io_type_t_size_get)
    tid = _swig_property(_uhd_swig.io_type_t_tid_get)

    def __init__(self, *args):
        """
        __init__(uhd::io_type_t self, uhd::io_type_t::tid_t tid) -> io_type_t
        __init__(uhd::io_type_t self, size_t size) -> io_type_t
        """
        this = _uhd_swig.new_io_type_t(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _uhd_swig.delete_io_type_t
    __del__ = lambda self: None
io_type_t_swigregister = _uhd_swig.io_type_t_swigregister
io_type_t_swigregister(io_type_t)

class range_vector_t(object):
    """Proxy of C++ std::vector<(uhd::range_t)> class."""

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

    def iterator(self):
        """iterator(range_vector_t self) -> SwigPyIterator"""
        return _uhd_swig.range_vector_t_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(range_vector_t self) -> bool"""
        return _uhd_swig.range_vector_t___nonzero__(self)


    def __bool__(self):
        """__bool__(range_vector_t self) -> bool"""
        return _uhd_swig.range_vector_t___bool__(self)


    def __len__(self):
        """__len__(range_vector_t self) -> std::vector< uhd::range_t >::size_type"""
        return _uhd_swig.range_vector_t___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(range_vector_t self, std::vector< uhd::range_t >::difference_type i, std::vector< uhd::range_t >::difference_type j) -> range_vector_t"""
        return _uhd_swig.range_vector_t___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(range_vector_t self, std::vector< uhd::range_t >::difference_type i, std::vector< uhd::range_t >::difference_type j)
        __setslice__(range_vector_t self, std::vector< uhd::range_t >::difference_type i, std::vector< uhd::range_t >::difference_type j, range_vector_t v)
        """
        return _uhd_swig.range_vector_t___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(range_vector_t self, std::vector< uhd::range_t >::difference_type i, std::vector< uhd::range_t >::difference_type j)"""
        return _uhd_swig.range_vector_t___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(range_vector_t self, std::vector< uhd::range_t >::difference_type i)
        __delitem__(range_vector_t self, PySliceObject * slice)
        """
        return _uhd_swig.range_vector_t___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(range_vector_t self, PySliceObject * slice) -> range_vector_t
        __getitem__(range_vector_t self, std::vector< uhd::range_t >::difference_type i) -> range_t
        """
        return _uhd_swig.range_vector_t___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(range_vector_t self, PySliceObject * slice, range_vector_t v)
        __setitem__(range_vector_t self, PySliceObject * slice)
        __setitem__(range_vector_t self, std::vector< uhd::range_t >::difference_type i, range_t x)
        """
        return _uhd_swig.range_vector_t___setitem__(self, *args)


    def pop(self):
        """pop(range_vector_t self) -> range_t"""
        return _uhd_swig.range_vector_t_pop(self)


    def append(self, x):
        """append(range_vector_t self, range_t x)"""
        return _uhd_swig.range_vector_t_append(self, x)


    def empty(self):
        """empty(range_vector_t self) -> bool"""
        return _uhd_swig.range_vector_t_empty(self)


    def size(self):
        """size(range_vector_t self) -> std::vector< uhd::range_t >::size_type"""
        return _uhd_swig.range_vector_t_size(self)


    def swap(self, v):
        """swap(range_vector_t self, range_vector_t v)"""
        return _uhd_swig.range_vector_t_swap(self, v)


    def begin(self):
        """begin(range_vector_t self) -> std::vector< uhd::range_t >::iterator"""
        return _uhd_swig.range_vector_t_begin(self)


    def end(self):
        """end(range_vector_t self) -> std::vector< uhd::range_t >::iterator"""
        return _uhd_swig.range_vector_t_end(self)


    def rbegin(self):
        """rbegin(range_vector_t self) -> std::vector< uhd::range_t >::reverse_iterator"""
        return _uhd_swig.range_vector_t_rbegin(self)


    def rend(self):
        """rend(range_vector_t self) -> std::vector< uhd::range_t >::reverse_iterator"""
        return _uhd_swig.range_vector_t_rend(self)


    def clear(self):
        """clear(range_vector_t self)"""
        return _uhd_swig.range_vector_t_clear(self)


    def get_allocator(self):
        """get_allocator(range_vector_t self) -> std::vector< uhd::range_t >::allocator_type"""
        return _uhd_swig.range_vector_t_get_allocator(self)


    def pop_back(self):
        """pop_back(range_vector_t self)"""
        return _uhd_swig.range_vector_t_pop_back(self)


    def erase(self, *args):
        """
        erase(range_vector_t self, std::vector< uhd::range_t >::iterator pos) -> std::vector< uhd::range_t >::iterator
        erase(range_vector_t self, std::vector< uhd::range_t >::iterator first, std::vector< uhd::range_t >::iterator last) -> std::vector< uhd::range_t >::iterator
        """
        return _uhd_swig.range_vector_t_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(uhd::range_t)> self) -> range_vector_t
        __init__(std::vector<(uhd::range_t)> self, range_vector_t arg2) -> range_vector_t
        __init__(std::vector<(uhd::range_t)> self, std::vector< uhd::range_t >::size_type size) -> range_vector_t
        __init__(std::vector<(uhd::range_t)> self, std::vector< uhd::range_t >::size_type size, range_t value) -> range_vector_t
        """
        this = _uhd_swig.new_range_vector_t(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(range_vector_t self, range_t x)"""
        return _uhd_swig.range_vector_t_push_back(self, x)


    def front(self):
        """front(range_vector_t self) -> range_t"""
        return _uhd_swig.range_vector_t_front(self)


    def back(self):
        """back(range_vector_t self) -> range_t"""
        return _uhd_swig.range_vector_t_back(self)


    def assign(self, n, x):
        """assign(range_vector_t self, std::vector< uhd::range_t >::size_type n, range_t x)"""
        return _uhd_swig.range_vector_t_assign(self, n, x)


    def resize(self, *args):
        """
        resize(range_vector_t self, std::vector< uhd::range_t >::size_type new_size)
        resize(range_vector_t self, std::vector< uhd::range_t >::size_type new_size, range_t x)
        """
        return _uhd_swig.range_vector_t_resize(self, *args)


    def insert(self, *args):
        """
        insert(range_vector_t self, std::vector< uhd::range_t >::iterator pos, range_t x) -> std::vector< uhd::range_t >::iterator
        insert(range_vector_t self, std::vector< uhd::range_t >::iterator pos, std::vector< uhd::range_t >::size_type n, range_t x)
        """
        return _uhd_swig.range_vector_t_insert(self, *args)


    def reserve(self, n):
        """reserve(range_vector_t self, std::vector< uhd::range_t >::size_type n)"""
        return _uhd_swig.range_vector_t_reserve(self, n)


    def capacity(self):
        """capacity(range_vector_t self) -> std::vector< uhd::range_t >::size_type"""
        return _uhd_swig.range_vector_t_capacity(self)

    __swig_destroy__ = _uhd_swig.delete_range_vector_t
    __del__ = lambda self: None
range_vector_t_swigregister = _uhd_swig.range_vector_t_swigregister
range_vector_t_swigregister(range_vector_t)

class range_t(object):
    """Proxy of C++ uhd::range_t class."""

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

    def __init__(self, *args):
        """
        __init__(uhd::range_t self, double value) -> range_t
        __init__(uhd::range_t self, double start, double stop, double step) -> range_t
        """
        this = _uhd_swig.new_range_t(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def start(self):
        """start(range_t self) -> double"""
        return _uhd_swig.range_t_start(self)


    def stop(self):
        """stop(range_t self) -> double"""
        return _uhd_swig.range_t_stop(self)


    def step(self):
        """step(range_t self) -> double"""
        return _uhd_swig.range_t_step(self)


    def to_pp_string(self):
        """to_pp_string(range_t self) -> std::string const"""
        return _uhd_swig.range_t_to_pp_string(self)

    __swig_destroy__ = _uhd_swig.delete_range_t
    __del__ = lambda self: None
range_t_swigregister = _uhd_swig.range_t_swigregister
range_t_swigregister(range_t)

class meta_range_t(range_vector_t):
    """Proxy of C++ uhd::meta_range_t class."""

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

    def __init__(self, *args):
        """
        __init__(uhd::meta_range_t self) -> meta_range_t
        __init__(uhd::meta_range_t self, double start, double stop, double step) -> meta_range_t
        """
        this = _uhd_swig.new_meta_range_t(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def start(self):
        """start(meta_range_t self) -> double"""
        return _uhd_swig.meta_range_t_start(self)


    def stop(self):
        """stop(meta_range_t self) -> double"""
        return _uhd_swig.meta_range_t_stop(self)


    def step(self):
        """step(meta_range_t self) -> double"""
        return _uhd_swig.meta_range_t_step(self)


    def clip(self, value, clip_step=False):
        """clip(meta_range_t self, double value, bool clip_step=False) -> double"""
        return _uhd_swig.meta_range_t_clip(self, value, clip_step)


    def to_pp_string(self):
        """to_pp_string(meta_range_t self) -> std::string const"""
        return _uhd_swig.meta_range_t_to_pp_string(self)

    __swig_destroy__ = _uhd_swig.delete_meta_range_t
    __del__ = lambda self: None
meta_range_t_swigregister = _uhd_swig.meta_range_t_swigregister
meta_range_t_swigregister(meta_range_t)

class tune_request_t(object):
    """Proxy of C++ uhd::tune_request_t class."""

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

    def __init__(self, *args):
        """
        __init__(uhd::tune_request_t self, double target_freq) -> tune_request_t
        __init__(uhd::tune_request_t self, double target_freq, double lo_off) -> tune_request_t
        """
        this = _uhd_swig.new_tune_request_t(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    POLICY_NONE = _uhd_swig.tune_request_t_POLICY_NONE
    POLICY_AUTO = _uhd_swig.tune_request_t_POLICY_AUTO
    POLICY_MANUAL = _uhd_swig.tune_request_t_POLICY_MANUAL
    target_freq = _swig_property(_uhd_swig.tune_request_t_target_freq_get, _uhd_swig.tune_request_t_target_freq_set)
    rf_freq_policy = _swig_property(_uhd_swig.tune_request_t_rf_freq_policy_get, _uhd_swig.tune_request_t_rf_freq_policy_set)
    rf_freq = _swig_property(_uhd_swig.tune_request_t_rf_freq_get, _uhd_swig.tune_request_t_rf_freq_set)
    dsp_freq_policy = _swig_property(_uhd_swig.tune_request_t_dsp_freq_policy_get, _uhd_swig.tune_request_t_dsp_freq_policy_set)
    dsp_freq = _swig_property(_uhd_swig.tune_request_t_dsp_freq_get, _uhd_swig.tune_request_t_dsp_freq_set)
    args = _swig_property(_uhd_swig.tune_request_t_args_get, _uhd_swig.tune_request_t_args_set)
    __swig_destroy__ = _uhd_swig.delete_tune_request_t
    __del__ = lambda self: None
tune_request_t_swigregister = _uhd_swig.tune_request_t_swigregister
tune_request_t_swigregister(tune_request_t)

class tune_result_t(object):
    """Proxy of C++ uhd::tune_result_t class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    clipped_rf_freq = _swig_property(_uhd_swig.tune_result_t_clipped_rf_freq_get, _uhd_swig.tune_result_t_clipped_rf_freq_set)
    target_rf_freq = _swig_property(_uhd_swig.tune_result_t_target_rf_freq_get, _uhd_swig.tune_result_t_target_rf_freq_set)
    actual_rf_freq = _swig_property(_uhd_swig.tune_result_t_actual_rf_freq_get, _uhd_swig.tune_result_t_actual_rf_freq_set)
    target_dsp_freq = _swig_property(_uhd_swig.tune_result_t_target_dsp_freq_get, _uhd_swig.tune_result_t_target_dsp_freq_set)
    actual_dsp_freq = _swig_property(_uhd_swig.tune_result_t_actual_dsp_freq_get, _uhd_swig.tune_result_t_actual_dsp_freq_set)

    def to_pp_string(self):
        """to_pp_string(tune_result_t self) -> std::string"""
        return _uhd_swig.tune_result_t_to_pp_string(self)


    def __init__(self):
        """__init__(uhd::tune_result_t self) -> tune_result_t"""
        this = _uhd_swig.new_tune_result_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _uhd_swig.delete_tune_result_t
    __del__ = lambda self: None
tune_result_t_swigregister = _uhd_swig.tune_result_t_swigregister
tune_result_t_swigregister(tune_result_t)

class time_spec_t(object):
    """Proxy of C++ uhd::time_spec_t class."""

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

    def get_system_time():
        """get_system_time() -> time_spec_t"""
        return _uhd_swig.time_spec_t_get_system_time()

    get_system_time = staticmethod(get_system_time)

    def __init__(self, *args):
        """
        __init__(uhd::time_spec_t self, double secs) -> time_spec_t
        __init__(uhd::time_spec_t self, time_t full_secs, double frac_secs) -> time_spec_t
        __init__(uhd::time_spec_t self, time_t full_secs, long tick_count, double tick_rate) -> time_spec_t
        """
        this = _uhd_swig.new_time_spec_t(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def from_ticks(ticks, tick_rate):
        """from_ticks(long long ticks, double tick_rate) -> time_spec_t"""
        return _uhd_swig.time_spec_t_from_ticks(ticks, tick_rate)

    from_ticks = staticmethod(from_ticks)

    def get_tick_count(self, tick_rate):
        """get_tick_count(time_spec_t self, double tick_rate) -> long"""
        return _uhd_swig.time_spec_t_get_tick_count(self, tick_rate)


    def to_ticks(self, tick_rate):
        """to_ticks(time_spec_t self, double const tick_rate) -> long long"""
        return _uhd_swig.time_spec_t_to_ticks(self, tick_rate)


    def get_real_secs(self):
        """get_real_secs(time_spec_t self) -> double"""
        return _uhd_swig.time_spec_t_get_real_secs(self)


    def get_full_secs(self):
        """get_full_secs(time_spec_t self) -> time_t"""
        return _uhd_swig.time_spec_t_get_full_secs(self)


    def get_frac_secs(self):
        """get_frac_secs(time_spec_t self) -> double"""
        return _uhd_swig.time_spec_t_get_frac_secs(self)


    def __iadd__(self, arg2):
        """__iadd__(time_spec_t self, time_spec_t arg2) -> time_spec_t"""
        return _uhd_swig.time_spec_t___iadd__(self, arg2)


    def __isub__(self, arg2):
        """__isub__(time_spec_t self, time_spec_t arg2) -> time_spec_t"""
        return _uhd_swig.time_spec_t___isub__(self, arg2)


    def __add__(self, what):
        """__add__(time_spec_t self, time_spec_t what) -> time_spec_t"""
        return _uhd_swig.time_spec_t___add__(self, what)


    def __sub__(self, what):
        """__sub__(time_spec_t self, time_spec_t what) -> time_spec_t"""
        return _uhd_swig.time_spec_t___sub__(self, what)

    __swig_destroy__ = _uhd_swig.delete_time_spec_t
    __del__ = lambda self: None
time_spec_t_swigregister = _uhd_swig.time_spec_t_swigregister
time_spec_t_swigregister(time_spec_t)

def time_spec_t_get_system_time():
    """time_spec_t_get_system_time() -> time_spec_t"""
    return _uhd_swig.time_spec_t_get_system_time()

def time_spec_t_from_ticks(ticks, tick_rate):
    """time_spec_t_from_ticks(long long ticks, double tick_rate) -> time_spec_t"""
    return _uhd_swig.time_spec_t_from_ticks(ticks, tick_rate)


def __eq__(arg1, arg2):
    """__eq__(time_spec_t arg1, time_spec_t arg2) -> bool"""
    return _uhd_swig.__eq__(arg1, arg2)

def __lt__(arg1, arg2):
    """__lt__(time_spec_t arg1, time_spec_t arg2) -> bool"""
    return _uhd_swig.__lt__(arg1, arg2)
class stream_cmd_t(object):
    """Proxy of C++ uhd::stream_cmd_t class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    STREAM_MODE_START_CONTINUOUS = _uhd_swig.stream_cmd_t_STREAM_MODE_START_CONTINUOUS
    STREAM_MODE_STOP_CONTINUOUS = _uhd_swig.stream_cmd_t_STREAM_MODE_STOP_CONTINUOUS
    STREAM_MODE_NUM_SAMPS_AND_DONE = _uhd_swig.stream_cmd_t_STREAM_MODE_NUM_SAMPS_AND_DONE
    STREAM_MODE_NUM_SAMPS_AND_MORE = _uhd_swig.stream_cmd_t_STREAM_MODE_NUM_SAMPS_AND_MORE
    stream_mode = _swig_property(_uhd_swig.stream_cmd_t_stream_mode_get, _uhd_swig.stream_cmd_t_stream_mode_set)
    num_samps = _swig_property(_uhd_swig.stream_cmd_t_num_samps_get, _uhd_swig.stream_cmd_t_num_samps_set)
    stream_now = _swig_property(_uhd_swig.stream_cmd_t_stream_now_get, _uhd_swig.stream_cmd_t_stream_now_set)
    time_spec = _swig_property(_uhd_swig.stream_cmd_t_time_spec_get, _uhd_swig.stream_cmd_t_time_spec_set)

    def __init__(self, stream_mode):
        """__init__(uhd::stream_cmd_t self, uhd::stream_cmd_t::stream_mode_t const & stream_mode) -> stream_cmd_t"""
        this = _uhd_swig.new_stream_cmd_t(stream_mode)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _uhd_swig.delete_stream_cmd_t
    __del__ = lambda self: None
stream_cmd_t_swigregister = _uhd_swig.stream_cmd_t_swigregister
stream_cmd_t_swigregister(stream_cmd_t)

class clock_config_t(object):
    """Proxy of C++ uhd::clock_config_t class."""

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

    def external():
        """external() -> clock_config_t"""
        return _uhd_swig.clock_config_t_external()

    external = staticmethod(external)

    def internal():
        """internal() -> clock_config_t"""
        return _uhd_swig.clock_config_t_internal()

    internal = staticmethod(internal)
    REF_AUTO = _uhd_swig.clock_config_t_REF_AUTO
    REF_INT = _uhd_swig.clock_config_t_REF_INT
    REF_SMA = _uhd_swig.clock_config_t_REF_SMA
    REF_MIMO = _uhd_swig.clock_config_t_REF_MIMO
    ref_source = _swig_property(_uhd_swig.clock_config_t_ref_source_get, _uhd_swig.clock_config_t_ref_source_set)
    PPS_INT = _uhd_swig.clock_config_t_PPS_INT
    PPS_SMA = _uhd_swig.clock_config_t_PPS_SMA
    PPS_MIMO = _uhd_swig.clock_config_t_PPS_MIMO
    pps_source = _swig_property(_uhd_swig.clock_config_t_pps_source_get, _uhd_swig.clock_config_t_pps_source_set)
    PPS_NEG = _uhd_swig.clock_config_t_PPS_NEG
    PPS_POS = _uhd_swig.clock_config_t_PPS_POS
    pps_polarity = _swig_property(_uhd_swig.clock_config_t_pps_polarity_get, _uhd_swig.clock_config_t_pps_polarity_set)

    def __init__(self):
        """__init__(uhd::clock_config_t self) -> clock_config_t"""
        this = _uhd_swig.new_clock_config_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _uhd_swig.delete_clock_config_t
    __del__ = lambda self: None
clock_config_t_swigregister = _uhd_swig.clock_config_t_swigregister
clock_config_t_swigregister(clock_config_t)

def clock_config_t_external():
    """clock_config_t_external() -> clock_config_t"""
    return _uhd_swig.clock_config_t_external()

def clock_config_t_internal():
    """clock_config_t_internal() -> clock_config_t"""
    return _uhd_swig.clock_config_t_internal()

class rx_metadata_t(object):
    """Proxy of C++ uhd::rx_metadata_t class."""

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

    def __init__(self):
        """__init__(uhd::rx_metadata_t self) -> rx_metadata_t"""
        this = _uhd_swig.new_rx_metadata_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def reset(self):
        """reset(rx_metadata_t self)"""
        return _uhd_swig.rx_metadata_t_reset(self)

    has_time_spec = _swig_property(_uhd_swig.rx_metadata_t_has_time_spec_get, _uhd_swig.rx_metadata_t_has_time_spec_set)
    time_spec = _swig_property(_uhd_swig.rx_metadata_t_time_spec_get, _uhd_swig.rx_metadata_t_time_spec_set)
    more_fragments = _swig_property(_uhd_swig.rx_metadata_t_more_fragments_get, _uhd_swig.rx_metadata_t_more_fragments_set)
    fragment_offset = _swig_property(_uhd_swig.rx_metadata_t_fragment_offset_get, _uhd_swig.rx_metadata_t_fragment_offset_set)
    start_of_burst = _swig_property(_uhd_swig.rx_metadata_t_start_of_burst_get, _uhd_swig.rx_metadata_t_start_of_burst_set)
    end_of_burst = _swig_property(_uhd_swig.rx_metadata_t_end_of_burst_get, _uhd_swig.rx_metadata_t_end_of_burst_set)
    ERROR_CODE_NONE = _uhd_swig.rx_metadata_t_ERROR_CODE_NONE
    ERROR_CODE_TIMEOUT = _uhd_swig.rx_metadata_t_ERROR_CODE_TIMEOUT
    ERROR_CODE_LATE_COMMAND = _uhd_swig.rx_metadata_t_ERROR_CODE_LATE_COMMAND
    ERROR_CODE_BROKEN_CHAIN = _uhd_swig.rx_metadata_t_ERROR_CODE_BROKEN_CHAIN
    ERROR_CODE_OVERFLOW = _uhd_swig.rx_metadata_t_ERROR_CODE_OVERFLOW
    ERROR_CODE_ALIGNMENT = _uhd_swig.rx_metadata_t_ERROR_CODE_ALIGNMENT
    ERROR_CODE_BAD_PACKET = _uhd_swig.rx_metadata_t_ERROR_CODE_BAD_PACKET
    error_code = _swig_property(_uhd_swig.rx_metadata_t_error_code_get, _uhd_swig.rx_metadata_t_error_code_set)
    out_of_sequence = _swig_property(_uhd_swig.rx_metadata_t_out_of_sequence_get, _uhd_swig.rx_metadata_t_out_of_sequence_set)

    def to_pp_string(self, compact=True):
        """to_pp_string(rx_metadata_t self, bool compact=True) -> std::string"""
        return _uhd_swig.rx_metadata_t_to_pp_string(self, compact)


    def strerror(self):
        """strerror(rx_metadata_t self) -> std::string"""
        return _uhd_swig.rx_metadata_t_strerror(self)

    __swig_destroy__ = _uhd_swig.delete_rx_metadata_t
    __del__ = lambda self: None
rx_metadata_t_swigregister = _uhd_swig.rx_metadata_t_swigregister
rx_metadata_t_swigregister(rx_metadata_t)

class tx_metadata_t(object):
    """Proxy of C++ uhd::tx_metadata_t class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    has_time_spec = _swig_property(_uhd_swig.tx_metadata_t_has_time_spec_get, _uhd_swig.tx_metadata_t_has_time_spec_set)
    time_spec = _swig_property(_uhd_swig.tx_metadata_t_time_spec_get, _uhd_swig.tx_metadata_t_time_spec_set)
    start_of_burst = _swig_property(_uhd_swig.tx_metadata_t_start_of_burst_get, _uhd_swig.tx_metadata_t_start_of_burst_set)
    end_of_burst = _swig_property(_uhd_swig.tx_metadata_t_end_of_burst_get, _uhd_swig.tx_metadata_t_end_of_burst_set)

    def __init__(self):
        """__init__(uhd::tx_metadata_t self) -> tx_metadata_t"""
        this = _uhd_swig.new_tx_metadata_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _uhd_swig.delete_tx_metadata_t
    __del__ = lambda self: None
tx_metadata_t_swigregister = _uhd_swig.tx_metadata_t_swigregister
tx_metadata_t_swigregister(tx_metadata_t)

class async_metadata_t(object):
    """Proxy of C++ uhd::async_metadata_t class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    channel = _swig_property(_uhd_swig.async_metadata_t_channel_get, _uhd_swig.async_metadata_t_channel_set)
    has_time_spec = _swig_property(_uhd_swig.async_metadata_t_has_time_spec_get, _uhd_swig.async_metadata_t_has_time_spec_set)
    time_spec = _swig_property(_uhd_swig.async_metadata_t_time_spec_get, _uhd_swig.async_metadata_t_time_spec_set)
    EVENT_CODE_BURST_ACK = _uhd_swig.async_metadata_t_EVENT_CODE_BURST_ACK
    EVENT_CODE_UNDERFLOW = _uhd_swig.async_metadata_t_EVENT_CODE_UNDERFLOW
    EVENT_CODE_SEQ_ERROR = _uhd_swig.async_metadata_t_EVENT_CODE_SEQ_ERROR
    EVENT_CODE_TIME_ERROR = _uhd_swig.async_metadata_t_EVENT_CODE_TIME_ERROR
    EVENT_CODE_UNDERFLOW_IN_PACKET = _uhd_swig.async_metadata_t_EVENT_CODE_UNDERFLOW_IN_PACKET
    EVENT_CODE_SEQ_ERROR_IN_BURST = _uhd_swig.async_metadata_t_EVENT_CODE_SEQ_ERROR_IN_BURST
    EVENT_CODE_USER_PAYLOAD = _uhd_swig.async_metadata_t_EVENT_CODE_USER_PAYLOAD
    event_code = _swig_property(_uhd_swig.async_metadata_t_event_code_get, _uhd_swig.async_metadata_t_event_code_set)
    user_payload = _swig_property(_uhd_swig.async_metadata_t_user_payload_get, _uhd_swig.async_metadata_t_user_payload_set)

    def __init__(self):
        """__init__(uhd::async_metadata_t self) -> async_metadata_t"""
        this = _uhd_swig.new_async_metadata_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _uhd_swig.delete_async_metadata_t
    __del__ = lambda self: None
async_metadata_t_swigregister = _uhd_swig.async_metadata_t_swigregister
async_metadata_t_swigregister(async_metadata_t)

class device_addr_vector_t(object):
    """Proxy of C++ std::vector<(uhd::device_addr_t)> class."""

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

    def iterator(self):
        """iterator(device_addr_vector_t self) -> SwigPyIterator"""
        return _uhd_swig.device_addr_vector_t_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(device_addr_vector_t self) -> bool"""
        return _uhd_swig.device_addr_vector_t___nonzero__(self)


    def __bool__(self):
        """__bool__(device_addr_vector_t self) -> bool"""
        return _uhd_swig.device_addr_vector_t___bool__(self)


    def __len__(self):
        """__len__(device_addr_vector_t self) -> std::vector< uhd::device_addr_t >::size_type"""
        return _uhd_swig.device_addr_vector_t___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(device_addr_vector_t self, std::vector< uhd::device_addr_t >::difference_type i, std::vector< uhd::device_addr_t >::difference_type j) -> device_addr_vector_t"""
        return _uhd_swig.device_addr_vector_t___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(device_addr_vector_t self, std::vector< uhd::device_addr_t >::difference_type i, std::vector< uhd::device_addr_t >::difference_type j)
        __setslice__(device_addr_vector_t self, std::vector< uhd::device_addr_t >::difference_type i, std::vector< uhd::device_addr_t >::difference_type j, device_addr_vector_t v)
        """
        return _uhd_swig.device_addr_vector_t___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(device_addr_vector_t self, std::vector< uhd::device_addr_t >::difference_type i, std::vector< uhd::device_addr_t >::difference_type j)"""
        return _uhd_swig.device_addr_vector_t___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(device_addr_vector_t self, std::vector< uhd::device_addr_t >::difference_type i)
        __delitem__(device_addr_vector_t self, PySliceObject * slice)
        """
        return _uhd_swig.device_addr_vector_t___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(device_addr_vector_t self, PySliceObject * slice) -> device_addr_vector_t
        __getitem__(device_addr_vector_t self, std::vector< uhd::device_addr_t >::difference_type i) -> device_addr_t
        """
        return _uhd_swig.device_addr_vector_t___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(device_addr_vector_t self, PySliceObject * slice, device_addr_vector_t v)
        __setitem__(device_addr_vector_t self, PySliceObject * slice)
        __setitem__(device_addr_vector_t self, std::vector< uhd::device_addr_t >::difference_type i, device_addr_t x)
        """
        return _uhd_swig.device_addr_vector_t___setitem__(self, *args)


    def pop(self):
        """pop(device_addr_vector_t self) -> device_addr_t"""
        return _uhd_swig.device_addr_vector_t_pop(self)


    def append(self, x):
        """append(device_addr_vector_t self, device_addr_t x)"""
        return _uhd_swig.device_addr_vector_t_append(self, x)


    def empty(self):
        """empty(device_addr_vector_t self) -> bool"""
        return _uhd_swig.device_addr_vector_t_empty(self)


    def size(self):
        """size(device_addr_vector_t self) -> std::vector< uhd::device_addr_t >::size_type"""
        return _uhd_swig.device_addr_vector_t_size(self)


    def swap(self, v):
        """swap(device_addr_vector_t self, device_addr_vector_t v)"""
        return _uhd_swig.device_addr_vector_t_swap(self, v)


    def begin(self):
        """begin(device_addr_vector_t self) -> std::vector< uhd::device_addr_t >::iterator"""
        return _uhd_swig.device_addr_vector_t_begin(self)


    def end(self):
        """end(device_addr_vector_t self) -> std::vector< uhd::device_addr_t >::iterator"""
        return _uhd_swig.device_addr_vector_t_end(self)


    def rbegin(self):
        """rbegin(device_addr_vector_t self) -> std::vector< uhd::device_addr_t >::reverse_iterator"""
        return _uhd_swig.device_addr_vector_t_rbegin(self)


    def rend(self):
        """rend(device_addr_vector_t self) -> std::vector< uhd::device_addr_t >::reverse_iterator"""
        return _uhd_swig.device_addr_vector_t_rend(self)


    def clear(self):
        """clear(device_addr_vector_t self)"""
        return _uhd_swig.device_addr_vector_t_clear(self)


    def get_allocator(self):
        """get_allocator(device_addr_vector_t self) -> std::vector< uhd::device_addr_t >::allocator_type"""
        return _uhd_swig.device_addr_vector_t_get_allocator(self)


    def pop_back(self):
        """pop_back(device_addr_vector_t self)"""
        return _uhd_swig.device_addr_vector_t_pop_back(self)


    def erase(self, *args):
        """
        erase(device_addr_vector_t self, std::vector< uhd::device_addr_t >::iterator pos) -> std::vector< uhd::device_addr_t >::iterator
        erase(device_addr_vector_t self, std::vector< uhd::device_addr_t >::iterator first, std::vector< uhd::device_addr_t >::iterator last) -> std::vector< uhd::device_addr_t >::iterator
        """
        return _uhd_swig.device_addr_vector_t_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(uhd::device_addr_t)> self) -> device_addr_vector_t
        __init__(std::vector<(uhd::device_addr_t)> self, device_addr_vector_t arg2) -> device_addr_vector_t
        __init__(std::vector<(uhd::device_addr_t)> self, std::vector< uhd::device_addr_t >::size_type size) -> device_addr_vector_t
        __init__(std::vector<(uhd::device_addr_t)> self, std::vector< uhd::device_addr_t >::size_type size, device_addr_t value) -> device_addr_vector_t
        """
        this = _uhd_swig.new_device_addr_vector_t(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(device_addr_vector_t self, device_addr_t x)"""
        return _uhd_swig.device_addr_vector_t_push_back(self, x)


    def front(self):
        """front(device_addr_vector_t self) -> device_addr_t"""
        return _uhd_swig.device_addr_vector_t_front(self)


    def back(self):
        """back(device_addr_vector_t self) -> device_addr_t"""
        return _uhd_swig.device_addr_vector_t_back(self)


    def assign(self, n, x):
        """assign(device_addr_vector_t self, std::vector< uhd::device_addr_t >::size_type n, device_addr_t x)"""
        return _uhd_swig.device_addr_vector_t_assign(self, n, x)


    def resize(self, *args):
        """
        resize(device_addr_vector_t self, std::vector< uhd::device_addr_t >::size_type new_size)
        resize(device_addr_vector_t self, std::vector< uhd::device_addr_t >::size_type new_size, device_addr_t x)
        """
        return _uhd_swig.device_addr_vector_t_resize(self, *args)


    def insert(self, *args):
        """
        insert(device_addr_vector_t self, std::vector< uhd::device_addr_t >::iterator pos, device_addr_t x) -> std::vector< uhd::device_addr_t >::iterator
        insert(device_addr_vector_t self, std::vector< uhd::device_addr_t >::iterator pos, std::vector< uhd::device_addr_t >::size_type n, device_addr_t x)
        """
        return _uhd_swig.device_addr_vector_t_insert(self, *args)


    def reserve(self, n):
        """reserve(device_addr_vector_t self, std::vector< uhd::device_addr_t >::size_type n)"""
        return _uhd_swig.device_addr_vector_t_reserve(self, n)


    def capacity(self):
        """capacity(device_addr_vector_t self) -> std::vector< uhd::device_addr_t >::size_type"""
        return _uhd_swig.device_addr_vector_t_capacity(self)

    __swig_destroy__ = _uhd_swig.delete_device_addr_vector_t
    __del__ = lambda self: None
device_addr_vector_t_swigregister = _uhd_swig.device_addr_vector_t_swigregister
device_addr_vector_t_swigregister(device_addr_vector_t)

class sensor_value_t(object):
    """Proxy of C++ uhd::sensor_value_t class."""

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

    def __init__(self, *args):
        """
        __init__(uhd::sensor_value_t self, std::string const & name, bool value, std::string const & utrue, std::string const & ufalse) -> sensor_value_t
        __init__(uhd::sensor_value_t self, std::string const & name, int value, std::string const & unit, std::string const & formatter) -> sensor_value_t
        __init__(uhd::sensor_value_t self, std::string const & name, double value, std::string const & unit, std::string const & formatter) -> sensor_value_t
        __init__(uhd::sensor_value_t self, std::string const & name, std::string const & value, std::string const & unit) -> sensor_value_t
        __init__(uhd::sensor_value_t self, sensor_value_t source) -> sensor_value_t
        """
        this = _uhd_swig.new_sensor_value_t(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def to_bool(self):
        """to_bool(sensor_value_t self) -> bool"""
        return _uhd_swig.sensor_value_t_to_bool(self)


    def to_int(self):
        """to_int(sensor_value_t self) -> int"""
        return _uhd_swig.sensor_value_t_to_int(self)


    def to_real(self):
        """to_real(sensor_value_t self) -> double"""
        return _uhd_swig.sensor_value_t_to_real(self)

    name = _swig_property(_uhd_swig.sensor_value_t_name_get, _uhd_swig.sensor_value_t_name_set)
    value = _swig_property(_uhd_swig.sensor_value_t_value_get, _uhd_swig.sensor_value_t_value_set)
    unit = _swig_property(_uhd_swig.sensor_value_t_unit_get, _uhd_swig.sensor_value_t_unit_set)
    BOOLEAN = _uhd_swig.sensor_value_t_BOOLEAN
    INTEGER = _uhd_swig.sensor_value_t_INTEGER
    REALNUM = _uhd_swig.sensor_value_t_REALNUM
    STRING = _uhd_swig.sensor_value_t_STRING
    type = _swig_property(_uhd_swig.sensor_value_t_type_get, _uhd_swig.sensor_value_t_type_set)

    def to_pp_string(self):
        """to_pp_string(sensor_value_t self) -> std::string"""
        return _uhd_swig.sensor_value_t_to_pp_string(self)

    __swig_destroy__ = _uhd_swig.delete_sensor_value_t
    __del__ = lambda self: None
sensor_value_t_swigregister = _uhd_swig.sensor_value_t_swigregister
sensor_value_t_swigregister(sensor_value_t)

class stream_args_t(object):
    """Proxy of C++ uhd::stream_args_t class."""

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

    def __init__(self, *args, **kwargs):
        """__init__(uhd::stream_args_t self, std::string const & cpu, std::string const & otw) -> stream_args_t"""
        this = _uhd_swig.new_stream_args_t(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    cpu_format = _swig_property(_uhd_swig.stream_args_t_cpu_format_get, _uhd_swig.stream_args_t_cpu_format_set)
    otw_format = _swig_property(_uhd_swig.stream_args_t_otw_format_get, _uhd_swig.stream_args_t_otw_format_set)
    args = _swig_property(_uhd_swig.stream_args_t_args_get, _uhd_swig.stream_args_t_args_set)
    channels = _swig_property(_uhd_swig.stream_args_t_channels_get, _uhd_swig.stream_args_t_channels_set)
    __swig_destroy__ = _uhd_swig.delete_stream_args_t
    __del__ = lambda self: None
stream_args_t_swigregister = _uhd_swig.stream_args_t_swigregister
stream_args_t_swigregister(stream_args_t)

class rx_streamer(object):
    """Proxy of C++ uhd::rx_streamer class."""

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

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

    def get_num_channels(self):
        """get_num_channels(rx_streamer self) -> size_t"""
        return _uhd_swig.rx_streamer_get_num_channels(self)


    def get_max_num_samps(self):
        """get_max_num_samps(rx_streamer self) -> size_t"""
        return _uhd_swig.rx_streamer_get_max_num_samps(self)


    def recv(self, *args, **kwargs):
        """recv(rx_streamer self, uhd::rx_streamer::buffs_type const & buffs, size_t const nsamps_per_buff, rx_metadata_t metadata, double const timeout, bool const one_packet=False) -> size_t"""
        return _uhd_swig.rx_streamer_recv(self, *args, **kwargs)


    def issue_stream_cmd(self, stream_cmd):
        """issue_stream_cmd(rx_streamer self, stream_cmd_t stream_cmd)"""
        return _uhd_swig.rx_streamer_issue_stream_cmd(self, stream_cmd)

rx_streamer_swigregister = _uhd_swig.rx_streamer_swigregister
rx_streamer_swigregister(rx_streamer)

class tx_streamer(object):
    """Proxy of C++ uhd::tx_streamer class."""

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

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

    def get_num_channels(self):
        """get_num_channels(tx_streamer self) -> size_t"""
        return _uhd_swig.tx_streamer_get_num_channels(self)


    def get_max_num_samps(self):
        """get_max_num_samps(tx_streamer self) -> size_t"""
        return _uhd_swig.tx_streamer_get_max_num_samps(self)


    def send(self, *args, **kwargs):
        """send(tx_streamer self, uhd::tx_streamer::buffs_type const & buffs, size_t const nsamps_per_buff, tx_metadata_t metadata, double const timeout) -> size_t"""
        return _uhd_swig.tx_streamer_send(self, *args, **kwargs)


    def recv_async_msg(self, *args, **kwargs):
        """recv_async_msg(tx_streamer self, async_metadata_t async_metadata, double timeout) -> bool"""
        return _uhd_swig.tx_streamer_recv_async_msg(self, *args, **kwargs)

tx_streamer_swigregister = _uhd_swig.tx_streamer_swigregister
tx_streamer_swigregister(tx_streamer)

class i2c_iface(object):
    """Proxy of C++ uhd::i2c_iface class."""

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

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

    def eeprom16(self):
        """eeprom16(i2c_iface self) -> uhd::i2c_iface::sptr"""
        return _uhd_swig.i2c_iface_eeprom16(self)


    def write_i2c(self, addr, buf):
        """write_i2c(i2c_iface self, uint16_t addr, uhd::byte_vector_t const & buf)"""
        return _uhd_swig.i2c_iface_write_i2c(self, addr, buf)


    def read_i2c(self, addr, num_bytes):
        """read_i2c(i2c_iface self, uint16_t addr, size_t num_bytes) -> uhd::byte_vector_t"""
        return _uhd_swig.i2c_iface_read_i2c(self, addr, num_bytes)


    def write_eeprom(self, addr, offset, buf):
        """write_eeprom(i2c_iface self, uint16_t addr, uint16_t offset, uhd::byte_vector_t const & buf)"""
        return _uhd_swig.i2c_iface_write_eeprom(self, addr, offset, buf)


    def read_eeprom(self, addr, offset, num_bytes):
        """read_eeprom(i2c_iface self, uint16_t addr, uint16_t offset, size_t num_bytes) -> uhd::byte_vector_t"""
        return _uhd_swig.i2c_iface_read_eeprom(self, addr, offset, num_bytes)

i2c_iface_swigregister = _uhd_swig.i2c_iface_swigregister
i2c_iface_swigregister(i2c_iface)

class spi_config_t(object):
    """Proxy of C++ uhd::spi_config_t class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    EDGE_RISE = _uhd_swig.spi_config_t_EDGE_RISE
    EDGE_FALL = _uhd_swig.spi_config_t_EDGE_FALL
    mosi_edge = _swig_property(_uhd_swig.spi_config_t_mosi_edge_get, _uhd_swig.spi_config_t_mosi_edge_set)
    miso_edge = _swig_property(_uhd_swig.spi_config_t_miso_edge_get, _uhd_swig.spi_config_t_miso_edge_set)
    use_custom_divider = _swig_property(_uhd_swig.spi_config_t_use_custom_divider_get, _uhd_swig.spi_config_t_use_custom_divider_set)
    divider = _swig_property(_uhd_swig.spi_config_t_divider_get, _uhd_swig.spi_config_t_divider_set)

    def __init__(self, *args, **kwargs):
        """__init__(uhd::spi_config_t self, uhd::spi_config_t::edge_t edge) -> spi_config_t"""
        this = _uhd_swig.new_spi_config_t(*args, **kwargs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _uhd_swig.delete_spi_config_t
    __del__ = lambda self: None
spi_config_t_swigregister = _uhd_swig.spi_config_t_swigregister
spi_config_t_swigregister(spi_config_t)

class spi_iface(object):
    """Proxy of C++ uhd::spi_iface class."""

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

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

    def transact_spi(self, which_slave, config, data, num_bits, readback):
        """transact_spi(spi_iface self, int which_slave, spi_config_t config, uint32_t data, size_t num_bits, bool readback) -> uint32_t"""
        return _uhd_swig.spi_iface_transact_spi(self, which_slave, config, data, num_bits, readback)


    def read_spi(self, which_slave, config, data, num_bits):
        """read_spi(spi_iface self, int which_slave, spi_config_t config, uint32_t data, size_t num_bits) -> uint32_t"""
        return _uhd_swig.spi_iface_read_spi(self, which_slave, config, data, num_bits)


    def write_spi(self, which_slave, config, data, num_bits):
        """write_spi(spi_iface self, int which_slave, spi_config_t config, uint32_t data, size_t num_bits)"""
        return _uhd_swig.spi_iface_write_spi(self, which_slave, config, data, num_bits)

spi_iface_swigregister = _uhd_swig.spi_iface_swigregister
spi_iface_swigregister(spi_iface)

class uart_iface(object):
    """Proxy of C++ uhd::uart_iface class."""

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

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

    def write_uart(self, buf):
        """write_uart(uart_iface self, std::string const & buf)"""
        return _uhd_swig.uart_iface_write_uart(self, buf)


    def read_uart(self, timeout):
        """read_uart(uart_iface self, double timeout) -> std::string"""
        return _uhd_swig.uart_iface_read_uart(self, timeout)

uart_iface_swigregister = _uhd_swig.uart_iface_swigregister
uart_iface_swigregister(uart_iface)

class dboard_iface_special_props_t(object):
    """Proxy of C++ uhd::usrp::dboard_iface_special_props_t class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    soft_clock_divider = _swig_property(_uhd_swig.dboard_iface_special_props_t_soft_clock_divider_get, _uhd_swig.dboard_iface_special_props_t_soft_clock_divider_set)
    mangle_i2c_addrs = _swig_property(_uhd_swig.dboard_iface_special_props_t_mangle_i2c_addrs_get, _uhd_swig.dboard_iface_special_props_t_mangle_i2c_addrs_set)

    def __init__(self):
        """__init__(uhd::usrp::dboard_iface_special_props_t self) -> dboard_iface_special_props_t"""
        this = _uhd_swig.new_dboard_iface_special_props_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _uhd_swig.delete_dboard_iface_special_props_t
    __del__ = lambda self: None
dboard_iface_special_props_t_swigregister = _uhd_swig.dboard_iface_special_props_t_swigregister
dboard_iface_special_props_t_swigregister(dboard_iface_special_props_t)

class dboard_iface(i2c_iface):
    """Proxy of C++ uhd::usrp::dboard_iface class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    UNIT_RX = _uhd_swig.dboard_iface_UNIT_RX
    UNIT_TX = _uhd_swig.dboard_iface_UNIT_TX
    UNIT_BOTH = _uhd_swig.dboard_iface_UNIT_BOTH
    AUX_DAC_A = _uhd_swig.dboard_iface_AUX_DAC_A
    AUX_DAC_B = _uhd_swig.dboard_iface_AUX_DAC_B
    AUX_DAC_C = _uhd_swig.dboard_iface_AUX_DAC_C
    AUX_DAC_D = _uhd_swig.dboard_iface_AUX_DAC_D
    AUX_ADC_A = _uhd_swig.dboard_iface_AUX_ADC_A
    AUX_ADC_B = _uhd_swig.dboard_iface_AUX_ADC_B
    __swig_destroy__ = _uhd_swig.delete_dboard_iface
    __del__ = lambda self: None

    def get_special_props(self):
        """get_special_props(dboard_iface self) -> dboard_iface_special_props_t"""
        return _uhd_swig.dboard_iface_get_special_props(self)


    def write_aux_dac(self, unit, which_dac, value):
        """write_aux_dac(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, uhd::usrp::dboard_iface::aux_dac_t which_dac, double value)"""
        return _uhd_swig.dboard_iface_write_aux_dac(self, unit, which_dac, value)


    def read_aux_adc(self, unit, which_adc):
        """read_aux_adc(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, uhd::usrp::dboard_iface::aux_adc_t which_adc) -> double"""
        return _uhd_swig.dboard_iface_read_aux_adc(self, unit, which_adc)


    def set_pin_ctrl(self, *args, **kwargs):
        """set_pin_ctrl(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, uint32_t value, uint32_t mask)"""
        return _uhd_swig.dboard_iface_set_pin_ctrl(self, *args, **kwargs)


    def get_pin_ctrl(self, unit):
        """get_pin_ctrl(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit) -> uint32_t"""
        return _uhd_swig.dboard_iface_get_pin_ctrl(self, unit)


    def set_atr_reg(self, *args, **kwargs):
        """set_atr_reg(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, uhd::usrp::dboard_iface::atr_reg_t reg, uint32_t value, uint32_t mask)"""
        return _uhd_swig.dboard_iface_set_atr_reg(self, *args, **kwargs)


    def get_atr_reg(self, unit, reg):
        """get_atr_reg(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, uhd::usrp::dboard_iface::atr_reg_t reg) -> uint32_t"""
        return _uhd_swig.dboard_iface_get_atr_reg(self, unit, reg)


    def set_gpio_ddr(self, *args, **kwargs):
        """set_gpio_ddr(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, uint32_t value, uint32_t mask)"""
        return _uhd_swig.dboard_iface_set_gpio_ddr(self, *args, **kwargs)


    def get_gpio_ddr(self, unit):
        """get_gpio_ddr(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit) -> uint32_t"""
        return _uhd_swig.dboard_iface_get_gpio_ddr(self, unit)


    def set_gpio_out(self, *args, **kwargs):
        """set_gpio_out(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, uint32_t value, uint32_t mask)"""
        return _uhd_swig.dboard_iface_set_gpio_out(self, *args, **kwargs)


    def get_gpio_out(self, unit):
        """get_gpio_out(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit) -> uint32_t"""
        return _uhd_swig.dboard_iface_get_gpio_out(self, unit)


    def read_gpio(self, unit):
        """read_gpio(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit) -> uint32_t"""
        return _uhd_swig.dboard_iface_read_gpio(self, unit)


    def write_spi(self, unit, config, data, num_bits):
        """write_spi(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, spi_config_t config, uint32_t data, size_t num_bits)"""
        return _uhd_swig.dboard_iface_write_spi(self, unit, config, data, num_bits)


    def read_write_spi(self, unit, config, data, num_bits):
        """read_write_spi(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, spi_config_t config, uint32_t data, size_t num_bits) -> uint32_t"""
        return _uhd_swig.dboard_iface_read_write_spi(self, unit, config, data, num_bits)


    def set_clock_rate(self, unit, rate):
        """set_clock_rate(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, double rate)"""
        return _uhd_swig.dboard_iface_set_clock_rate(self, unit, rate)


    def get_clock_rate(self, unit):
        """get_clock_rate(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit) -> double"""
        return _uhd_swig.dboard_iface_get_clock_rate(self, unit)


    def get_clock_rates(self, unit):
        """get_clock_rates(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit) -> pmt_vector_double"""
        return _uhd_swig.dboard_iface_get_clock_rates(self, unit)


    def set_clock_enabled(self, unit, enb):
        """set_clock_enabled(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, bool enb)"""
        return _uhd_swig.dboard_iface_set_clock_enabled(self, unit, enb)


    def get_codec_rate(self, unit):
        """get_codec_rate(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit) -> double"""
        return _uhd_swig.dboard_iface_get_codec_rate(self, unit)


    def set_fe_connection(self, unit, fe_name, fe_conn):
        """set_fe_connection(dboard_iface self, uhd::usrp::dboard_iface::unit_t unit, std::string const & fe_name, uhd::usrp::fe_connection_t const & fe_conn)"""
        return _uhd_swig.dboard_iface_set_fe_connection(self, unit, fe_name, fe_conn)


    def get_command_time(self):
        """get_command_time(dboard_iface self) -> time_spec_t"""
        return _uhd_swig.dboard_iface_get_command_time(self)


    def set_command_time(self, t):
        """set_command_time(dboard_iface self, time_spec_t t)"""
        return _uhd_swig.dboard_iface_set_command_time(self, t)


    def sleep(self, time):
        """sleep(dboard_iface self, boost::chrono::nanoseconds const & time)"""
        return _uhd_swig.dboard_iface_sleep(self, time)

dboard_iface_swigregister = _uhd_swig.dboard_iface_swigregister
dboard_iface_swigregister(dboard_iface)

class dboard_iface_sptr(object):
    """Proxy of C++ boost::shared_ptr<(uhd::usrp::dboard_iface)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(uhd::usrp::dboard_iface)> self) -> dboard_iface_sptr
        __init__(boost::shared_ptr<(uhd::usrp::dboard_iface)> self, dboard_iface p) -> dboard_iface_sptr
        """
        this = _uhd_swig.new_dboard_iface_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(dboard_iface_sptr self) -> dboard_iface"""
        return _uhd_swig.dboard_iface_sptr___deref__(self)

    __swig_destroy__ = _uhd_swig.delete_dboard_iface_sptr
    __del__ = lambda self: None

    def get_special_props(self):
        """get_special_props(dboard_iface_sptr self) -> dboard_iface_special_props_t"""
        return _uhd_swig.dboard_iface_sptr_get_special_props(self)


    def write_aux_dac(self, unit, which_dac, value):
        """write_aux_dac(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, uhd::usrp::dboard_iface::aux_dac_t which_dac, double value)"""
        return _uhd_swig.dboard_iface_sptr_write_aux_dac(self, unit, which_dac, value)


    def read_aux_adc(self, unit, which_adc):
        """read_aux_adc(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, uhd::usrp::dboard_iface::aux_adc_t which_adc) -> double"""
        return _uhd_swig.dboard_iface_sptr_read_aux_adc(self, unit, which_adc)


    def set_pin_ctrl(self, *args, **kwargs):
        """set_pin_ctrl(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, uint32_t value, uint32_t mask)"""
        return _uhd_swig.dboard_iface_sptr_set_pin_ctrl(self, *args, **kwargs)


    def get_pin_ctrl(self, unit):
        """get_pin_ctrl(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit) -> uint32_t"""
        return _uhd_swig.dboard_iface_sptr_get_pin_ctrl(self, unit)


    def set_atr_reg(self, *args, **kwargs):
        """set_atr_reg(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, uhd::usrp::dboard_iface::atr_reg_t reg, uint32_t value, uint32_t mask)"""
        return _uhd_swig.dboard_iface_sptr_set_atr_reg(self, *args, **kwargs)


    def get_atr_reg(self, unit, reg):
        """get_atr_reg(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, uhd::usrp::dboard_iface::atr_reg_t reg) -> uint32_t"""
        return _uhd_swig.dboard_iface_sptr_get_atr_reg(self, unit, reg)


    def set_gpio_ddr(self, *args, **kwargs):
        """set_gpio_ddr(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, uint32_t value, uint32_t mask)"""
        return _uhd_swig.dboard_iface_sptr_set_gpio_ddr(self, *args, **kwargs)


    def get_gpio_ddr(self, unit):
        """get_gpio_ddr(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit) -> uint32_t"""
        return _uhd_swig.dboard_iface_sptr_get_gpio_ddr(self, unit)


    def set_gpio_out(self, *args, **kwargs):
        """set_gpio_out(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, uint32_t value, uint32_t mask)"""
        return _uhd_swig.dboard_iface_sptr_set_gpio_out(self, *args, **kwargs)


    def get_gpio_out(self, unit):
        """get_gpio_out(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit) -> uint32_t"""
        return _uhd_swig.dboard_iface_sptr_get_gpio_out(self, unit)


    def read_gpio(self, unit):
        """read_gpio(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit) -> uint32_t"""
        return _uhd_swig.dboard_iface_sptr_read_gpio(self, unit)


    def write_spi(self, unit, config, data, num_bits):
        """write_spi(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, spi_config_t config, uint32_t data, size_t num_bits)"""
        return _uhd_swig.dboard_iface_sptr_write_spi(self, unit, config, data, num_bits)


    def read_write_spi(self, unit, config, data, num_bits):
        """read_write_spi(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, spi_config_t config, uint32_t data, size_t num_bits) -> uint32_t"""
        return _uhd_swig.dboard_iface_sptr_read_write_spi(self, unit, config, data, num_bits)


    def set_clock_rate(self, unit, rate):
        """set_clock_rate(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, double rate)"""
        return _uhd_swig.dboard_iface_sptr_set_clock_rate(self, unit, rate)


    def get_clock_rate(self, unit):
        """get_clock_rate(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit) -> double"""
        return _uhd_swig.dboard_iface_sptr_get_clock_rate(self, unit)


    def get_clock_rates(self, unit):
        """get_clock_rates(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit) -> pmt_vector_double"""
        return _uhd_swig.dboard_iface_sptr_get_clock_rates(self, unit)


    def set_clock_enabled(self, unit, enb):
        """set_clock_enabled(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, bool enb)"""
        return _uhd_swig.dboard_iface_sptr_set_clock_enabled(self, unit, enb)


    def get_codec_rate(self, unit):
        """get_codec_rate(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit) -> double"""
        return _uhd_swig.dboard_iface_sptr_get_codec_rate(self, unit)


    def set_fe_connection(self, unit, fe_name, fe_conn):
        """set_fe_connection(dboard_iface_sptr self, uhd::usrp::dboard_iface::unit_t unit, std::string const & fe_name, uhd::usrp::fe_connection_t const & fe_conn)"""
        return _uhd_swig.dboard_iface_sptr_set_fe_connection(self, unit, fe_name, fe_conn)


    def get_command_time(self):
        """get_command_time(dboard_iface_sptr self) -> time_spec_t"""
        return _uhd_swig.dboard_iface_sptr_get_command_time(self)


    def set_command_time(self, t):
        """set_command_time(dboard_iface_sptr self, time_spec_t t)"""
        return _uhd_swig.dboard_iface_sptr_set_command_time(self, t)


    def sleep(self, time):
        """sleep(dboard_iface_sptr self, boost::chrono::nanoseconds const & time)"""
        return _uhd_swig.dboard_iface_sptr_sleep(self, time)


    def eeprom16(self):
        """eeprom16(dboard_iface_sptr self) -> uhd::i2c_iface::sptr"""
        return _uhd_swig.dboard_iface_sptr_eeprom16(self)


    def write_i2c(self, addr, buf):
        """write_i2c(dboard_iface_sptr self, uint16_t addr, uhd::byte_vector_t const & buf)"""
        return _uhd_swig.dboard_iface_sptr_write_i2c(self, addr, buf)


    def read_i2c(self, addr, num_bytes):
        """read_i2c(dboard_iface_sptr self, uint16_t addr, size_t num_bytes) -> uhd::byte_vector_t"""
        return _uhd_swig.dboard_iface_sptr_read_i2c(self, addr, num_bytes)


    def write_eeprom(self, addr, offset, buf):
        """write_eeprom(dboard_iface_sptr self, uint16_t addr, uint16_t offset, uhd::byte_vector_t const & buf)"""
        return _uhd_swig.dboard_iface_sptr_write_eeprom(self, addr, offset, buf)


    def read_eeprom(self, addr, offset, num_bytes):
        """read_eeprom(dboard_iface_sptr self, uint16_t addr, uint16_t offset, size_t num_bytes) -> uhd::byte_vector_t"""
        return _uhd_swig.dboard_iface_sptr_read_eeprom(self, addr, offset, num_bytes)

dboard_iface_sptr_swigregister = _uhd_swig.dboard_iface_sptr_swigregister
dboard_iface_sptr_swigregister(dboard_iface_sptr)

class usrp_source(usrp_block):
    """Proxy of C++ gr::uhd::usrp_source class."""

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

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

    def make(*args):
        """
        make(device_addr_t device_addr, io_type_t io_type, size_t num_channels) -> usrp_source_sptr
        make(device_addr_t device_addr, stream_args_t stream_args, bool const issue_stream_cmd_on_start=True) -> usrp_source_sptr
        """
        return _uhd_swig.usrp_source_make(*args)

    make = staticmethod(make)

    def set_start_time(self, time):
        """set_start_time(usrp_source self, time_spec_t time)"""
        return _uhd_swig.usrp_source_set_start_time(self, time)


    def issue_stream_cmd(self, cmd):
        """issue_stream_cmd(usrp_source self, stream_cmd_t cmd)"""
        return _uhd_swig.usrp_source_issue_stream_cmd(self, cmd)


    def get_usrp_info(self, *args, **kwargs):
        """get_usrp_info(usrp_source self, size_t chan) -> string_string_dict_t"""
        return _uhd_swig.usrp_source_get_usrp_info(self, *args, **kwargs)


    def get_lo_names(self, *args, **kwargs):
        """get_lo_names(usrp_source self, size_t chan) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_get_lo_names(self, *args, **kwargs)


    def set_lo_source(self, *args, **kwargs):
        """set_lo_source(usrp_source self, std::string const & src, std::string const & name, size_t chan)"""
        return _uhd_swig.usrp_source_set_lo_source(self, *args, **kwargs)


    def get_lo_source(self, *args, **kwargs):
        """get_lo_source(usrp_source self, std::string const & name, size_t chan) -> std::string const"""
        return _uhd_swig.usrp_source_get_lo_source(self, *args, **kwargs)


    def get_lo_sources(self, *args, **kwargs):
        """get_lo_sources(usrp_source self, std::string const & name, size_t chan) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_get_lo_sources(self, *args, **kwargs)


    def set_lo_export_enabled(self, *args, **kwargs):
        """set_lo_export_enabled(usrp_source self, bool enabled, std::string const & name, size_t chan)"""
        return _uhd_swig.usrp_source_set_lo_export_enabled(self, *args, **kwargs)


    def get_lo_export_enabled(self, *args, **kwargs):
        """get_lo_export_enabled(usrp_source self, std::string const & name, size_t chan) -> bool"""
        return _uhd_swig.usrp_source_get_lo_export_enabled(self, *args, **kwargs)


    def set_lo_freq(self, *args, **kwargs):
        """set_lo_freq(usrp_source self, double freq, std::string const & name, size_t chan) -> double"""
        return _uhd_swig.usrp_source_set_lo_freq(self, *args, **kwargs)


    def get_lo_freq(self, *args, **kwargs):
        """get_lo_freq(usrp_source self, std::string const & name, size_t chan) -> double"""
        return _uhd_swig.usrp_source_get_lo_freq(self, *args, **kwargs)


    def get_lo_freq_range(self, *args, **kwargs):
        """get_lo_freq_range(usrp_source self, std::string const & name, size_t chan) -> meta_range_t"""
        return _uhd_swig.usrp_source_get_lo_freq_range(self, *args, **kwargs)


    def set_auto_dc_offset(self, *args, **kwargs):
        """set_auto_dc_offset(usrp_source self, bool const enb, size_t chan)"""
        return _uhd_swig.usrp_source_set_auto_dc_offset(self, *args, **kwargs)


    def set_dc_offset(self, *args, **kwargs):
        """set_dc_offset(usrp_source self, std::complex< double > const & offset, size_t chan)"""
        return _uhd_swig.usrp_source_set_dc_offset(self, *args, **kwargs)


    def set_auto_iq_balance(self, *args, **kwargs):
        """set_auto_iq_balance(usrp_source self, bool const enb, size_t chan)"""
        return _uhd_swig.usrp_source_set_auto_iq_balance(self, *args, **kwargs)


    def set_iq_balance(self, *args, **kwargs):
        """set_iq_balance(usrp_source self, std::complex< double > const & correction, size_t chan)"""
        return _uhd_swig.usrp_source_set_iq_balance(self, *args, **kwargs)


    def finite_acquisition(self, nsamps):
        """finite_acquisition(usrp_source self, size_t const nsamps) -> pmt_vector_cfloat"""
        return _uhd_swig.usrp_source_finite_acquisition(self, nsamps)


    def finite_acquisition_v(self, nsamps):
        """finite_acquisition_v(usrp_source self, size_t const nsamps) -> gr_vector_vector_complexf"""
        return _uhd_swig.usrp_source_finite_acquisition_v(self, nsamps)

    __swig_destroy__ = _uhd_swig.delete_usrp_source
    __del__ = lambda self: None
usrp_source_swigregister = _uhd_swig.usrp_source_swigregister
usrp_source_swigregister(usrp_source)

def usrp_source_make(*args):
    """
    make(device_addr_t device_addr, io_type_t io_type, size_t num_channels) -> usrp_source_sptr
    usrp_source_make(device_addr_t device_addr, stream_args_t stream_args, bool const issue_stream_cmd_on_start=True) -> usrp_source_sptr
    """
    return _uhd_swig.usrp_source_make(*args)

class usrp_sink(usrp_block):
    """Proxy of C++ gr::uhd::usrp_sink class."""

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

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

    def make(*args):
        """
        make(device_addr_t device_addr, io_type_t io_type, size_t num_channels) -> usrp_sink_sptr
        make(device_addr_t device_addr, stream_args_t stream_args, std::string const & tsb_tag_name) -> usrp_sink_sptr
        """
        return _uhd_swig.usrp_sink_make(*args)

    make = staticmethod(make)

    def set_start_time(self, time):
        """set_start_time(usrp_sink self, time_spec_t time)"""
        return _uhd_swig.usrp_sink_set_start_time(self, time)


    def get_usrp_info(self, *args, **kwargs):
        """get_usrp_info(usrp_sink self, size_t chan) -> string_string_dict_t"""
        return _uhd_swig.usrp_sink_get_usrp_info(self, *args, **kwargs)


    def set_dc_offset(self, *args, **kwargs):
        """set_dc_offset(usrp_sink self, std::complex< double > const & offset, size_t chan)"""
        return _uhd_swig.usrp_sink_set_dc_offset(self, *args, **kwargs)


    def set_iq_balance(self, *args, **kwargs):
        """set_iq_balance(usrp_sink self, std::complex< double > const & correction, size_t chan)"""
        return _uhd_swig.usrp_sink_set_iq_balance(self, *args, **kwargs)

    __swig_destroy__ = _uhd_swig.delete_usrp_sink
    __del__ = lambda self: None
usrp_sink_swigregister = _uhd_swig.usrp_sink_swigregister
usrp_sink_swigregister(usrp_sink)

def usrp_sink_make(*args):
    """
    make(device_addr_t device_addr, io_type_t io_type, size_t num_channels) -> usrp_sink_sptr
    usrp_sink_make(device_addr_t device_addr, stream_args_t stream_args, std::string const & tsb_tag_name) -> usrp_sink_sptr
    """
    return _uhd_swig.usrp_sink_make(*args)

class amsg_source(object):
    """Proxy of C++ gr::uhd::amsg_source class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _uhd_swig.delete_amsg_source
    __del__ = lambda self: None

    def make(device_addr, msgq):
        """make(device_addr_t device_addr, msg_queue_sptr msgq) -> amsg_source_sptr"""
        return _uhd_swig.amsg_source_make(device_addr, msgq)

    make = staticmethod(make)

    def msg_to_async_metadata_t(msg):
        """msg_to_async_metadata_t(message_sptr msg) -> async_metadata_t"""
        return _uhd_swig.amsg_source_msg_to_async_metadata_t(msg)

    msg_to_async_metadata_t = staticmethod(msg_to_async_metadata_t)

    def __init__(self):
        """__init__(gr::uhd::amsg_source self) -> amsg_source"""
        this = _uhd_swig.new_amsg_source()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
amsg_source_swigregister = _uhd_swig.amsg_source_swigregister
amsg_source_swigregister(amsg_source)

def amsg_source_make(device_addr, msgq):
    """amsg_source_make(device_addr_t device_addr, msg_queue_sptr msgq) -> amsg_source_sptr"""
    return _uhd_swig.amsg_source_make(device_addr, msgq)

def amsg_source_msg_to_async_metadata_t(msg):
    """amsg_source_msg_to_async_metadata_t(message_sptr msg) -> async_metadata_t"""
    return _uhd_swig.amsg_source_msg_to_async_metadata_t(msg)

class usrp_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::uhd::usrp_source)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::uhd::usrp_source)> self) -> usrp_source_sptr
        __init__(boost::shared_ptr<(gr::uhd::usrp_source)> self, usrp_source p) -> usrp_source_sptr
        """
        this = _uhd_swig.new_usrp_source_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(usrp_source_sptr self) -> usrp_source"""
        return _uhd_swig.usrp_source_sptr___deref__(self)

    __swig_destroy__ = _uhd_swig.delete_usrp_source_sptr
    __del__ = lambda self: None

    def make(self, *args):
        """
        make(usrp_source_sptr self, device_addr_t device_addr, io_type_t io_type, size_t num_channels) -> usrp_source_sptr
        make(usrp_source_sptr self, device_addr_t device_addr, stream_args_t stream_args, bool const issue_stream_cmd_on_start=True) -> usrp_source_sptr
        """
        return _uhd_swig.usrp_source_sptr_make(self, *args)


    def set_start_time(self, time):
        """set_start_time(usrp_source_sptr self, time_spec_t time)"""
        return _uhd_swig.usrp_source_sptr_set_start_time(self, time)


    def issue_stream_cmd(self, cmd):
        """issue_stream_cmd(usrp_source_sptr self, stream_cmd_t cmd)"""
        return _uhd_swig.usrp_source_sptr_issue_stream_cmd(self, cmd)


    def get_usrp_info(self, *args, **kwargs):
        """get_usrp_info(usrp_source_sptr self, size_t chan) -> string_string_dict_t"""
        return _uhd_swig.usrp_source_sptr_get_usrp_info(self, *args, **kwargs)


    def get_lo_names(self, *args, **kwargs):
        """get_lo_names(usrp_source_sptr self, size_t chan) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_lo_names(self, *args, **kwargs)


    def set_lo_source(self, *args, **kwargs):
        """set_lo_source(usrp_source_sptr self, std::string const & src, std::string const & name, size_t chan)"""
        return _uhd_swig.usrp_source_sptr_set_lo_source(self, *args, **kwargs)


    def get_lo_source(self, *args, **kwargs):
        """get_lo_source(usrp_source_sptr self, std::string const & name, size_t chan) -> std::string const"""
        return _uhd_swig.usrp_source_sptr_get_lo_source(self, *args, **kwargs)


    def get_lo_sources(self, *args, **kwargs):
        """get_lo_sources(usrp_source_sptr self, std::string const & name, size_t chan) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_lo_sources(self, *args, **kwargs)


    def set_lo_export_enabled(self, *args, **kwargs):
        """set_lo_export_enabled(usrp_source_sptr self, bool enabled, std::string const & name, size_t chan)"""
        return _uhd_swig.usrp_source_sptr_set_lo_export_enabled(self, *args, **kwargs)


    def get_lo_export_enabled(self, *args, **kwargs):
        """get_lo_export_enabled(usrp_source_sptr self, std::string const & name, size_t chan) -> bool"""
        return _uhd_swig.usrp_source_sptr_get_lo_export_enabled(self, *args, **kwargs)


    def set_lo_freq(self, *args, **kwargs):
        """set_lo_freq(usrp_source_sptr self, double freq, std::string const & name, size_t chan) -> double"""
        return _uhd_swig.usrp_source_sptr_set_lo_freq(self, *args, **kwargs)


    def get_lo_freq(self, *args, **kwargs):
        """get_lo_freq(usrp_source_sptr self, std::string const & name, size_t chan) -> double"""
        return _uhd_swig.usrp_source_sptr_get_lo_freq(self, *args, **kwargs)


    def get_lo_freq_range(self, *args, **kwargs):
        """get_lo_freq_range(usrp_source_sptr self, std::string const & name, size_t chan) -> meta_range_t"""
        return _uhd_swig.usrp_source_sptr_get_lo_freq_range(self, *args, **kwargs)


    def set_auto_dc_offset(self, *args, **kwargs):
        """set_auto_dc_offset(usrp_source_sptr self, bool const enb, size_t chan)"""
        return _uhd_swig.usrp_source_sptr_set_auto_dc_offset(self, *args, **kwargs)


    def set_dc_offset(self, *args, **kwargs):
        """set_dc_offset(usrp_source_sptr self, std::complex< double > const & offset, size_t chan)"""
        return _uhd_swig.usrp_source_sptr_set_dc_offset(self, *args, **kwargs)


    def set_auto_iq_balance(self, *args, **kwargs):
        """set_auto_iq_balance(usrp_source_sptr self, bool const enb, size_t chan)"""
        return _uhd_swig.usrp_source_sptr_set_auto_iq_balance(self, *args, **kwargs)


    def set_iq_balance(self, *args, **kwargs):
        """set_iq_balance(usrp_source_sptr self, std::complex< double > const & correction, size_t chan)"""
        return _uhd_swig.usrp_source_sptr_set_iq_balance(self, *args, **kwargs)


    def finite_acquisition(self, nsamps):
        """finite_acquisition(usrp_source_sptr self, size_t const nsamps) -> pmt_vector_cfloat"""
        return _uhd_swig.usrp_source_sptr_finite_acquisition(self, nsamps)


    def finite_acquisition_v(self, nsamps):
        """finite_acquisition_v(usrp_source_sptr self, size_t const nsamps) -> gr_vector_vector_complexf"""
        return _uhd_swig.usrp_source_sptr_finite_acquisition_v(self, nsamps)


    def set_subdev_spec(self, *args, **kwargs):
        """set_subdev_spec(usrp_source_sptr self, std::string const & spec, size_t mboard)"""
        return _uhd_swig.usrp_source_sptr_set_subdev_spec(self, *args, **kwargs)


    def get_subdev_spec(self, *args, **kwargs):
        """get_subdev_spec(usrp_source_sptr self, size_t mboard) -> std::string"""
        return _uhd_swig.usrp_source_sptr_get_subdev_spec(self, *args, **kwargs)


    def get_num_mboards(self):
        """get_num_mboards(usrp_source_sptr self) -> size_t"""
        return _uhd_swig.usrp_source_sptr_get_num_mboards(self)


    def set_samp_rate(self, rate):
        """set_samp_rate(usrp_source_sptr self, double rate)"""
        return _uhd_swig.usrp_source_sptr_set_samp_rate(self, rate)


    def get_samp_rate(self):
        """get_samp_rate(usrp_source_sptr self) -> double"""
        return _uhd_swig.usrp_source_sptr_get_samp_rate(self)


    def get_samp_rates(self):
        """get_samp_rates(usrp_source_sptr self) -> meta_range_t"""
        return _uhd_swig.usrp_source_sptr_get_samp_rates(self)


    def set_center_freq(self, *args):
        """
        set_center_freq(usrp_source_sptr self, tune_request_t tune_request, size_t chan) -> tune_result_t
        set_center_freq(usrp_source_sptr self, double freq, size_t chan) -> tune_result_t
        """
        return _uhd_swig.usrp_source_sptr_set_center_freq(self, *args)


    def get_center_freq(self, *args, **kwargs):
        """get_center_freq(usrp_source_sptr self, size_t chan) -> double"""
        return _uhd_swig.usrp_source_sptr_get_center_freq(self, *args, **kwargs)


    def get_freq_range(self, *args, **kwargs):
        """get_freq_range(usrp_source_sptr self, size_t chan) -> meta_range_t"""
        return _uhd_swig.usrp_source_sptr_get_freq_range(self, *args, **kwargs)


    def set_gain(self, *args):
        """
        set_gain(usrp_source_sptr self, double gain, size_t chan)
        set_gain(usrp_source_sptr self, double gain, std::string const & name, size_t chan)
        """
        return _uhd_swig.usrp_source_sptr_set_gain(self, *args)


    def set_normalized_gain(self, *args, **kwargs):
        """set_normalized_gain(usrp_source_sptr self, double norm_gain, size_t chan)"""
        return _uhd_swig.usrp_source_sptr_set_normalized_gain(self, *args, **kwargs)


    def get_gain(self, *args):
        """
        get_gain(usrp_source_sptr self, size_t chan) -> double
        get_gain(usrp_source_sptr self, std::string const & name, size_t chan) -> double
        """
        return _uhd_swig.usrp_source_sptr_get_gain(self, *args)


    def get_normalized_gain(self, *args, **kwargs):
        """get_normalized_gain(usrp_source_sptr self, size_t chan) -> double"""
        return _uhd_swig.usrp_source_sptr_get_normalized_gain(self, *args, **kwargs)


    def get_gain_names(self, *args, **kwargs):
        """get_gain_names(usrp_source_sptr self, size_t chan) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_gain_names(self, *args, **kwargs)


    def get_gain_range(self, *args):
        """
        get_gain_range(usrp_source_sptr self, size_t chan) -> meta_range_t
        get_gain_range(usrp_source_sptr self, std::string const & name, size_t chan) -> meta_range_t
        """
        return _uhd_swig.usrp_source_sptr_get_gain_range(self, *args)


    def set_antenna(self, *args, **kwargs):
        """set_antenna(usrp_source_sptr self, std::string const & ant, size_t chan)"""
        return _uhd_swig.usrp_source_sptr_set_antenna(self, *args, **kwargs)


    def get_antenna(self, *args, **kwargs):
        """get_antenna(usrp_source_sptr self, size_t chan) -> std::string"""
        return _uhd_swig.usrp_source_sptr_get_antenna(self, *args, **kwargs)


    def get_antennas(self, *args, **kwargs):
        """get_antennas(usrp_source_sptr self, size_t chan) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_antennas(self, *args, **kwargs)


    def set_bandwidth(self, *args, **kwargs):
        """set_bandwidth(usrp_source_sptr self, double bandwidth, size_t chan)"""
        return _uhd_swig.usrp_source_sptr_set_bandwidth(self, *args, **kwargs)


    def get_bandwidth(self, *args, **kwargs):
        """get_bandwidth(usrp_source_sptr self, size_t chan) -> double"""
        return _uhd_swig.usrp_source_sptr_get_bandwidth(self, *args, **kwargs)


    def get_bandwidth_range(self, *args, **kwargs):
        """get_bandwidth_range(usrp_source_sptr self, size_t chan) -> meta_range_t"""
        return _uhd_swig.usrp_source_sptr_get_bandwidth_range(self, *args, **kwargs)


    def get_sensor(self, *args, **kwargs):
        """get_sensor(usrp_source_sptr self, std::string const & name, size_t chan) -> sensor_value_t"""
        return _uhd_swig.usrp_source_sptr_get_sensor(self, *args, **kwargs)


    def get_sensor_names(self, *args, **kwargs):
        """get_sensor_names(usrp_source_sptr self, size_t chan) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_sensor_names(self, *args, **kwargs)


    def get_dboard_sensor(self, *args, **kwargs):
        """get_dboard_sensor(usrp_source_sptr self, std::string const & name, size_t chan) -> sensor_value_t"""
        return _uhd_swig.usrp_source_sptr_get_dboard_sensor(self, *args, **kwargs)


    def get_dboard_sensor_names(self, *args, **kwargs):
        """get_dboard_sensor_names(usrp_source_sptr self, size_t chan) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_dboard_sensor_names(self, *args, **kwargs)


    def get_mboard_sensor(self, *args, **kwargs):
        """get_mboard_sensor(usrp_source_sptr self, std::string const & name, size_t mboard) -> sensor_value_t"""
        return _uhd_swig.usrp_source_sptr_get_mboard_sensor(self, *args, **kwargs)


    def get_mboard_sensor_names(self, *args, **kwargs):
        """get_mboard_sensor_names(usrp_source_sptr self, size_t mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_mboard_sensor_names(self, *args, **kwargs)


    def get_time_source(self, mboard):
        """get_time_source(usrp_source_sptr self, size_t const mboard) -> std::string"""
        return _uhd_swig.usrp_source_sptr_get_time_source(self, mboard)


    def get_time_sources(self, mboard):
        """get_time_sources(usrp_source_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_time_sources(self, mboard)


    def set_clock_source(self, *args, **kwargs):
        """set_clock_source(usrp_source_sptr self, std::string const & source, size_t const mboard)"""
        return _uhd_swig.usrp_source_sptr_set_clock_source(self, *args, **kwargs)


    def get_clock_source(self, mboard):
        """get_clock_source(usrp_source_sptr self, size_t const mboard) -> std::string"""
        return _uhd_swig.usrp_source_sptr_get_clock_source(self, mboard)


    def get_clock_sources(self, mboard):
        """get_clock_sources(usrp_source_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_clock_sources(self, mboard)


    def get_clock_rate(self, *args, **kwargs):
        """get_clock_rate(usrp_source_sptr self, size_t mboard) -> double"""
        return _uhd_swig.usrp_source_sptr_get_clock_rate(self, *args, **kwargs)


    def set_clock_rate(self, *args, **kwargs):
        """set_clock_rate(usrp_source_sptr self, double rate, size_t mboard)"""
        return _uhd_swig.usrp_source_sptr_set_clock_rate(self, *args, **kwargs)


    def get_time_now(self, *args, **kwargs):
        """get_time_now(usrp_source_sptr self, size_t mboard) -> time_spec_t"""
        return _uhd_swig.usrp_source_sptr_get_time_now(self, *args, **kwargs)


    def get_time_last_pps(self, *args, **kwargs):
        """get_time_last_pps(usrp_source_sptr self, size_t mboard) -> time_spec_t"""
        return _uhd_swig.usrp_source_sptr_get_time_last_pps(self, *args, **kwargs)


    def set_time_now(self, *args, **kwargs):
        """set_time_now(usrp_source_sptr self, time_spec_t time_spec, size_t mboard)"""
        return _uhd_swig.usrp_source_sptr_set_time_now(self, *args, **kwargs)


    def set_time_next_pps(self, time_spec):
        """set_time_next_pps(usrp_source_sptr self, time_spec_t time_spec)"""
        return _uhd_swig.usrp_source_sptr_set_time_next_pps(self, time_spec)


    def set_time_unknown_pps(self, time_spec):
        """set_time_unknown_pps(usrp_source_sptr self, time_spec_t time_spec)"""
        return _uhd_swig.usrp_source_sptr_set_time_unknown_pps(self, time_spec)


    def set_command_time(self, *args, **kwargs):
        """set_command_time(usrp_source_sptr self, time_spec_t time_spec, size_t mboard)"""
        return _uhd_swig.usrp_source_sptr_set_command_time(self, *args, **kwargs)


    def clear_command_time(self, *args, **kwargs):
        """clear_command_time(usrp_source_sptr self, size_t mboard)"""
        return _uhd_swig.usrp_source_sptr_clear_command_time(self, *args, **kwargs)


    def get_dboard_iface(self, *args, **kwargs):
        """get_dboard_iface(usrp_source_sptr self, size_t chan) -> dboard_iface_sptr"""
        return _uhd_swig.usrp_source_sptr_get_dboard_iface(self, *args, **kwargs)


    def get_device(self):
        """get_device(usrp_source_sptr self) -> ::uhd::usrp::multi_usrp::sptr"""
        return _uhd_swig.usrp_source_sptr_get_device(self)


    def set_user_register(self, *args, **kwargs):
        """set_user_register(usrp_source_sptr self, uint8_t const addr, uint32_t const data, size_t mboard)"""
        return _uhd_swig.usrp_source_sptr_set_user_register(self, *args, **kwargs)


    def set_clock_config(self, *args, **kwargs):
        """set_clock_config(usrp_source_sptr self, clock_config_t clock_config, size_t mboard)"""
        return _uhd_swig.usrp_source_sptr_set_clock_config(self, *args, **kwargs)


    def set_time_source(self, *args, **kwargs):
        """set_time_source(usrp_source_sptr self, std::string const & source, size_t const mboard)"""
        return _uhd_swig.usrp_source_sptr_set_time_source(self, *args, **kwargs)


    def set_stream_args(self, stream_args):
        """set_stream_args(usrp_source_sptr self, stream_args_t stream_args)"""
        return _uhd_swig.usrp_source_sptr_set_stream_args(self, stream_args)


    def get_gpio_banks(self, mboard):
        """get_gpio_banks(usrp_source_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_source_sptr_get_gpio_banks(self, mboard)


    def set_gpio_attr(self, *args, **kwargs):
        """set_gpio_attr(usrp_source_sptr self, std::string const & bank, std::string const & attr, boost::uint32_t const value, boost::uint32_t const mask, size_t const mboard)"""
        return _uhd_swig.usrp_source_sptr_set_gpio_attr(self, *args, **kwargs)


    def get_gpio_attr(self, *args, **kwargs):
        """get_gpio_attr(usrp_source_sptr self, std::string const & bank, std::string const & attr, size_t const mboard) -> boost::uint32_t"""
        return _uhd_swig.usrp_source_sptr_get_gpio_attr(self, *args, **kwargs)


    def history(self):
        """history(usrp_source_sptr self) -> unsigned int"""
        return _uhd_swig.usrp_source_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(usrp_source_sptr self, int which, int delay)
        declare_sample_delay(usrp_source_sptr self, unsigned int delay)
        """
        return _uhd_swig.usrp_source_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(usrp_source_sptr self, int which) -> unsigned int"""
        return _uhd_swig.usrp_source_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(usrp_source_sptr self) -> int"""
        return _uhd_swig.usrp_source_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(usrp_source_sptr self) -> double"""
        return _uhd_swig.usrp_source_sptr_relative_rate(self)


    def start(self):
        """start(usrp_source_sptr self) -> bool"""
        return _uhd_swig.usrp_source_sptr_start(self)


    def stop(self):
        """stop(usrp_source_sptr self) -> bool"""
        return _uhd_swig.usrp_source_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(usrp_source_sptr self, unsigned int which_input) -> uint64_t"""
        return _uhd_swig.usrp_source_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(usrp_source_sptr self, unsigned int which_output) -> uint64_t"""
        return _uhd_swig.usrp_source_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(usrp_source_sptr self) -> int"""
        return _uhd_swig.usrp_source_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(usrp_source_sptr self, int m)"""
        return _uhd_swig.usrp_source_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(usrp_source_sptr self)"""
        return _uhd_swig.usrp_source_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(usrp_source_sptr self) -> bool"""
        return _uhd_swig.usrp_source_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(usrp_source_sptr self, int m)"""
        return _uhd_swig.usrp_source_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(usrp_source_sptr self) -> int"""
        return _uhd_swig.usrp_source_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(usrp_source_sptr self, int i) -> long"""
        return _uhd_swig.usrp_source_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(usrp_source_sptr self, long max_output_buffer)
        set_max_output_buffer(usrp_source_sptr self, int port, long max_output_buffer)
        """
        return _uhd_swig.usrp_source_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(usrp_source_sptr self, int i) -> long"""
        return _uhd_swig.usrp_source_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(usrp_source_sptr self, long min_output_buffer)
        set_min_output_buffer(usrp_source_sptr self, int port, long min_output_buffer)
        """
        return _uhd_swig.usrp_source_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(usrp_source_sptr self, int which) -> float
        pc_input_buffers_full(usrp_source_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_source_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(usrp_source_sptr self, int which) -> float
        pc_input_buffers_full_avg(usrp_source_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_source_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(usrp_source_sptr self, int which) -> float
        pc_input_buffers_full_var(usrp_source_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_source_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(usrp_source_sptr self, int which) -> float
        pc_output_buffers_full(usrp_source_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_source_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(usrp_source_sptr self, int which) -> float
        pc_output_buffers_full_avg(usrp_source_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_source_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(usrp_source_sptr self, int which) -> float
        pc_output_buffers_full_var(usrp_source_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_source_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(usrp_source_sptr self) -> float"""
        return _uhd_swig.usrp_source_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(usrp_source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _uhd_swig.usrp_source_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(usrp_source_sptr self)"""
        return _uhd_swig.usrp_source_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(usrp_source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _uhd_swig.usrp_source_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(usrp_source_sptr self) -> int"""
        return _uhd_swig.usrp_source_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(usrp_source_sptr self) -> int"""
        return _uhd_swig.usrp_source_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(usrp_source_sptr self, int priority) -> int"""
        return _uhd_swig.usrp_source_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(usrp_source_sptr self) -> std::string"""
        return _uhd_swig.usrp_source_sptr_name(self)


    def symbol_name(self):
        """symbol_name(usrp_source_sptr self) -> std::string"""
        return _uhd_swig.usrp_source_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(usrp_source_sptr self) -> io_signature_sptr"""
        return _uhd_swig.usrp_source_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(usrp_source_sptr self) -> io_signature_sptr"""
        return _uhd_swig.usrp_source_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(usrp_source_sptr self) -> long"""
        return _uhd_swig.usrp_source_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(usrp_source_sptr self) -> basic_block_sptr"""
        return _uhd_swig.usrp_source_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(usrp_source_sptr self, int ninputs, int noutputs) -> bool"""
        return _uhd_swig.usrp_source_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(usrp_source_sptr self) -> std::string"""
        return _uhd_swig.usrp_source_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(usrp_source_sptr self, std::string name)"""
        return _uhd_swig.usrp_source_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(usrp_source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _uhd_swig.usrp_source_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(usrp_source_sptr self) -> swig_int_ptr"""
        return _uhd_swig.usrp_source_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(usrp_source_sptr self) -> swig_int_ptr"""
        return _uhd_swig.usrp_source_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(usrp_source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _uhd_swig.usrp_source_sptr_message_subscribers(self, which_port)

usrp_source_sptr_swigregister = _uhd_swig.usrp_source_sptr_swigregister
usrp_source_sptr_swigregister(usrp_source_sptr)


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

class usrp_sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::uhd::usrp_sink)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::uhd::usrp_sink)> self) -> usrp_sink_sptr
        __init__(boost::shared_ptr<(gr::uhd::usrp_sink)> self, usrp_sink p) -> usrp_sink_sptr
        """
        this = _uhd_swig.new_usrp_sink_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(usrp_sink_sptr self) -> usrp_sink"""
        return _uhd_swig.usrp_sink_sptr___deref__(self)

    __swig_destroy__ = _uhd_swig.delete_usrp_sink_sptr
    __del__ = lambda self: None

    def make(self, *args):
        """
        make(usrp_sink_sptr self, device_addr_t device_addr, io_type_t io_type, size_t num_channels) -> usrp_sink_sptr
        make(usrp_sink_sptr self, device_addr_t device_addr, stream_args_t stream_args, std::string const & tsb_tag_name) -> usrp_sink_sptr
        """
        return _uhd_swig.usrp_sink_sptr_make(self, *args)


    def set_start_time(self, time):
        """set_start_time(usrp_sink_sptr self, time_spec_t time)"""
        return _uhd_swig.usrp_sink_sptr_set_start_time(self, time)


    def get_usrp_info(self, *args, **kwargs):
        """get_usrp_info(usrp_sink_sptr self, size_t chan) -> string_string_dict_t"""
        return _uhd_swig.usrp_sink_sptr_get_usrp_info(self, *args, **kwargs)


    def set_dc_offset(self, *args, **kwargs):
        """set_dc_offset(usrp_sink_sptr self, std::complex< double > const & offset, size_t chan)"""
        return _uhd_swig.usrp_sink_sptr_set_dc_offset(self, *args, **kwargs)


    def set_iq_balance(self, *args, **kwargs):
        """set_iq_balance(usrp_sink_sptr self, std::complex< double > const & correction, size_t chan)"""
        return _uhd_swig.usrp_sink_sptr_set_iq_balance(self, *args, **kwargs)


    def set_subdev_spec(self, *args, **kwargs):
        """set_subdev_spec(usrp_sink_sptr self, std::string const & spec, size_t mboard)"""
        return _uhd_swig.usrp_sink_sptr_set_subdev_spec(self, *args, **kwargs)


    def get_subdev_spec(self, *args, **kwargs):
        """get_subdev_spec(usrp_sink_sptr self, size_t mboard) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_get_subdev_spec(self, *args, **kwargs)


    def get_num_mboards(self):
        """get_num_mboards(usrp_sink_sptr self) -> size_t"""
        return _uhd_swig.usrp_sink_sptr_get_num_mboards(self)


    def set_samp_rate(self, rate):
        """set_samp_rate(usrp_sink_sptr self, double rate)"""
        return _uhd_swig.usrp_sink_sptr_set_samp_rate(self, rate)


    def get_samp_rate(self):
        """get_samp_rate(usrp_sink_sptr self) -> double"""
        return _uhd_swig.usrp_sink_sptr_get_samp_rate(self)


    def get_samp_rates(self):
        """get_samp_rates(usrp_sink_sptr self) -> meta_range_t"""
        return _uhd_swig.usrp_sink_sptr_get_samp_rates(self)


    def set_center_freq(self, *args):
        """
        set_center_freq(usrp_sink_sptr self, tune_request_t tune_request, size_t chan) -> tune_result_t
        set_center_freq(usrp_sink_sptr self, double freq, size_t chan) -> tune_result_t
        """
        return _uhd_swig.usrp_sink_sptr_set_center_freq(self, *args)


    def get_center_freq(self, *args, **kwargs):
        """get_center_freq(usrp_sink_sptr self, size_t chan) -> double"""
        return _uhd_swig.usrp_sink_sptr_get_center_freq(self, *args, **kwargs)


    def get_freq_range(self, *args, **kwargs):
        """get_freq_range(usrp_sink_sptr self, size_t chan) -> meta_range_t"""
        return _uhd_swig.usrp_sink_sptr_get_freq_range(self, *args, **kwargs)


    def set_gain(self, *args):
        """
        set_gain(usrp_sink_sptr self, double gain, size_t chan)
        set_gain(usrp_sink_sptr self, double gain, std::string const & name, size_t chan)
        """
        return _uhd_swig.usrp_sink_sptr_set_gain(self, *args)


    def set_normalized_gain(self, *args, **kwargs):
        """set_normalized_gain(usrp_sink_sptr self, double norm_gain, size_t chan)"""
        return _uhd_swig.usrp_sink_sptr_set_normalized_gain(self, *args, **kwargs)


    def get_gain(self, *args):
        """
        get_gain(usrp_sink_sptr self, size_t chan) -> double
        get_gain(usrp_sink_sptr self, std::string const & name, size_t chan) -> double
        """
        return _uhd_swig.usrp_sink_sptr_get_gain(self, *args)


    def get_normalized_gain(self, *args, **kwargs):
        """get_normalized_gain(usrp_sink_sptr self, size_t chan) -> double"""
        return _uhd_swig.usrp_sink_sptr_get_normalized_gain(self, *args, **kwargs)


    def get_gain_names(self, *args, **kwargs):
        """get_gain_names(usrp_sink_sptr self, size_t chan) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_gain_names(self, *args, **kwargs)


    def get_gain_range(self, *args):
        """
        get_gain_range(usrp_sink_sptr self, size_t chan) -> meta_range_t
        get_gain_range(usrp_sink_sptr self, std::string const & name, size_t chan) -> meta_range_t
        """
        return _uhd_swig.usrp_sink_sptr_get_gain_range(self, *args)


    def set_antenna(self, *args, **kwargs):
        """set_antenna(usrp_sink_sptr self, std::string const & ant, size_t chan)"""
        return _uhd_swig.usrp_sink_sptr_set_antenna(self, *args, **kwargs)


    def get_antenna(self, *args, **kwargs):
        """get_antenna(usrp_sink_sptr self, size_t chan) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_get_antenna(self, *args, **kwargs)


    def get_antennas(self, *args, **kwargs):
        """get_antennas(usrp_sink_sptr self, size_t chan) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_antennas(self, *args, **kwargs)


    def set_bandwidth(self, *args, **kwargs):
        """set_bandwidth(usrp_sink_sptr self, double bandwidth, size_t chan)"""
        return _uhd_swig.usrp_sink_sptr_set_bandwidth(self, *args, **kwargs)


    def get_bandwidth(self, *args, **kwargs):
        """get_bandwidth(usrp_sink_sptr self, size_t chan) -> double"""
        return _uhd_swig.usrp_sink_sptr_get_bandwidth(self, *args, **kwargs)


    def get_bandwidth_range(self, *args, **kwargs):
        """get_bandwidth_range(usrp_sink_sptr self, size_t chan) -> meta_range_t"""
        return _uhd_swig.usrp_sink_sptr_get_bandwidth_range(self, *args, **kwargs)


    def get_sensor(self, *args, **kwargs):
        """get_sensor(usrp_sink_sptr self, std::string const & name, size_t chan) -> sensor_value_t"""
        return _uhd_swig.usrp_sink_sptr_get_sensor(self, *args, **kwargs)


    def get_sensor_names(self, *args, **kwargs):
        """get_sensor_names(usrp_sink_sptr self, size_t chan) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_sensor_names(self, *args, **kwargs)


    def get_dboard_sensor(self, *args, **kwargs):
        """get_dboard_sensor(usrp_sink_sptr self, std::string const & name, size_t chan) -> sensor_value_t"""
        return _uhd_swig.usrp_sink_sptr_get_dboard_sensor(self, *args, **kwargs)


    def get_dboard_sensor_names(self, *args, **kwargs):
        """get_dboard_sensor_names(usrp_sink_sptr self, size_t chan) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_dboard_sensor_names(self, *args, **kwargs)


    def get_mboard_sensor(self, *args, **kwargs):
        """get_mboard_sensor(usrp_sink_sptr self, std::string const & name, size_t mboard) -> sensor_value_t"""
        return _uhd_swig.usrp_sink_sptr_get_mboard_sensor(self, *args, **kwargs)


    def get_mboard_sensor_names(self, *args, **kwargs):
        """get_mboard_sensor_names(usrp_sink_sptr self, size_t mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_mboard_sensor_names(self, *args, **kwargs)


    def get_time_source(self, mboard):
        """get_time_source(usrp_sink_sptr self, size_t const mboard) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_get_time_source(self, mboard)


    def get_time_sources(self, mboard):
        """get_time_sources(usrp_sink_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_time_sources(self, mboard)


    def set_clock_source(self, *args, **kwargs):
        """set_clock_source(usrp_sink_sptr self, std::string const & source, size_t const mboard)"""
        return _uhd_swig.usrp_sink_sptr_set_clock_source(self, *args, **kwargs)


    def get_clock_source(self, mboard):
        """get_clock_source(usrp_sink_sptr self, size_t const mboard) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_get_clock_source(self, mboard)


    def get_clock_sources(self, mboard):
        """get_clock_sources(usrp_sink_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_clock_sources(self, mboard)


    def get_clock_rate(self, *args, **kwargs):
        """get_clock_rate(usrp_sink_sptr self, size_t mboard) -> double"""
        return _uhd_swig.usrp_sink_sptr_get_clock_rate(self, *args, **kwargs)


    def set_clock_rate(self, *args, **kwargs):
        """set_clock_rate(usrp_sink_sptr self, double rate, size_t mboard)"""
        return _uhd_swig.usrp_sink_sptr_set_clock_rate(self, *args, **kwargs)


    def get_time_now(self, *args, **kwargs):
        """get_time_now(usrp_sink_sptr self, size_t mboard) -> time_spec_t"""
        return _uhd_swig.usrp_sink_sptr_get_time_now(self, *args, **kwargs)


    def get_time_last_pps(self, *args, **kwargs):
        """get_time_last_pps(usrp_sink_sptr self, size_t mboard) -> time_spec_t"""
        return _uhd_swig.usrp_sink_sptr_get_time_last_pps(self, *args, **kwargs)


    def set_time_now(self, *args, **kwargs):
        """set_time_now(usrp_sink_sptr self, time_spec_t time_spec, size_t mboard)"""
        return _uhd_swig.usrp_sink_sptr_set_time_now(self, *args, **kwargs)


    def set_time_next_pps(self, time_spec):
        """set_time_next_pps(usrp_sink_sptr self, time_spec_t time_spec)"""
        return _uhd_swig.usrp_sink_sptr_set_time_next_pps(self, time_spec)


    def set_time_unknown_pps(self, time_spec):
        """set_time_unknown_pps(usrp_sink_sptr self, time_spec_t time_spec)"""
        return _uhd_swig.usrp_sink_sptr_set_time_unknown_pps(self, time_spec)


    def set_command_time(self, *args, **kwargs):
        """set_command_time(usrp_sink_sptr self, time_spec_t time_spec, size_t mboard)"""
        return _uhd_swig.usrp_sink_sptr_set_command_time(self, *args, **kwargs)


    def clear_command_time(self, *args, **kwargs):
        """clear_command_time(usrp_sink_sptr self, size_t mboard)"""
        return _uhd_swig.usrp_sink_sptr_clear_command_time(self, *args, **kwargs)


    def get_dboard_iface(self, *args, **kwargs):
        """get_dboard_iface(usrp_sink_sptr self, size_t chan) -> dboard_iface_sptr"""
        return _uhd_swig.usrp_sink_sptr_get_dboard_iface(self, *args, **kwargs)


    def get_device(self):
        """get_device(usrp_sink_sptr self) -> ::uhd::usrp::multi_usrp::sptr"""
        return _uhd_swig.usrp_sink_sptr_get_device(self)


    def set_user_register(self, *args, **kwargs):
        """set_user_register(usrp_sink_sptr self, uint8_t const addr, uint32_t const data, size_t mboard)"""
        return _uhd_swig.usrp_sink_sptr_set_user_register(self, *args, **kwargs)


    def set_clock_config(self, *args, **kwargs):
        """set_clock_config(usrp_sink_sptr self, clock_config_t clock_config, size_t mboard)"""
        return _uhd_swig.usrp_sink_sptr_set_clock_config(self, *args, **kwargs)


    def set_time_source(self, *args, **kwargs):
        """set_time_source(usrp_sink_sptr self, std::string const & source, size_t const mboard)"""
        return _uhd_swig.usrp_sink_sptr_set_time_source(self, *args, **kwargs)


    def set_stream_args(self, stream_args):
        """set_stream_args(usrp_sink_sptr self, stream_args_t stream_args)"""
        return _uhd_swig.usrp_sink_sptr_set_stream_args(self, stream_args)


    def get_gpio_banks(self, mboard):
        """get_gpio_banks(usrp_sink_sptr self, size_t const mboard) -> std::vector< std::string,std::allocator< std::string > >"""
        return _uhd_swig.usrp_sink_sptr_get_gpio_banks(self, mboard)


    def set_gpio_attr(self, *args, **kwargs):
        """set_gpio_attr(usrp_sink_sptr self, std::string const & bank, std::string const & attr, boost::uint32_t const value, boost::uint32_t const mask, size_t const mboard)"""
        return _uhd_swig.usrp_sink_sptr_set_gpio_attr(self, *args, **kwargs)


    def get_gpio_attr(self, *args, **kwargs):
        """get_gpio_attr(usrp_sink_sptr self, std::string const & bank, std::string const & attr, size_t const mboard) -> boost::uint32_t"""
        return _uhd_swig.usrp_sink_sptr_get_gpio_attr(self, *args, **kwargs)


    def history(self):
        """history(usrp_sink_sptr self) -> unsigned int"""
        return _uhd_swig.usrp_sink_sptr_history(self)


    def declare_sample_delay(self, *args):
        """
        declare_sample_delay(usrp_sink_sptr self, int which, int delay)
        declare_sample_delay(usrp_sink_sptr self, unsigned int delay)
        """
        return _uhd_swig.usrp_sink_sptr_declare_sample_delay(self, *args)


    def sample_delay(self, which):
        """sample_delay(usrp_sink_sptr self, int which) -> unsigned int"""
        return _uhd_swig.usrp_sink_sptr_sample_delay(self, which)


    def output_multiple(self):
        """output_multiple(usrp_sink_sptr self) -> int"""
        return _uhd_swig.usrp_sink_sptr_output_multiple(self)


    def relative_rate(self):
        """relative_rate(usrp_sink_sptr self) -> double"""
        return _uhd_swig.usrp_sink_sptr_relative_rate(self)


    def start(self):
        """start(usrp_sink_sptr self) -> bool"""
        return _uhd_swig.usrp_sink_sptr_start(self)


    def stop(self):
        """stop(usrp_sink_sptr self) -> bool"""
        return _uhd_swig.usrp_sink_sptr_stop(self)


    def nitems_read(self, which_input):
        """nitems_read(usrp_sink_sptr self, unsigned int which_input) -> uint64_t"""
        return _uhd_swig.usrp_sink_sptr_nitems_read(self, which_input)


    def nitems_written(self, which_output):
        """nitems_written(usrp_sink_sptr self, unsigned int which_output) -> uint64_t"""
        return _uhd_swig.usrp_sink_sptr_nitems_written(self, which_output)


    def max_noutput_items(self):
        """max_noutput_items(usrp_sink_sptr self) -> int"""
        return _uhd_swig.usrp_sink_sptr_max_noutput_items(self)


    def set_max_noutput_items(self, m):
        """set_max_noutput_items(usrp_sink_sptr self, int m)"""
        return _uhd_swig.usrp_sink_sptr_set_max_noutput_items(self, m)


    def unset_max_noutput_items(self):
        """unset_max_noutput_items(usrp_sink_sptr self)"""
        return _uhd_swig.usrp_sink_sptr_unset_max_noutput_items(self)


    def is_set_max_noutput_items(self):
        """is_set_max_noutput_items(usrp_sink_sptr self) -> bool"""
        return _uhd_swig.usrp_sink_sptr_is_set_max_noutput_items(self)


    def set_min_noutput_items(self, m):
        """set_min_noutput_items(usrp_sink_sptr self, int m)"""
        return _uhd_swig.usrp_sink_sptr_set_min_noutput_items(self, m)


    def min_noutput_items(self):
        """min_noutput_items(usrp_sink_sptr self) -> int"""
        return _uhd_swig.usrp_sink_sptr_min_noutput_items(self)


    def max_output_buffer(self, i):
        """max_output_buffer(usrp_sink_sptr self, int i) -> long"""
        return _uhd_swig.usrp_sink_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(usrp_sink_sptr self, long max_output_buffer)
        set_max_output_buffer(usrp_sink_sptr self, int port, long max_output_buffer)
        """
        return _uhd_swig.usrp_sink_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(usrp_sink_sptr self, int i) -> long"""
        return _uhd_swig.usrp_sink_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(usrp_sink_sptr self, long min_output_buffer)
        set_min_output_buffer(usrp_sink_sptr self, int port, long min_output_buffer)
        """
        return _uhd_swig.usrp_sink_sptr_set_min_output_buffer(self, *args)


    def pc_noutput_items(self):
        """pc_noutput_items(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_noutput_items(self)


    def pc_noutput_items_avg(self):
        """pc_noutput_items_avg(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_noutput_items_avg(self)


    def pc_noutput_items_var(self):
        """pc_noutput_items_var(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_noutput_items_var(self)


    def pc_nproduced(self):
        """pc_nproduced(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_nproduced(self)


    def pc_nproduced_avg(self):
        """pc_nproduced_avg(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_nproduced_avg(self)


    def pc_nproduced_var(self):
        """pc_nproduced_var(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_nproduced_var(self)


    def pc_input_buffers_full(self, *args):
        """
        pc_input_buffers_full(usrp_sink_sptr self, int which) -> float
        pc_input_buffers_full(usrp_sink_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_sink_sptr_pc_input_buffers_full(self, *args)


    def pc_input_buffers_full_avg(self, *args):
        """
        pc_input_buffers_full_avg(usrp_sink_sptr self, int which) -> float
        pc_input_buffers_full_avg(usrp_sink_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_sink_sptr_pc_input_buffers_full_avg(self, *args)


    def pc_input_buffers_full_var(self, *args):
        """
        pc_input_buffers_full_var(usrp_sink_sptr self, int which) -> float
        pc_input_buffers_full_var(usrp_sink_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_sink_sptr_pc_input_buffers_full_var(self, *args)


    def pc_output_buffers_full(self, *args):
        """
        pc_output_buffers_full(usrp_sink_sptr self, int which) -> float
        pc_output_buffers_full(usrp_sink_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_sink_sptr_pc_output_buffers_full(self, *args)


    def pc_output_buffers_full_avg(self, *args):
        """
        pc_output_buffers_full_avg(usrp_sink_sptr self, int which) -> float
        pc_output_buffers_full_avg(usrp_sink_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_sink_sptr_pc_output_buffers_full_avg(self, *args)


    def pc_output_buffers_full_var(self, *args):
        """
        pc_output_buffers_full_var(usrp_sink_sptr self, int which) -> float
        pc_output_buffers_full_var(usrp_sink_sptr self) -> pmt_vector_float
        """
        return _uhd_swig.usrp_sink_sptr_pc_output_buffers_full_var(self, *args)


    def pc_work_time(self):
        """pc_work_time(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_work_time(self)


    def pc_work_time_avg(self):
        """pc_work_time_avg(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_work_time_avg(self)


    def pc_work_time_var(self):
        """pc_work_time_var(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_work_time_var(self)


    def pc_work_time_total(self):
        """pc_work_time_total(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_work_time_total(self)


    def pc_throughput_avg(self):
        """pc_throughput_avg(usrp_sink_sptr self) -> float"""
        return _uhd_swig.usrp_sink_sptr_pc_throughput_avg(self)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(usrp_sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _uhd_swig.usrp_sink_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(usrp_sink_sptr self)"""
        return _uhd_swig.usrp_sink_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(usrp_sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _uhd_swig.usrp_sink_sptr_processor_affinity(self)


    def active_thread_priority(self):
        """active_thread_priority(usrp_sink_sptr self) -> int"""
        return _uhd_swig.usrp_sink_sptr_active_thread_priority(self)


    def thread_priority(self):
        """thread_priority(usrp_sink_sptr self) -> int"""
        return _uhd_swig.usrp_sink_sptr_thread_priority(self)


    def set_thread_priority(self, priority):
        """set_thread_priority(usrp_sink_sptr self, int priority) -> int"""
        return _uhd_swig.usrp_sink_sptr_set_thread_priority(self, priority)


    def name(self):
        """name(usrp_sink_sptr self) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_name(self)


    def symbol_name(self):
        """symbol_name(usrp_sink_sptr self) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(usrp_sink_sptr self) -> io_signature_sptr"""
        return _uhd_swig.usrp_sink_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(usrp_sink_sptr self) -> io_signature_sptr"""
        return _uhd_swig.usrp_sink_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(usrp_sink_sptr self) -> long"""
        return _uhd_swig.usrp_sink_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(usrp_sink_sptr self) -> basic_block_sptr"""
        return _uhd_swig.usrp_sink_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(usrp_sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _uhd_swig.usrp_sink_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(usrp_sink_sptr self) -> std::string"""
        return _uhd_swig.usrp_sink_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(usrp_sink_sptr self, std::string name)"""
        return _uhd_swig.usrp_sink_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(usrp_sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _uhd_swig.usrp_sink_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(usrp_sink_sptr self) -> swig_int_ptr"""
        return _uhd_swig.usrp_sink_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(usrp_sink_sptr self) -> swig_int_ptr"""
        return _uhd_swig.usrp_sink_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(usrp_sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _uhd_swig.usrp_sink_sptr_message_subscribers(self, which_port)

usrp_sink_sptr_swigregister = _uhd_swig.usrp_sink_sptr_swigregister
usrp_sink_sptr_swigregister(usrp_sink_sptr)


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

class amsg_source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(gr::uhd::amsg_source)> class."""

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

    def __init__(self, *args):
        """
        __init__(boost::shared_ptr<(gr::uhd::amsg_source)> self) -> amsg_source_sptr
        __init__(boost::shared_ptr<(gr::uhd::amsg_source)> self, amsg_source p) -> amsg_source_sptr
        """
        this = _uhd_swig.new_amsg_source_sptr(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def __deref__(self):
        """__deref__(amsg_source_sptr self) -> amsg_source"""
        return _uhd_swig.amsg_source_sptr___deref__(self)

    __swig_destroy__ = _uhd_swig.delete_amsg_source_sptr
    __del__ = lambda self: None

    def make(self, device_addr, msgq):
        """make(amsg_source_sptr self, device_addr_t device_addr, msg_queue_sptr msgq) -> amsg_source_sptr"""
        return _uhd_swig.amsg_source_sptr_make(self, device_addr, msgq)


    def msg_to_async_metadata_t(self, msg):
        """msg_to_async_metadata_t(amsg_source_sptr self, message_sptr msg) -> async_metadata_t"""
        return _uhd_swig.amsg_source_sptr_msg_to_async_metadata_t(self, msg)

amsg_source_sptr_swigregister = _uhd_swig.amsg_source_sptr_swigregister
amsg_source_sptr_swigregister(amsg_source_sptr)


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


def find_devices_raw(*args, **kwargs):
    """find_devices_raw(device_addr_t dev_addr) -> device_addr_vector_t"""
    return _uhd_swig.find_devices_raw(*args, **kwargs)

def get_version_string():
    """get_version_string() -> std::string"""
    return _uhd_swig.get_version_string()

cvar = _uhd_swig.cvar
ALL_MBOARDS = cvar.ALL_MBOARDS
ALL_CHANS = cvar.ALL_CHANS
ALL_GAINS = cvar.ALL_GAINS
ALL_LOS = cvar.ALL_LOS

