gnuradio_swig_python.py

gnuradio软件无线电源程序.现在的手机多基于软件无线电

def io_signature(*args):
    """io_signature(int min_streams, int max_streams, size_t sizeof_stream_item) -> gr_io_signature_sptr"""
    return _gnuradio_swig_python.io_signature(*args)
class gr_io_signature(_object):
    """Proxy of C++ gr_io_signature class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gr_io_signature, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gr_io_signature, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C++ gr_io_signature instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __del__(self, destroy=_gnuradio_swig_python.delete_gr_io_signature):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass

    def min_streams(*args): 
        """min_streams(self) -> int"""
        return _gnuradio_swig_python.gr_io_signature_min_streams(*args)

    def max_streams(*args): 
        """max_streams(self) -> int"""
        return _gnuradio_swig_python.gr_io_signature_max_streams(*args)

    def sizeof_stream_item(*args): 
        """sizeof_stream_item(self, int index) -> size_t"""
        return _gnuradio_swig_python.gr_io_signature_sizeof_stream_item(*args)


class gr_io_signaturePtr(gr_io_signature):
    def __init__(self, this):
        _swig_setattr(self, gr_io_signature, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, gr_io_signature, 'thisown', 0)
        _swig_setattr(self, gr_io_signature,self.__class__,gr_io_signature)
_gnuradio_swig_python.gr_io_signature_swigregister(gr_io_signaturePtr)

class gr_buffer_sptr(_object):
    """Proxy of C++ gr_buffer_sptr class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gr_buffer_sptr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gr_buffer_sptr, name)
    def __repr__(self):
        return "<%s.%s; proxy of C++ boost::shared_ptr<gr_buffer > instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        """
        __init__(self) -> gr_buffer_sptr
        __init__(self,  p) -> gr_buffer_sptr
        """
        _swig_setattr(self, gr_buffer_sptr, 'this', _gnuradio_swig_python.new_gr_buffer_sptr(*args))
        _swig_setattr(self, gr_buffer_sptr, 'thisown', 1)
    def __deref__(*args): 
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_buffer_sptr___deref__(*args)

    def __del__(self, destroy=_gnuradio_swig_python.delete_gr_buffer_sptr):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class gr_buffer_sptrPtr(gr_buffer_sptr):
    def __init__(self, this):
        _swig_setattr(self, gr_buffer_sptr, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, gr_buffer_sptr, 'thisown', 0)
        _swig_setattr(self, gr_buffer_sptr,self.__class__,gr_buffer_sptr)
_gnuradio_swig_python.gr_buffer_sptr_swigregister(gr_buffer_sptrPtr)

def buffer(*args):
    """buffer(int nitems, size_t sizeof_item) -> gr_buffer_sptr"""
    return _gnuradio_swig_python.buffer(*args)

class gr_buffer_reader_sptr(_object):
    """Proxy of C++ gr_buffer_reader_sptr class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gr_buffer_reader_sptr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gr_buffer_reader_sptr, name)
    def __repr__(self):
        return "<%s.%s; proxy of C++ boost::shared_ptr<gr_buffer_reader > instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        """
        __init__(self) -> gr_buffer_reader_sptr
        __init__(self,  p) -> gr_buffer_reader_sptr
        """
        _swig_setattr(self, gr_buffer_reader_sptr, 'this', _gnuradio_swig_python.new_gr_buffer_reader_sptr(*args))
        _swig_setattr(self, gr_buffer_reader_sptr, 'thisown', 1)
    def __deref__(*args): 
        """__deref__(self)"""
        return _gnuradio_swig_python.gr_buffer_reader_sptr___deref__(*args)

    def __del__(self, destroy=_gnuradio_swig_python.delete_gr_buffer_reader_sptr):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class gr_buffer_reader_sptrPtr(gr_buffer_reader_sptr):
    def __init__(self, this):
        _swig_setattr(self, gr_buffer_reader_sptr, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, gr_buffer_reader_sptr, 'thisown', 0)
        _swig_setattr(self, gr_buffer_reader_sptr,self.__class__,gr_buffer_reader_sptr)
_gnuradio_swig_python.gr_buffer_reader_sptr_swigregister(gr_buffer_reader_sptrPtr)


def buffer_add_reader(*args):
    """buffer_add_reader(gr_buffer_sptr buf) -> gr_buffer_reader_sptr"""
    return _gnuradio_swig_python.buffer_add_reader(*args)

def buffer_ncurrently_allocated(*args):
    """buffer_ncurrently_allocated() -> long"""
    return _gnuradio_swig_python.buffer_ncurrently_allocated(*args)

def buffer_reader_ncurrently_allocated(*args):
    """buffer_reader_ncurrently_allocated() -> long"""
    return _gnuradio_swig_python.buffer_reader_ncurrently_allocated(*args)
class gr_block_sptr(_object):
    """Proxy of C++ gr_block_sptr class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gr_block_sptr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gr_block_sptr, name)
    def __repr__(self):
        return "<%s.%s; proxy of C++ boost::shared_ptr<gr_block > instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __init__(self, *args):
        """
        __init__(self) -> gr_block_sptr
        __init__(self, gr_block p) -> gr_block_sptr
        """
        _swig_setattr(self, gr_block_sptr, 'this', _gnuradio_swig_python.new_gr_block_sptr(*args))
        _swig_setattr(self, gr_block_sptr, 'thisown', 1)
    def __deref__(*args): 
        """__deref__(self) -> gr_block"""
        return _gnuradio_swig_python.gr_block_sptr___deref__(*args)

    def name(*args): 
        """name(self) -> string"""
        return _gnuradio_swig_python.gr_block_sptr_name(*args)

    def input_signature(*args): 
        """input_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_block_sptr_input_signature(*args)

    def output_signature(*args): 
        """output_signature(self) -> gr_io_signature_sptr"""
        return _gnuradio_swig_python.gr_block_sptr_output_signature(*args)

    def unique_id(*args): 
        """unique_id(self) -> long"""
        return _gnuradio_swig_python.gr_block_sptr_unique_id(*args)

    def output_multiple(*args): 
        """output_multiple(self) -> int"""
        return _gnuradio_swig_python.gr_block_sptr_output_multiple(*args)

    def relative_rate(*args): 
        """relative_rate(self) -> double"""
        return _gnuradio_swig_python.gr_block_sptr_relative_rate(*args)

    def check_topology(*args): 
        """check_topology(self, int ninputs, int noutputs) -> bool"""
        return _gnuradio_swig_python.gr_block_sptr_check_topology(*args)

    def detail(*args): 
        """detail(self) -> gr_block_detail_sptr"""
        return _gnuradio_swig_python.gr_block_sptr_detail(*args)

    def set_detail(*args): 
        """set_detail(self, gr_block_detail_sptr detail)"""
        return _gnuradio_swig_python.gr_block_sptr_set_detail(*args)

    def __del__(self, destroy=_gnuradio_swig_python.delete_gr_block_sptr):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class gr_block_sptrPtr(gr_block_sptr):
    def __init__(self, this):
        _swig_setattr(self, gr_block_sptr, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, gr_block_sptr, 'thisown', 0)
        _swig_setattr(self, gr_block_sptr,self.__class__,gr_block_sptr)
_gnuradio_swig_python.gr_block_sptr_swigregister(gr_block_sptrPtr)

class x_vector_gr_block_sptr(_object):
    """Proxy of C++ x_vector_gr_block_sptr class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, x_vector_gr_block_sptr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, x_vector_gr_block_sptr, name)
    def __repr__(self):
        return "<%s.%s; proxy of C++ std::vector<gr_block_sptr > instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def empty(*args): 
        """empty(self) -> bool"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr_empty(*args)

    def size(*args): 
        """size(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::size_type"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr_size(*args)

    def clear(*args): 
        """clear(self)"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr_clear(*args)

    def swap(*args): 
        """swap(self, x_vector_gr_block_sptr v)"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr_swap(*args)

    def get_allocator(*args): 
        """get_allocator(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::allocator_type"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr_get_allocator(*args)

    def pop_back(*args): 
        """pop_back(self)"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr_pop_back(*args)

    def __init__(self, *args):
        """
        __init__(self) -> x_vector_gr_block_sptr
        __init__(self, x_vector_gr_block_sptr ??) -> x_vector_gr_block_sptr
        __init__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::size_type size) -> x_vector_gr_block_sptr
        __init__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::size_type size, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::value_type value) -> x_vector_gr_block_sptr
        """
        _swig_setattr(self, x_vector_gr_block_sptr, 'this', _gnuradio_swig_python.new_x_vector_gr_block_sptr(*args))
        _swig_setattr(self, x_vector_gr_block_sptr, 'thisown', 1)
    def push_back(*args): 
        """push_back(self, std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x)"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr_push_back(*args)

    def front(*args): 
        """front(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::value_type"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr_front(*args)

    def back(*args): 
        """back(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::value_type"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr_back(*args)

    def assign(*args): 
        """
        assign(self, std::vector<(boost::shared_ptr<(gr_block)>)>::size_type n, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x)
        """
        return _gnuradio_swig_python.x_vector_gr_block_sptr_assign(*args)

    def resize(*args): 
        """
        resize(self, std::vector<(boost::shared_ptr<(gr_block)>)>::size_type new_size)
        resize(self, std::vector<(boost::shared_ptr<(gr_block)>)>::size_type new_size, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x)
        """
        return _gnuradio_swig_python.x_vector_gr_block_sptr_resize(*args)

    def reserve(*args): 
        """reserve(self, std::vector<(boost::shared_ptr<(gr_block)>)>::size_type n)"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr_reserve(*args)

    def capacity(*args): 
        """capacity(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::size_type"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr_capacity(*args)

    def __nonzero__(*args): 
        """__nonzero__(self) -> bool"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr___nonzero__(*args)

    def __len__(*args): 
        """__len__(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::size_type"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr___len__(*args)

    def pop(*args): 
        """pop(self) -> std::vector<(boost::shared_ptr<(gr_block)>)>::value_type"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr_pop(*args)

    def __getslice__(*args): 
        """
        __getslice__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type j) -> std::vector<(gr_block_sptr,std::allocator<(boost::shared_ptr<(gr_block)>)>)>
        """
        return _gnuradio_swig_python.x_vector_gr_block_sptr___getslice__(*args)

    def __setslice__(*args): 
        """
        __setslice__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type j, 
            std::vector<(gr_block_sptr,std::allocator<(boost::shared_ptr<(gr_block)>)>)> v)
        """
        return _gnuradio_swig_python.x_vector_gr_block_sptr___setslice__(*args)

    def __delslice__(*args): 
        """
        __delslice__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type j)
        """
        return _gnuradio_swig_python.x_vector_gr_block_sptr___delslice__(*args)

    def __delitem__(*args): 
        """__delitem__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type i)"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr___delitem__(*args)

    def __getitem__(*args): 
        """__getitem__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type i) -> std::vector<(boost::shared_ptr<(gr_block)>)>::value_type"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr___getitem__(*args)

    def __setitem__(*args): 
        """
        __setitem__(self, std::vector<(boost::shared_ptr<(gr_block)>)>::difference_type i, 
            std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x)
        """
        return _gnuradio_swig_python.x_vector_gr_block_sptr___setitem__(*args)

    def append(*args): 
        """append(self, std::vector<(boost::shared_ptr<(gr_block)>)>::value_type x)"""
        return _gnuradio_swig_python.x_vector_gr_block_sptr_append(*args)

    def __del__(self, destroy=_gnuradio_swig_python.delete_x_vector_gr_block_sptr):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass