# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.5
#
# 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
if 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('_osmosdr_swig', [dirname(__file__)])
        except ImportError:
            import _osmosdr_swig
            return _osmosdr_swig
        if fp is not None:
            try:
                _mod = imp.load_module('_osmosdr_swig', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _osmosdr_swig = swig_import_helper()
    del swig_import_helper
else:
    import _osmosdr_swig
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


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_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0



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



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

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

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

def high_res_timer_epoch():
    """high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _osmosdr_swig.high_res_timer_epoch()
class 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(string_vector_t self) -> SwigPyIterator"""
        return _osmosdr_swig.string_vector_t_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(string_vector_t self) -> bool"""
        return _osmosdr_swig.string_vector_t___nonzero__(self)


    def __bool__(self):
        """__bool__(string_vector_t self) -> bool"""
        return _osmosdr_swig.string_vector_t___bool__(self)


    def __len__(self):
        """__len__(string_vector_t self) -> std::vector< std::string >::size_type"""
        return _osmosdr_swig.string_vector_t___len__(self)


    def pop(self):
        """pop(string_vector_t self) -> std::vector< std::string >::value_type"""
        return _osmosdr_swig.string_vector_t_pop(self)


    def __getslice__(self, i, j):
        """__getslice__(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 _osmosdr_swig.string_vector_t___getslice__(self, i, j)


    def __setslice__(self, *args, **kwargs):
        """__setslice__(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 _osmosdr_swig.string_vector_t___setslice__(self, *args, **kwargs)


    def __delslice__(self, i, j):
        """__delslice__(string_vector_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _osmosdr_swig.string_vector_t___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(string_vector_t self, std::vector< std::string >::difference_type i)
        __delitem__(string_vector_t self, PySliceObject * slice)
        """
        return _osmosdr_swig.string_vector_t___delitem__(self, *args)


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


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


    def append(self, x):
        """append(string_vector_t self, std::vector< std::string >::value_type const & x)"""
        return _osmosdr_swig.string_vector_t_append(self, x)


    def empty(self):
        """empty(string_vector_t self) -> bool"""
        return _osmosdr_swig.string_vector_t_empty(self)


    def size(self):
        """size(string_vector_t self) -> std::vector< std::string >::size_type"""
        return _osmosdr_swig.string_vector_t_size(self)


    def clear(self):
        """clear(string_vector_t self)"""
        return _osmosdr_swig.string_vector_t_clear(self)


    def swap(self, v):
        """swap(string_vector_t self, std::vector< std::string > & v)"""
        return _osmosdr_swig.string_vector_t_swap(self, v)


    def get_allocator(self):
        """get_allocator(string_vector_t self) -> std::vector< std::string >::allocator_type"""
        return _osmosdr_swig.string_vector_t_get_allocator(self)


    def begin(self):
        """begin(string_vector_t self) -> std::vector< std::string >::iterator"""
        return _osmosdr_swig.string_vector_t_begin(self)


    def end(self):
        """end(string_vector_t self) -> std::vector< std::string >::iterator"""
        return _osmosdr_swig.string_vector_t_end(self)


    def rbegin(self):
        """rbegin(string_vector_t self) -> std::vector< std::string >::reverse_iterator"""
        return _osmosdr_swig.string_vector_t_rbegin(self)


    def rend(self):
        """rend(string_vector_t self) -> std::vector< std::string >::reverse_iterator"""
        return _osmosdr_swig.string_vector_t_rend(self)


    def pop_back(self):
        """pop_back(string_vector_t self)"""
        return _osmosdr_swig.string_vector_t_pop_back(self)


    def erase(self, *args):
        """
        erase(string_vector_t self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
        erase(string_vector_t self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
        """
        return _osmosdr_swig.string_vector_t_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::string)> self) -> string_vector_t
        __init__(std::vector<(std::string)> self, std::vector< std::string > const & arg2) -> string_vector_t
        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size) -> string_vector_t
        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> string_vector_t
        """
        this = _osmosdr_swig.new_string_vector_t(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        """push_back(string_vector_t self, std::vector< std::string >::value_type const & x)"""
        return _osmosdr_swig.string_vector_t_push_back(self, x)


    def front(self):
        """front(string_vector_t self) -> std::vector< std::string >::value_type const &"""
        return _osmosdr_swig.string_vector_t_front(self)


    def back(self):
        """back(string_vector_t self) -> std::vector< std::string >::value_type const &"""
        return _osmosdr_swig.string_vector_t_back(self)


    def assign(self, n, x):
        """assign(string_vector_t self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
        return _osmosdr_swig.string_vector_t_assign(self, n, x)


    def resize(self, *args):
        """
        resize(string_vector_t self, std::vector< std::string >::size_type new_size)
        resize(string_vector_t self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)
        """
        return _osmosdr_swig.string_vector_t_resize(self, *args)


    def insert(self, *args):
        """
        insert(string_vector_t self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator
        insert(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 _osmosdr_swig.string_vector_t_insert(self, *args)


    def reserve(self, n):
        """reserve(string_vector_t self, std::vector< std::string >::size_type n)"""
        return _osmosdr_swig.string_vector_t_reserve(self, n)


    def capacity(self):
        """capacity(string_vector_t self) -> std::vector< std::string >::size_type"""
        return _osmosdr_swig.string_vector_t_capacity(self)

    __swig_destroy__ = _osmosdr_swig.delete_string_vector_t
    __del__ = lambda self: None
string_vector_t_swigregister = _osmosdr_swig.string_vector_t_swigregister
string_vector_t_swigregister(string_vector_t)

class string_string_dict_t(object):
    """Proxy of C++ std::map<(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 iterator(self):
        """iterator(string_string_dict_t self) -> SwigPyIterator"""
        return _osmosdr_swig.string_string_dict_t_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(string_string_dict_t self) -> bool"""
        return _osmosdr_swig.string_string_dict_t___nonzero__(self)


    def __bool__(self):
        """__bool__(string_string_dict_t self) -> bool"""
        return _osmosdr_swig.string_string_dict_t___bool__(self)


    def __len__(self):
        """__len__(string_string_dict_t self) -> std::map< std::string,std::string >::size_type"""
        return _osmosdr_swig.string_string_dict_t___len__(self)

    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        """__getitem__(string_string_dict_t self, std::map< std::string,std::string >::key_type const & key) -> std::map< std::string,std::string >::mapped_type const &"""
        return _osmosdr_swig.string_string_dict_t___getitem__(self, key)


    def __delitem__(self, key):
        """__delitem__(string_string_dict_t self, std::map< std::string,std::string >::key_type const & key)"""
        return _osmosdr_swig.string_string_dict_t___delitem__(self, key)


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


    def keys(self):
        """keys(string_string_dict_t self) -> PyObject *"""
        return _osmosdr_swig.string_string_dict_t_keys(self)


    def values(self):
        """values(string_string_dict_t self) -> PyObject *"""
        return _osmosdr_swig.string_string_dict_t_values(self)


    def items(self):
        """items(string_string_dict_t self) -> PyObject *"""
        return _osmosdr_swig.string_string_dict_t_items(self)


    def __contains__(self, key):
        """__contains__(string_string_dict_t self, std::map< std::string,std::string >::key_type const & key) -> bool"""
        return _osmosdr_swig.string_string_dict_t___contains__(self, key)


    def key_iterator(self):
        """key_iterator(string_string_dict_t self) -> SwigPyIterator"""
        return _osmosdr_swig.string_string_dict_t_key_iterator(self)


    def value_iterator(self):
        """value_iterator(string_string_dict_t self) -> SwigPyIterator"""
        return _osmosdr_swig.string_string_dict_t_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(string_string_dict_t self, std::map< std::string,std::string >::key_type const & key)
        __setitem__(string_string_dict_t self, std::map< std::string,std::string >::key_type const & key, std::map< std::string,std::string >::mapped_type const & x)
        """
        return _osmosdr_swig.string_string_dict_t___setitem__(self, *args)


    def asdict(self):
        """asdict(string_string_dict_t self) -> PyObject *"""
        return _osmosdr_swig.string_string_dict_t_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(std::string,std::string)> self, std::less< std::string > const & arg2) -> string_string_dict_t
        __init__(std::map<(std::string,std::string)> self) -> string_string_dict_t
        __init__(std::map<(std::string,std::string)> self, string_string_dict_t arg2) -> string_string_dict_t
        """
        this = _osmosdr_swig.new_string_string_dict_t(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def empty(self):
        """empty(string_string_dict_t self) -> bool"""
        return _osmosdr_swig.string_string_dict_t_empty(self)


    def size(self):
        """size(string_string_dict_t self) -> std::map< std::string,std::string >::size_type"""
        return _osmosdr_swig.string_string_dict_t_size(self)


    def clear(self):
        """clear(string_string_dict_t self)"""
        return _osmosdr_swig.string_string_dict_t_clear(self)


    def swap(self, v):
        """swap(string_string_dict_t self, string_string_dict_t v)"""
        return _osmosdr_swig.string_string_dict_t_swap(self, v)


    def get_allocator(self):
        """get_allocator(string_string_dict_t self) -> std::map< std::string,std::string >::allocator_type"""
        return _osmosdr_swig.string_string_dict_t_get_allocator(self)


    def begin(self):
        """begin(string_string_dict_t self) -> std::map< std::string,std::string >::iterator"""
        return _osmosdr_swig.string_string_dict_t_begin(self)


    def end(self):
        """end(string_string_dict_t self) -> std::map< std::string,std::string >::iterator"""
        return _osmosdr_swig.string_string_dict_t_end(self)


    def rbegin(self):
        """rbegin(string_string_dict_t self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _osmosdr_swig.string_string_dict_t_rbegin(self)


    def rend(self):
        """rend(string_string_dict_t self) -> std::map< std::string,std::string >::reverse_iterator"""
        return _osmosdr_swig.string_string_dict_t_rend(self)


    def count(self, x):
        """count(string_string_dict_t self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type"""
        return _osmosdr_swig.string_string_dict_t_count(self, x)


    def erase(self, *args):
        """
        erase(string_string_dict_t self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::size_type
        erase(string_string_dict_t self, std::map< std::string,std::string >::iterator position)
        erase(string_string_dict_t self, std::map< std::string,std::string >::iterator first, std::map< std::string,std::string >::iterator last)
        """
        return _osmosdr_swig.string_string_dict_t_erase(self, *args)


    def find(self, x):
        """find(string_string_dict_t self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _osmosdr_swig.string_string_dict_t_find(self, x)


    def lower_bound(self, x):
        """lower_bound(string_string_dict_t self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _osmosdr_swig.string_string_dict_t_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(string_string_dict_t self, std::map< std::string,std::string >::key_type const & x) -> std::map< std::string,std::string >::iterator"""
        return _osmosdr_swig.string_string_dict_t_upper_bound(self, x)

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

class devices_t(object):
    """Proxy of C++ std::vector<(osmosdr::device_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(devices_t self) -> SwigPyIterator"""
        return _osmosdr_swig.devices_t_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(devices_t self) -> bool"""
        return _osmosdr_swig.devices_t___nonzero__(self)


    def __bool__(self):
        """__bool__(devices_t self) -> bool"""
        return _osmosdr_swig.devices_t___bool__(self)


    def __len__(self):
        """__len__(devices_t self) -> std::vector< osmosdr::device_t >::size_type"""
        return _osmosdr_swig.devices_t___len__(self)


    def pop(self):
        """pop(devices_t self) -> device_t"""
        return _osmosdr_swig.devices_t_pop(self)


    def __getslice__(self, i, j):
        """__getslice__(devices_t self, std::vector< osmosdr::device_t >::difference_type i, std::vector< osmosdr::device_t >::difference_type j) -> devices_t"""
        return _osmosdr_swig.devices_t___getslice__(self, i, j)


    def __setslice__(self, *args, **kwargs):
        """__setslice__(devices_t self, std::vector< osmosdr::device_t >::difference_type i, std::vector< osmosdr::device_t >::difference_type j, devices_t v)"""
        return _osmosdr_swig.devices_t___setslice__(self, *args, **kwargs)


    def __delslice__(self, i, j):
        """__delslice__(devices_t self, std::vector< osmosdr::device_t >::difference_type i, std::vector< osmosdr::device_t >::difference_type j)"""
        return _osmosdr_swig.devices_t___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(devices_t self, std::vector< osmosdr::device_t >::difference_type i)
        __delitem__(devices_t self, PySliceObject * slice)
        """
        return _osmosdr_swig.devices_t___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(devices_t self, PySliceObject * slice) -> devices_t
        __getitem__(devices_t self, std::vector< osmosdr::device_t >::difference_type i) -> device_t
        """
        return _osmosdr_swig.devices_t___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(devices_t self, PySliceObject * slice, devices_t v)
        __setitem__(devices_t self, PySliceObject * slice)
        __setitem__(devices_t self, std::vector< osmosdr::device_t >::difference_type i, device_t x)
        """
        return _osmosdr_swig.devices_t___setitem__(self, *args)


    def append(self, x):
        """append(devices_t self, device_t x)"""
        return _osmosdr_swig.devices_t_append(self, x)


    def empty(self):
        """empty(devices_t self) -> bool"""
        return _osmosdr_swig.devices_t_empty(self)


    def size(self):
        """size(devices_t self) -> std::vector< osmosdr::device_t >::size_type"""
        return _osmosdr_swig.devices_t_size(self)


    def clear(self):
        """clear(devices_t self)"""
        return _osmosdr_swig.devices_t_clear(self)


    def swap(self, v):
        """swap(devices_t self, devices_t v)"""
        return _osmosdr_swig.devices_t_swap(self, v)


    def get_allocator(self):
        """get_allocator(devices_t self) -> std::vector< osmosdr::device_t >::allocator_type"""
        return _osmosdr_swig.devices_t_get_allocator(self)


    def begin(self):
        """begin(devices_t self) -> std::vector< osmosdr::device_t >::iterator"""
        return _osmosdr_swig.devices_t_begin(self)


    def end(self):
        """end(devices_t self) -> std::vector< osmosdr::device_t >::iterator"""
        return _osmosdr_swig.devices_t_end(self)


    def rbegin(self):
        """rbegin(devices_t self) -> std::vector< osmosdr::device_t >::reverse_iterator"""
        return _osmosdr_swig.devices_t_rbegin(self)


    def rend(self):
        """rend(devices_t self) -> std::vector< osmosdr::device_t >::reverse_iterator"""
        return _osmosdr_swig.devices_t_rend(self)


    def pop_back(self):
        """pop_back(devices_t self)"""
        return _osmosdr_swig.devices_t_pop_back(self)


    def erase(self, *args):
        """
        erase(devices_t self, std::vector< osmosdr::device_t >::iterator pos) -> std::vector< osmosdr::device_t >::iterator
        erase(devices_t self, std::vector< osmosdr::device_t >::iterator first, std::vector< osmosdr::device_t >::iterator last) -> std::vector< osmosdr::device_t >::iterator
        """
        return _osmosdr_swig.devices_t_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(osmosdr::device_t)> self) -> devices_t
        __init__(std::vector<(osmosdr::device_t)> self, devices_t arg2) -> devices_t
        __init__(std::vector<(osmosdr::device_t)> self, std::vector< osmosdr::device_t >::size_type size) -> devices_t
        __init__(std::vector<(osmosdr::device_t)> self, std::vector< osmosdr::device_t >::size_type size, device_t value) -> devices_t
        """
        this = _osmosdr_swig.new_devices_t(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def push_back(self, x):
        """push_back(devices_t self, device_t x)"""
        return _osmosdr_swig.devices_t_push_back(self, x)


    def front(self):
        """front(devices_t self) -> device_t"""
        return _osmosdr_swig.devices_t_front(self)


    def back(self):
        """back(devices_t self) -> device_t"""
        return _osmosdr_swig.devices_t_back(self)


    def assign(self, n, x):
        """assign(devices_t self, std::vector< osmosdr::device_t >::size_type n, device_t x)"""
        return _osmosdr_swig.devices_t_assign(self, n, x)


    def resize(self, *args):
        """
        resize(devices_t self, std::vector< osmosdr::device_t >::size_type new_size)
        resize(devices_t self, std::vector< osmosdr::device_t >::size_type new_size, device_t x)
        """
        return _osmosdr_swig.devices_t_resize(self, *args)


    def insert(self, *args):
        """
        insert(devices_t self, std::vector< osmosdr::device_t >::iterator pos, device_t x) -> std::vector< osmosdr::device_t >::iterator
        insert(devices_t self, std::vector< osmosdr::device_t >::iterator pos, std::vector< osmosdr::device_t >::size_type n, device_t x)
        """
        return _osmosdr_swig.devices_t_insert(self, *args)


    def reserve(self, n):
        """reserve(devices_t self, std::vector< osmosdr::device_t >::size_type n)"""
        return _osmosdr_swig.devices_t_reserve(self, n)


    def capacity(self):
        """capacity(devices_t self) -> std::vector< osmosdr::device_t >::size_type"""
        return _osmosdr_swig.devices_t_capacity(self)

    __swig_destroy__ = _osmosdr_swig.delete_devices_t
    __del__ = lambda self: None
devices_t_swigregister = _osmosdr_swig.devices_t_swigregister
devices_t_swigregister(devices_t)

class device_t(string_string_dict_t):
    """Proxy of C++ osmosdr::device_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__(osmosdr::device_t self, std::string const & args) -> device_t"""
        this = _osmosdr_swig.new_device_t(*args, **kwargs)
        try:
            self.this.append(this)
        except:
            self.this = this

    def to_pp_string(self):
        """to_pp_string(device_t self) -> std::string"""
        return _osmosdr_swig.device_t_to_pp_string(self)


    def to_string(self):
        """to_string(device_t self) -> std::string"""
        return _osmosdr_swig.device_t_to_string(self)

    __swig_destroy__ = _osmosdr_swig.delete_device_t
    __del__ = lambda self: None
device_t_swigregister = _osmosdr_swig.device_t_swigregister
device_t_swigregister(device_t)

class device(object):
    """Proxy of C++ osmosdr::device class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def find(*args, **kwargs):
        """find(device_t hint) -> devices_t"""
        return _osmosdr_swig.device_find(*args, **kwargs)

    find = staticmethod(find)

    def __init__(self):
        """__init__(osmosdr::device self) -> device"""
        this = _osmosdr_swig.new_device()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _osmosdr_swig.delete_device
    __del__ = lambda self: None
device_swigregister = _osmosdr_swig.device_swigregister
device_swigregister(device)

def device_find(*args, **kwargs):
    """device_find(device_t hint) -> devices_t"""
    return _osmosdr_swig.device_find(*args, **kwargs)

class range_vector_t(object):
    """Proxy of C++ std::vector<(osmosdr::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 _osmosdr_swig.range_vector_t_iterator(self)

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

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


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


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


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


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


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


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


    def __delitem__(self, *args):
        """
        __delitem__(range_vector_t self, std::vector< osmosdr::range_t >::difference_type i)
        __delitem__(range_vector_t self, PySliceObject * slice)
        """
        return _osmosdr_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< osmosdr::range_t >::difference_type i) -> range_t
        """
        return _osmosdr_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< osmosdr::range_t >::difference_type i, range_t x)
        """
        return _osmosdr_swig.range_vector_t___setitem__(self, *args)


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


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


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


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


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


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


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


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


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


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


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


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


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

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


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


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


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


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


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


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


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

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

class range_t(object):
    """Proxy of C++ osmosdr::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__(osmosdr::range_t self, double value=0) -> range_t
        __init__(osmosdr::range_t self, double start, double stop, double step=0) -> range_t
        """
        this = _osmosdr_swig.new_range_t(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

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


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


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


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

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

class meta_range_t(range_vector_t):
    """Proxy of C++ osmosdr::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__(osmosdr::meta_range_t self) -> meta_range_t
        __init__(osmosdr::meta_range_t self, double start, double stop, double step=0) -> meta_range_t
        """
        this = _osmosdr_swig.new_meta_range_t(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

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


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


    def step(self):
        """step(meta_range_t self) -> double"""
        return _osmosdr_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 _osmosdr_swig.meta_range_t_clip(self, value, clip_step)


    def values(self):
        """values(meta_range_t self) -> pmt_vector_double"""
        return _osmosdr_swig.meta_range_t_values(self)


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

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

class source(object):
    """Proxy of C++ osmosdr::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, **kwargs):
        """make(std::string const & args) -> source_sptr"""
        return _osmosdr_swig.source_make(*args, **kwargs)

    make = staticmethod(make)

    def get_num_channels(self):
        """get_num_channels(source self) -> size_t"""
        return _osmosdr_swig.source_get_num_channels(self)


    def seek(self, seek_point, whence, chan=0):
        """seek(source self, long seek_point, int whence, size_t chan=0) -> bool"""
        return _osmosdr_swig.source_seek(self, seek_point, whence, chan)


    def get_sample_rates(self):
        """get_sample_rates(source self) -> meta_range_t"""
        return _osmosdr_swig.source_get_sample_rates(self)


    def set_sample_rate(self, rate):
        """set_sample_rate(source self, double rate) -> double"""
        return _osmosdr_swig.source_set_sample_rate(self, rate)


    def get_sample_rate(self):
        """get_sample_rate(source self) -> double"""
        return _osmosdr_swig.source_get_sample_rate(self)


    def get_freq_range(self, chan=0):
        """get_freq_range(source self, size_t chan=0) -> meta_range_t"""
        return _osmosdr_swig.source_get_freq_range(self, chan)


    def set_center_freq(self, freq, chan=0):
        """set_center_freq(source self, double freq, size_t chan=0) -> double"""
        return _osmosdr_swig.source_set_center_freq(self, freq, chan)


    def get_center_freq(self, chan=0):
        """get_center_freq(source self, size_t chan=0) -> double"""
        return _osmosdr_swig.source_get_center_freq(self, chan)


    def set_freq_corr(self, ppm, chan=0):
        """set_freq_corr(source self, double ppm, size_t chan=0) -> double"""
        return _osmosdr_swig.source_set_freq_corr(self, ppm, chan)


    def get_freq_corr(self, chan=0):
        """get_freq_corr(source self, size_t chan=0) -> double"""
        return _osmosdr_swig.source_get_freq_corr(self, chan)


    def get_gain_names(self, chan=0):
        """get_gain_names(source self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.source_get_gain_names(self, chan)


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


    def set_gain_mode(self, automatic, chan=0):
        """set_gain_mode(source self, bool automatic, size_t chan=0) -> bool"""
        return _osmosdr_swig.source_set_gain_mode(self, automatic, chan)


    def get_gain_mode(self, chan=0):
        """get_gain_mode(source self, size_t chan=0) -> bool"""
        return _osmosdr_swig.source_get_gain_mode(self, chan)


    def set_gain(self, *args):
        """
        set_gain(source self, double gain, size_t chan=0) -> double
        set_gain(source self, double gain, std::string const & name, size_t chan=0) -> double
        """
        return _osmosdr_swig.source_set_gain(self, *args)


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


    def set_if_gain(self, gain, chan=0):
        """set_if_gain(source self, double gain, size_t chan=0) -> double"""
        return _osmosdr_swig.source_set_if_gain(self, gain, chan)


    def set_bb_gain(self, gain, chan=0):
        """set_bb_gain(source self, double gain, size_t chan=0) -> double"""
        return _osmosdr_swig.source_set_bb_gain(self, gain, chan)


    def get_antennas(self, chan=0):
        """get_antennas(source self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.source_get_antennas(self, chan)


    def set_antenna(self, antenna, chan=0):
        """set_antenna(source self, std::string const & antenna, size_t chan=0) -> std::string"""
        return _osmosdr_swig.source_set_antenna(self, antenna, chan)


    def get_antenna(self, chan=0):
        """get_antenna(source self, size_t chan=0) -> std::string"""
        return _osmosdr_swig.source_get_antenna(self, chan)

    DCOffsetOff = _osmosdr_swig.source_DCOffsetOff
    DCOffsetManual = _osmosdr_swig.source_DCOffsetManual
    DCOffsetAutomatic = _osmosdr_swig.source_DCOffsetAutomatic

    def set_dc_offset_mode(self, mode, chan=0):
        """set_dc_offset_mode(source self, int mode, size_t chan=0)"""
        return _osmosdr_swig.source_set_dc_offset_mode(self, mode, chan)


    def set_dc_offset(self, offset, chan=0):
        """set_dc_offset(source self, std::complex< double > const & offset, size_t chan=0)"""
        return _osmosdr_swig.source_set_dc_offset(self, offset, chan)

    IQBalanceOff = _osmosdr_swig.source_IQBalanceOff
    IQBalanceManual = _osmosdr_swig.source_IQBalanceManual
    IQBalanceAutomatic = _osmosdr_swig.source_IQBalanceAutomatic

    def set_iq_balance_mode(self, mode, chan=0):
        """set_iq_balance_mode(source self, int mode, size_t chan=0)"""
        return _osmosdr_swig.source_set_iq_balance_mode(self, mode, chan)


    def set_iq_balance(self, balance, chan=0):
        """set_iq_balance(source self, std::complex< double > const & balance, size_t chan=0)"""
        return _osmosdr_swig.source_set_iq_balance(self, balance, chan)


    def set_bandwidth(self, bandwidth, chan=0):
        """set_bandwidth(source self, double bandwidth, size_t chan=0) -> double"""
        return _osmosdr_swig.source_set_bandwidth(self, bandwidth, chan)


    def get_bandwidth(self, chan=0):
        """get_bandwidth(source self, size_t chan=0) -> double"""
        return _osmosdr_swig.source_get_bandwidth(self, chan)


    def get_bandwidth_range(self, chan=0):
        """get_bandwidth_range(source self, size_t chan=0) -> meta_range_t"""
        return _osmosdr_swig.source_get_bandwidth_range(self, chan)

    __swig_destroy__ = _osmosdr_swig.delete_source
    __del__ = lambda self: None
source_swigregister = _osmosdr_swig.source_swigregister
source_swigregister(source)

def source_make(*args, **kwargs):
    """source_make(std::string const & args) -> source_sptr"""
    return _osmosdr_swig.source_make(*args, **kwargs)

class sink(object):
    """Proxy of C++ osmosdr::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, **kwargs):
        """make(std::string const & args) -> sink_sptr"""
        return _osmosdr_swig.sink_make(*args, **kwargs)

    make = staticmethod(make)

    def get_num_channels(self):
        """get_num_channels(sink self) -> size_t"""
        return _osmosdr_swig.sink_get_num_channels(self)


    def get_sample_rates(self):
        """get_sample_rates(sink self) -> meta_range_t"""
        return _osmosdr_swig.sink_get_sample_rates(self)


    def set_sample_rate(self, rate):
        """set_sample_rate(sink self, double rate) -> double"""
        return _osmosdr_swig.sink_set_sample_rate(self, rate)


    def get_sample_rate(self):
        """get_sample_rate(sink self) -> double"""
        return _osmosdr_swig.sink_get_sample_rate(self)


    def get_freq_range(self, chan=0):
        """get_freq_range(sink self, size_t chan=0) -> meta_range_t"""
        return _osmosdr_swig.sink_get_freq_range(self, chan)


    def set_center_freq(self, freq, chan=0):
        """set_center_freq(sink self, double freq, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_set_center_freq(self, freq, chan)


    def get_center_freq(self, chan=0):
        """get_center_freq(sink self, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_get_center_freq(self, chan)


    def set_freq_corr(self, ppm, chan=0):
        """set_freq_corr(sink self, double ppm, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_set_freq_corr(self, ppm, chan)


    def get_freq_corr(self, chan=0):
        """get_freq_corr(sink self, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_get_freq_corr(self, chan)


    def get_gain_names(self, chan=0):
        """get_gain_names(sink self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.sink_get_gain_names(self, chan)


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


    def set_gain_mode(self, automatic, chan=0):
        """set_gain_mode(sink self, bool automatic, size_t chan=0) -> bool"""
        return _osmosdr_swig.sink_set_gain_mode(self, automatic, chan)


    def get_gain_mode(self, chan=0):
        """get_gain_mode(sink self, size_t chan=0) -> bool"""
        return _osmosdr_swig.sink_get_gain_mode(self, chan)


    def set_gain(self, *args):
        """
        set_gain(sink self, double gain, size_t chan=0) -> double
        set_gain(sink self, double gain, std::string const & name, size_t chan=0) -> double
        """
        return _osmosdr_swig.sink_set_gain(self, *args)


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


    def set_if_gain(self, gain, chan=0):
        """set_if_gain(sink self, double gain, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_set_if_gain(self, gain, chan)


    def set_bb_gain(self, gain, chan=0):
        """set_bb_gain(sink self, double gain, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_set_bb_gain(self, gain, chan)


    def get_antennas(self, chan=0):
        """get_antennas(sink self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.sink_get_antennas(self, chan)


    def set_antenna(self, antenna, chan=0):
        """set_antenna(sink self, std::string const & antenna, size_t chan=0) -> std::string"""
        return _osmosdr_swig.sink_set_antenna(self, antenna, chan)


    def get_antenna(self, chan=0):
        """get_antenna(sink self, size_t chan=0) -> std::string"""
        return _osmosdr_swig.sink_get_antenna(self, chan)


    def set_dc_offset(self, offset, chan=0):
        """set_dc_offset(sink self, std::complex< double > const & offset, size_t chan=0)"""
        return _osmosdr_swig.sink_set_dc_offset(self, offset, chan)


    def set_iq_balance(self, balance, chan=0):
        """set_iq_balance(sink self, std::complex< double > const & balance, size_t chan=0)"""
        return _osmosdr_swig.sink_set_iq_balance(self, balance, chan)


    def set_bandwidth(self, bandwidth, chan=0):
        """set_bandwidth(sink self, double bandwidth, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_set_bandwidth(self, bandwidth, chan)


    def get_bandwidth(self, chan=0):
        """get_bandwidth(sink self, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_get_bandwidth(self, chan)


    def get_bandwidth_range(self, chan=0):
        """get_bandwidth_range(sink self, size_t chan=0) -> meta_range_t"""
        return _osmosdr_swig.sink_get_bandwidth_range(self, chan)

    __swig_destroy__ = _osmosdr_swig.delete_sink
    __del__ = lambda self: None
sink_swigregister = _osmosdr_swig.sink_swigregister
sink_swigregister(sink)

def sink_make(*args, **kwargs):
    """sink_make(std::string const & args) -> sink_sptr"""
    return _osmosdr_swig.sink_make(*args, **kwargs)

class source_sptr(object):
    """Proxy of C++ boost::shared_ptr<(osmosdr::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<(osmosdr::source)> self) -> source_sptr
        __init__(boost::shared_ptr<(osmosdr::source)> self, source p) -> source_sptr
        """
        this = _osmosdr_swig.new_source_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(source_sptr self) -> source"""
        return _osmosdr_swig.source_sptr___deref__(self)

    __swig_destroy__ = _osmosdr_swig.delete_source_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(source_sptr self, std::string const & args) -> source_sptr"""
        return _osmosdr_swig.source_sptr_make(self, *args, **kwargs)


    def get_num_channels(self):
        """get_num_channels(source_sptr self) -> size_t"""
        return _osmosdr_swig.source_sptr_get_num_channels(self)


    def seek(self, seek_point, whence, chan=0):
        """seek(source_sptr self, long seek_point, int whence, size_t chan=0) -> bool"""
        return _osmosdr_swig.source_sptr_seek(self, seek_point, whence, chan)


    def get_sample_rates(self):
        """get_sample_rates(source_sptr self) -> meta_range_t"""
        return _osmosdr_swig.source_sptr_get_sample_rates(self)


    def set_sample_rate(self, rate):
        """set_sample_rate(source_sptr self, double rate) -> double"""
        return _osmosdr_swig.source_sptr_set_sample_rate(self, rate)


    def get_sample_rate(self):
        """get_sample_rate(source_sptr self) -> double"""
        return _osmosdr_swig.source_sptr_get_sample_rate(self)


    def get_freq_range(self, chan=0):
        """get_freq_range(source_sptr self, size_t chan=0) -> meta_range_t"""
        return _osmosdr_swig.source_sptr_get_freq_range(self, chan)


    def set_center_freq(self, freq, chan=0):
        """set_center_freq(source_sptr self, double freq, size_t chan=0) -> double"""
        return _osmosdr_swig.source_sptr_set_center_freq(self, freq, chan)


    def get_center_freq(self, chan=0):
        """get_center_freq(source_sptr self, size_t chan=0) -> double"""
        return _osmosdr_swig.source_sptr_get_center_freq(self, chan)


    def set_freq_corr(self, ppm, chan=0):
        """set_freq_corr(source_sptr self, double ppm, size_t chan=0) -> double"""
        return _osmosdr_swig.source_sptr_set_freq_corr(self, ppm, chan)


    def get_freq_corr(self, chan=0):
        """get_freq_corr(source_sptr self, size_t chan=0) -> double"""
        return _osmosdr_swig.source_sptr_get_freq_corr(self, chan)


    def get_gain_names(self, chan=0):
        """get_gain_names(source_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.source_sptr_get_gain_names(self, chan)


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


    def set_gain_mode(self, automatic, chan=0):
        """set_gain_mode(source_sptr self, bool automatic, size_t chan=0) -> bool"""
        return _osmosdr_swig.source_sptr_set_gain_mode(self, automatic, chan)


    def get_gain_mode(self, chan=0):
        """get_gain_mode(source_sptr self, size_t chan=0) -> bool"""
        return _osmosdr_swig.source_sptr_get_gain_mode(self, chan)


    def set_gain(self, *args):
        """
        set_gain(source_sptr self, double gain, size_t chan=0) -> double
        set_gain(source_sptr self, double gain, std::string const & name, size_t chan=0) -> double
        """
        return _osmosdr_swig.source_sptr_set_gain(self, *args)


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


    def set_if_gain(self, gain, chan=0):
        """set_if_gain(source_sptr self, double gain, size_t chan=0) -> double"""
        return _osmosdr_swig.source_sptr_set_if_gain(self, gain, chan)


    def set_bb_gain(self, gain, chan=0):
        """set_bb_gain(source_sptr self, double gain, size_t chan=0) -> double"""
        return _osmosdr_swig.source_sptr_set_bb_gain(self, gain, chan)


    def get_antennas(self, chan=0):
        """get_antennas(source_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.source_sptr_get_antennas(self, chan)


    def set_antenna(self, antenna, chan=0):
        """set_antenna(source_sptr self, std::string const & antenna, size_t chan=0) -> std::string"""
        return _osmosdr_swig.source_sptr_set_antenna(self, antenna, chan)


    def get_antenna(self, chan=0):
        """get_antenna(source_sptr self, size_t chan=0) -> std::string"""
        return _osmosdr_swig.source_sptr_get_antenna(self, chan)


    def set_dc_offset_mode(self, mode, chan=0):
        """set_dc_offset_mode(source_sptr self, int mode, size_t chan=0)"""
        return _osmosdr_swig.source_sptr_set_dc_offset_mode(self, mode, chan)


    def set_dc_offset(self, offset, chan=0):
        """set_dc_offset(source_sptr self, std::complex< double > const & offset, size_t chan=0)"""
        return _osmosdr_swig.source_sptr_set_dc_offset(self, offset, chan)


    def set_iq_balance_mode(self, mode, chan=0):
        """set_iq_balance_mode(source_sptr self, int mode, size_t chan=0)"""
        return _osmosdr_swig.source_sptr_set_iq_balance_mode(self, mode, chan)


    def set_iq_balance(self, balance, chan=0):
        """set_iq_balance(source_sptr self, std::complex< double > const & balance, size_t chan=0)"""
        return _osmosdr_swig.source_sptr_set_iq_balance(self, balance, chan)


    def set_bandwidth(self, bandwidth, chan=0):
        """set_bandwidth(source_sptr self, double bandwidth, size_t chan=0) -> double"""
        return _osmosdr_swig.source_sptr_set_bandwidth(self, bandwidth, chan)


    def get_bandwidth(self, chan=0):
        """get_bandwidth(source_sptr self, size_t chan=0) -> double"""
        return _osmosdr_swig.source_sptr_get_bandwidth(self, chan)


    def get_bandwidth_range(self, chan=0):
        """get_bandwidth_range(source_sptr self, size_t chan=0) -> meta_range_t"""
        return _osmosdr_swig.source_sptr_get_bandwidth_range(self, chan)


    def primitive_connect(self, *args):
        """
        primitive_connect(source_sptr self, basic_block_sptr block)
        primitive_connect(source_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _osmosdr_swig.source_sptr_primitive_connect(self, *args)


    def primitive_msg_connect(self, *args):
        """
        primitive_msg_connect(source_sptr self, basic_block_sptr src, swig_int_ptr srcport, basic_block_sptr dst, swig_int_ptr dstport)
        primitive_msg_connect(source_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _osmosdr_swig.source_sptr_primitive_msg_connect(self, *args)


    def primitive_msg_disconnect(self, *args):
        """
        primitive_msg_disconnect(source_sptr self, basic_block_sptr src, swig_int_ptr srcport, basic_block_sptr dst, swig_int_ptr dstport)
        primitive_msg_disconnect(source_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _osmosdr_swig.source_sptr_primitive_msg_disconnect(self, *args)


    def primitive_disconnect(self, *args):
        """
        primitive_disconnect(source_sptr self, basic_block_sptr block)
        primitive_disconnect(source_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _osmosdr_swig.source_sptr_primitive_disconnect(self, *args)


    def disconnect_all(self):
        """disconnect_all(source_sptr self)"""
        return _osmosdr_swig.source_sptr_disconnect_all(self)


    def lock(self):
        """lock(source_sptr self)"""
        return _osmosdr_swig.source_sptr_lock(self)


    def unlock(self):
        """unlock(source_sptr self)"""
        return _osmosdr_swig.source_sptr_unlock(self)


    def primitive_message_port_register_hier_in(self, port_id):
        """primitive_message_port_register_hier_in(source_sptr self, swig_int_ptr port_id)"""
        return _osmosdr_swig.source_sptr_primitive_message_port_register_hier_in(self, port_id)


    def primitive_message_port_register_hier_out(self, port_id):
        """primitive_message_port_register_hier_out(source_sptr self, swig_int_ptr port_id)"""
        return _osmosdr_swig.source_sptr_primitive_message_port_register_hier_out(self, port_id)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(source_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _osmosdr_swig.source_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(source_sptr self)"""
        return _osmosdr_swig.source_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(source_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _osmosdr_swig.source_sptr_processor_affinity(self)


    def max_output_buffer(self, i):
        """max_output_buffer(source_sptr self, int i) -> size_t"""
        return _osmosdr_swig.source_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(source_sptr self, size_t max_output_buffer)
        set_max_output_buffer(source_sptr self, int port, size_t max_output_buffer)
        """
        return _osmosdr_swig.source_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(source_sptr self, int i) -> size_t"""
        return _osmosdr_swig.source_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(source_sptr self, size_t min_output_buffer)
        set_min_output_buffer(source_sptr self, int port, size_t min_output_buffer)
        """
        return _osmosdr_swig.source_sptr_set_min_output_buffer(self, *args)


    def to_hier_block2(self):
        """to_hier_block2(source_sptr self) -> hier_block2_sptr"""
        return _osmosdr_swig.source_sptr_to_hier_block2(self)


    def name(self):
        """name(source_sptr self) -> std::string"""
        return _osmosdr_swig.source_sptr_name(self)


    def symbol_name(self):
        """symbol_name(source_sptr self) -> std::string"""
        return _osmosdr_swig.source_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(source_sptr self) -> io_signature_sptr"""
        return _osmosdr_swig.source_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(source_sptr self) -> io_signature_sptr"""
        return _osmosdr_swig.source_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(source_sptr self) -> long"""
        return _osmosdr_swig.source_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(source_sptr self) -> basic_block_sptr"""
        return _osmosdr_swig.source_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(source_sptr self, int ninputs, int noutputs) -> bool"""
        return _osmosdr_swig.source_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(source_sptr self) -> std::string"""
        return _osmosdr_swig.source_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(source_sptr self, std::string name)"""
        return _osmosdr_swig.source_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(source_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _osmosdr_swig.source_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(source_sptr self) -> swig_int_ptr"""
        return _osmosdr_swig.source_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(source_sptr self) -> swig_int_ptr"""
        return _osmosdr_swig.source_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(source_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _osmosdr_swig.source_sptr_message_subscribers(self, which_port)

source_sptr_swigregister = _osmosdr_swig.source_sptr_swigregister
source_sptr_swigregister(source_sptr)

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

class sink_sptr(object):
    """Proxy of C++ boost::shared_ptr<(osmosdr::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<(osmosdr::sink)> self) -> sink_sptr
        __init__(boost::shared_ptr<(osmosdr::sink)> self, sink p) -> sink_sptr
        """
        this = _osmosdr_swig.new_sink_sptr(*args)
        try:
            self.this.append(this)
        except:
            self.this = this

    def __deref__(self):
        """__deref__(sink_sptr self) -> sink"""
        return _osmosdr_swig.sink_sptr___deref__(self)

    __swig_destroy__ = _osmosdr_swig.delete_sink_sptr
    __del__ = lambda self: None

    def make(self, *args, **kwargs):
        """make(sink_sptr self, std::string const & args) -> sink_sptr"""
        return _osmosdr_swig.sink_sptr_make(self, *args, **kwargs)


    def get_num_channels(self):
        """get_num_channels(sink_sptr self) -> size_t"""
        return _osmosdr_swig.sink_sptr_get_num_channels(self)


    def get_sample_rates(self):
        """get_sample_rates(sink_sptr self) -> meta_range_t"""
        return _osmosdr_swig.sink_sptr_get_sample_rates(self)


    def set_sample_rate(self, rate):
        """set_sample_rate(sink_sptr self, double rate) -> double"""
        return _osmosdr_swig.sink_sptr_set_sample_rate(self, rate)


    def get_sample_rate(self):
        """get_sample_rate(sink_sptr self) -> double"""
        return _osmosdr_swig.sink_sptr_get_sample_rate(self)


    def get_freq_range(self, chan=0):
        """get_freq_range(sink_sptr self, size_t chan=0) -> meta_range_t"""
        return _osmosdr_swig.sink_sptr_get_freq_range(self, chan)


    def set_center_freq(self, freq, chan=0):
        """set_center_freq(sink_sptr self, double freq, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_sptr_set_center_freq(self, freq, chan)


    def get_center_freq(self, chan=0):
        """get_center_freq(sink_sptr self, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_sptr_get_center_freq(self, chan)


    def set_freq_corr(self, ppm, chan=0):
        """set_freq_corr(sink_sptr self, double ppm, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_sptr_set_freq_corr(self, ppm, chan)


    def get_freq_corr(self, chan=0):
        """get_freq_corr(sink_sptr self, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_sptr_get_freq_corr(self, chan)


    def get_gain_names(self, chan=0):
        """get_gain_names(sink_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.sink_sptr_get_gain_names(self, chan)


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


    def set_gain_mode(self, automatic, chan=0):
        """set_gain_mode(sink_sptr self, bool automatic, size_t chan=0) -> bool"""
        return _osmosdr_swig.sink_sptr_set_gain_mode(self, automatic, chan)


    def get_gain_mode(self, chan=0):
        """get_gain_mode(sink_sptr self, size_t chan=0) -> bool"""
        return _osmosdr_swig.sink_sptr_get_gain_mode(self, chan)


    def set_gain(self, *args):
        """
        set_gain(sink_sptr self, double gain, size_t chan=0) -> double
        set_gain(sink_sptr self, double gain, std::string const & name, size_t chan=0) -> double
        """
        return _osmosdr_swig.sink_sptr_set_gain(self, *args)


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


    def set_if_gain(self, gain, chan=0):
        """set_if_gain(sink_sptr self, double gain, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_sptr_set_if_gain(self, gain, chan)


    def set_bb_gain(self, gain, chan=0):
        """set_bb_gain(sink_sptr self, double gain, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_sptr_set_bb_gain(self, gain, chan)


    def get_antennas(self, chan=0):
        """get_antennas(sink_sptr self, size_t chan=0) -> std::vector< std::string,std::allocator< std::string > >"""
        return _osmosdr_swig.sink_sptr_get_antennas(self, chan)


    def set_antenna(self, antenna, chan=0):
        """set_antenna(sink_sptr self, std::string const & antenna, size_t chan=0) -> std::string"""
        return _osmosdr_swig.sink_sptr_set_antenna(self, antenna, chan)


    def get_antenna(self, chan=0):
        """get_antenna(sink_sptr self, size_t chan=0) -> std::string"""
        return _osmosdr_swig.sink_sptr_get_antenna(self, chan)


    def set_dc_offset(self, offset, chan=0):
        """set_dc_offset(sink_sptr self, std::complex< double > const & offset, size_t chan=0)"""
        return _osmosdr_swig.sink_sptr_set_dc_offset(self, offset, chan)


    def set_iq_balance(self, balance, chan=0):
        """set_iq_balance(sink_sptr self, std::complex< double > const & balance, size_t chan=0)"""
        return _osmosdr_swig.sink_sptr_set_iq_balance(self, balance, chan)


    def set_bandwidth(self, bandwidth, chan=0):
        """set_bandwidth(sink_sptr self, double bandwidth, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_sptr_set_bandwidth(self, bandwidth, chan)


    def get_bandwidth(self, chan=0):
        """get_bandwidth(sink_sptr self, size_t chan=0) -> double"""
        return _osmosdr_swig.sink_sptr_get_bandwidth(self, chan)


    def get_bandwidth_range(self, chan=0):
        """get_bandwidth_range(sink_sptr self, size_t chan=0) -> meta_range_t"""
        return _osmosdr_swig.sink_sptr_get_bandwidth_range(self, chan)


    def primitive_connect(self, *args):
        """
        primitive_connect(sink_sptr self, basic_block_sptr block)
        primitive_connect(sink_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _osmosdr_swig.sink_sptr_primitive_connect(self, *args)


    def primitive_msg_connect(self, *args):
        """
        primitive_msg_connect(sink_sptr self, basic_block_sptr src, swig_int_ptr srcport, basic_block_sptr dst, swig_int_ptr dstport)
        primitive_msg_connect(sink_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _osmosdr_swig.sink_sptr_primitive_msg_connect(self, *args)


    def primitive_msg_disconnect(self, *args):
        """
        primitive_msg_disconnect(sink_sptr self, basic_block_sptr src, swig_int_ptr srcport, basic_block_sptr dst, swig_int_ptr dstport)
        primitive_msg_disconnect(sink_sptr self, basic_block_sptr src, std::string srcport, basic_block_sptr dst, std::string dstport)
        """
        return _osmosdr_swig.sink_sptr_primitive_msg_disconnect(self, *args)


    def primitive_disconnect(self, *args):
        """
        primitive_disconnect(sink_sptr self, basic_block_sptr block)
        primitive_disconnect(sink_sptr self, basic_block_sptr src, int src_port, basic_block_sptr dst, int dst_port)
        """
        return _osmosdr_swig.sink_sptr_primitive_disconnect(self, *args)


    def disconnect_all(self):
        """disconnect_all(sink_sptr self)"""
        return _osmosdr_swig.sink_sptr_disconnect_all(self)


    def lock(self):
        """lock(sink_sptr self)"""
        return _osmosdr_swig.sink_sptr_lock(self)


    def unlock(self):
        """unlock(sink_sptr self)"""
        return _osmosdr_swig.sink_sptr_unlock(self)


    def primitive_message_port_register_hier_in(self, port_id):
        """primitive_message_port_register_hier_in(sink_sptr self, swig_int_ptr port_id)"""
        return _osmosdr_swig.sink_sptr_primitive_message_port_register_hier_in(self, port_id)


    def primitive_message_port_register_hier_out(self, port_id):
        """primitive_message_port_register_hier_out(sink_sptr self, swig_int_ptr port_id)"""
        return _osmosdr_swig.sink_sptr_primitive_message_port_register_hier_out(self, port_id)


    def set_processor_affinity(self, mask):
        """set_processor_affinity(sink_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _osmosdr_swig.sink_sptr_set_processor_affinity(self, mask)


    def unset_processor_affinity(self):
        """unset_processor_affinity(sink_sptr self)"""
        return _osmosdr_swig.sink_sptr_unset_processor_affinity(self)


    def processor_affinity(self):
        """processor_affinity(sink_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _osmosdr_swig.sink_sptr_processor_affinity(self)


    def max_output_buffer(self, i):
        """max_output_buffer(sink_sptr self, int i) -> size_t"""
        return _osmosdr_swig.sink_sptr_max_output_buffer(self, i)


    def set_max_output_buffer(self, *args):
        """
        set_max_output_buffer(sink_sptr self, size_t max_output_buffer)
        set_max_output_buffer(sink_sptr self, int port, size_t max_output_buffer)
        """
        return _osmosdr_swig.sink_sptr_set_max_output_buffer(self, *args)


    def min_output_buffer(self, i):
        """min_output_buffer(sink_sptr self, int i) -> size_t"""
        return _osmosdr_swig.sink_sptr_min_output_buffer(self, i)


    def set_min_output_buffer(self, *args):
        """
        set_min_output_buffer(sink_sptr self, size_t min_output_buffer)
        set_min_output_buffer(sink_sptr self, int port, size_t min_output_buffer)
        """
        return _osmosdr_swig.sink_sptr_set_min_output_buffer(self, *args)


    def to_hier_block2(self):
        """to_hier_block2(sink_sptr self) -> hier_block2_sptr"""
        return _osmosdr_swig.sink_sptr_to_hier_block2(self)


    def name(self):
        """name(sink_sptr self) -> std::string"""
        return _osmosdr_swig.sink_sptr_name(self)


    def symbol_name(self):
        """symbol_name(sink_sptr self) -> std::string"""
        return _osmosdr_swig.sink_sptr_symbol_name(self)


    def input_signature(self):
        """input_signature(sink_sptr self) -> io_signature_sptr"""
        return _osmosdr_swig.sink_sptr_input_signature(self)


    def output_signature(self):
        """output_signature(sink_sptr self) -> io_signature_sptr"""
        return _osmosdr_swig.sink_sptr_output_signature(self)


    def unique_id(self):
        """unique_id(sink_sptr self) -> long"""
        return _osmosdr_swig.sink_sptr_unique_id(self)


    def to_basic_block(self):
        """to_basic_block(sink_sptr self) -> basic_block_sptr"""
        return _osmosdr_swig.sink_sptr_to_basic_block(self)


    def check_topology(self, ninputs, noutputs):
        """check_topology(sink_sptr self, int ninputs, int noutputs) -> bool"""
        return _osmosdr_swig.sink_sptr_check_topology(self, ninputs, noutputs)


    def alias(self):
        """alias(sink_sptr self) -> std::string"""
        return _osmosdr_swig.sink_sptr_alias(self)


    def set_block_alias(self, name):
        """set_block_alias(sink_sptr self, std::string name)"""
        return _osmosdr_swig.sink_sptr_set_block_alias(self, name)


    def _post(self, which_port, msg):
        """_post(sink_sptr self, swig_int_ptr which_port, swig_int_ptr msg)"""
        return _osmosdr_swig.sink_sptr__post(self, which_port, msg)


    def message_ports_in(self):
        """message_ports_in(sink_sptr self) -> swig_int_ptr"""
        return _osmosdr_swig.sink_sptr_message_ports_in(self)


    def message_ports_out(self):
        """message_ports_out(sink_sptr self) -> swig_int_ptr"""
        return _osmosdr_swig.sink_sptr_message_ports_out(self)


    def message_subscribers(self, which_port):
        """message_subscribers(sink_sptr self, swig_int_ptr which_port) -> swig_int_ptr"""
        return _osmosdr_swig.sink_sptr_message_subscribers(self, which_port)

sink_sptr_swigregister = _osmosdr_swig.sink_sptr_swigregister
sink_sptr_swigregister(sink_sptr)

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



