gnuradio_swig_python.py

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

class x_vector_gr_block_sptrPtr(x_vector_gr_block_sptr):
    def __init__(self, this):
        _swig_setattr(self, x_vector_gr_block_sptr, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, x_vector_gr_block_sptr, 'thisown', 0)
        _swig_setattr(self, x_vector_gr_block_sptr,self.__class__,x_vector_gr_block_sptr)
_gnuradio_swig_python.x_vector_gr_block_sptr_swigregister(x_vector_gr_block_sptrPtr)

class gr_block(_object):
    """Proxy of C++ gr_block class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gr_block, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gr_block, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C++ gr_block instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __del__(self, destroy=_gnuradio_swig_python.delete_gr_block):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass

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

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

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

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

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

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

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

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

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


class gr_blockPtr(gr_block):
    def __init__(self, this):
        _swig_setattr(self, gr_block, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, gr_block, 'thisown', 0)
        _swig_setattr(self, gr_block,self.__class__,gr_block)
_gnuradio_swig_python.gr_block_swigregister(gr_blockPtr)


def block_ncurrently_allocated(*args):
    """block_ncurrently_allocated() -> long"""
    return _gnuradio_swig_python.block_ncurrently_allocated(*args)
gr_block_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id ())
gr_block_sptr.block = lambda self: self

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

    def ninputs(*args): 
        """ninputs(self) -> int"""
        return _gnuradio_swig_python.gr_block_detail_sptr_ninputs(*args)

    def noutputs(*args): 
        """noutputs(self) -> int"""
        return _gnuradio_swig_python.gr_block_detail_sptr_noutputs(*args)

    def sink_p(*args): 
        """sink_p(self) -> bool"""
        return _gnuradio_swig_python.gr_block_detail_sptr_sink_p(*args)

    def source_p(*args): 
        """source_p(self) -> bool"""
        return _gnuradio_swig_python.gr_block_detail_sptr_source_p(*args)

    def set_input(*args): 
        """set_input(self, unsigned int which, gr_buffer_reader_sptr reader)"""
        return _gnuradio_swig_python.gr_block_detail_sptr_set_input(*args)

    def input(*args): 
        """input(self, unsigned int which) -> gr_buffer_reader_sptr"""
        return _gnuradio_swig_python.gr_block_detail_sptr_input(*args)

    def set_output(*args): 
        """set_output(self, unsigned int which, gr_buffer_sptr buffer)"""
        return _gnuradio_swig_python.gr_block_detail_sptr_set_output(*args)

    def output(*args): 
        """output(self, unsigned int which) -> gr_buffer_sptr"""
        return _gnuradio_swig_python.gr_block_detail_sptr_output(*args)

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


class gr_block_detail_sptrPtr(gr_block_detail_sptr):
    def __init__(self, this):
        _swig_setattr(self, gr_block_detail_sptr, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, gr_block_detail_sptr, 'thisown', 0)
        _swig_setattr(self, gr_block_detail_sptr,self.__class__,gr_block_detail_sptr)
_gnuradio_swig_python.gr_block_detail_sptr_swigregister(gr_block_detail_sptrPtr)

def block_detail(*args):
    """block_detail(unsigned int ninputs, unsigned int noutputs) -> gr_block_detail_sptr"""
    return _gnuradio_swig_python.block_detail(*args)


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

    def stop(*args): 
        """stop(self)"""
        return _gnuradio_swig_python.gr_single_threaded_scheduler_sptr_stop(*args)

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


class gr_single_threaded_scheduler_sptrPtr(gr_single_threaded_scheduler_sptr):
    def __init__(self, this):
        _swig_setattr(self, gr_single_threaded_scheduler_sptr, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, gr_single_threaded_scheduler_sptr, 'thisown', 0)
        _swig_setattr(self, gr_single_threaded_scheduler_sptr,self.__class__,gr_single_threaded_scheduler_sptr)
_gnuradio_swig_python.gr_single_threaded_scheduler_sptr_swigregister(gr_single_threaded_scheduler_sptrPtr)

def single_threaded_scheduler(*args):
    """single_threaded_scheduler(x_vector_gr_block_sptr modules) -> gr_single_threaded_scheduler_sptr"""
    return _gnuradio_swig_python.single_threaded_scheduler(*args)


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

    def type(*args): 
        """type(self) -> long"""
        return _gnuradio_swig_python.gr_message_sptr_type(*args)

    def arg1(*args): 
        """arg1(self) -> double"""
        return _gnuradio_swig_python.gr_message_sptr_arg1(*args)

    def arg2(*args): 
        """arg2(self) -> double"""
        return _gnuradio_swig_python.gr_message_sptr_arg2(*args)

    def set_type(*args): 
        """set_type(self, long type)"""
        return _gnuradio_swig_python.gr_message_sptr_set_type(*args)

    def set_arg1(*args): 
        """set_arg1(self, double arg1)"""
        return _gnuradio_swig_python.gr_message_sptr_set_arg1(*args)

    def set_arg2(*args): 
        """set_arg2(self, double arg2)"""
        return _gnuradio_swig_python.gr_message_sptr_set_arg2(*args)

    def length(*args): 
        """length(self) -> size_t"""
        return _gnuradio_swig_python.gr_message_sptr_length(*args)

    def headroom(*args): 
        """headroom(self) -> size_t"""
        return _gnuradio_swig_python.gr_message_sptr_headroom(*args)

    def tailroom(*args): 
        """tailroom(self) -> size_t"""
        return _gnuradio_swig_python.gr_message_sptr_tailroom(*args)

    def buffer_length(*args): 
        """buffer_length(self) -> size_t"""
        return _gnuradio_swig_python.gr_message_sptr_buffer_length(*args)

    def pull(*args): 
        """pull(self, size_t nb)"""
        return _gnuradio_swig_python.gr_message_sptr_pull(*args)

    def take(*args): 
        """take(self, size_t nb)"""
        return _gnuradio_swig_python.gr_message_sptr_take(*args)

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


class gr_message_sptrPtr(gr_message_sptr):
    def __init__(self, this):
        _swig_setattr(self, gr_message_sptr, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, gr_message_sptr, 'thisown', 0)
        _swig_setattr(self, gr_message_sptr,self.__class__,gr_message_sptr)
_gnuradio_swig_python.gr_message_sptr_swigregister(gr_message_sptrPtr)

class gr_message(_object):
    """Proxy of C++ gr_message class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gr_message, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gr_message, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C++ gr_message instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def __del__(self, destroy=_gnuradio_swig_python.delete_gr_message):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass

    def type(*args): 
        """type(self) -> long"""
        return _gnuradio_swig_python.gr_message_type(*args)

    def arg1(*args): 
        """arg1(self) -> double"""
        return _gnuradio_swig_python.gr_message_arg1(*args)

    def arg2(*args): 
        """arg2(self) -> double"""
        return _gnuradio_swig_python.gr_message_arg2(*args)

    def set_type(*args): 
        """set_type(self, long type)"""
        return _gnuradio_swig_python.gr_message_set_type(*args)

    def set_arg1(*args): 
        """set_arg1(self, double arg1)"""
        return _gnuradio_swig_python.gr_message_set_arg1(*args)

    def set_arg2(*args): 
        """set_arg2(self, double arg2)"""
        return _gnuradio_swig_python.gr_message_set_arg2(*args)

    def length(*args): 
        """length(self) -> size_t"""
        return _gnuradio_swig_python.gr_message_length(*args)

    def headroom(*args): 
        """headroom(self) -> size_t"""
        return _gnuradio_swig_python.gr_message_headroom(*args)

    def tail