Python PosixReactorBase.__init__方法代码示例

# 需要导入模块: from twisted.internet.posixbase import PosixReactorBase [as 别名]
# 或者: from twisted.internet.posixbase.PosixReactorBase import __init__ [as 别名]
 def __init__(self, app=None):
     self._reads = {}
     self._writes = {}
     if app is None:
         app = QApplication([])
     self.qApp = app
     PosixReactorBase.__init__(self)
     self.addSystemEventTrigger('after', 'shutdown', self.cleanup)

# 需要导入模块: from twisted.internet.posixbase import PosixReactorBase [as 别名]
# 或者: from twisted.internet.posixbase.PosixReactorBase import __init__ [as 别名]
 def __init__(self, io_loop=None):
     if not io_loop:
         io_loop = tornado.ioloop.IOLoop.instance()
     self._io_loop = io_loop
     self._readers = {}
     self._writers = {}
     self._fds = {} # a map of fd to a (reader, writer) tuple
     self._delayedCalls = {}
     self._running = False
     self._closed = False
     PosixReactorBase.__init__(self)

# 需要导入模块: from twisted.internet.posixbase import PosixReactorBase [as 别名]
# 或者: from twisted.internet.posixbase.PosixReactorBase import __init__ [as 别名]
    def __init__(self, runLoop=None, runner=None):
        self._fdmap = {}
        self._idmap = {}
        if runner is None:
            runner = CFRunLoopRun
        self._runner = runner

        if runLoop is None:
            runLoop = CFRunLoopGetMain()
        self._cfrunloop = runLoop
        PosixReactorBase.__init__(self)

# 需要导入模块: from twisted.internet.posixbase import PosixReactorBase [as 别名]
# 或者: from twisted.internet.posixbase.PosixReactorBase import __init__ [as 别名]
 def __init__(self):
     """Initialize reactor and local fd storage."""
     # These inits really ought to be before
     # L{PosixReactorBase.__init__} call, because it adds the
     # waker in the process
     self._reads = {}
     self._writes = {}
     self._selectables = {}
     self._signal_handlers = []
     from syncless import coio
     self._wakeup_info = coio.wakeup_info()
     self._pending_events = self._wakeup_info.pending_events
     PosixReactorBase.__init__(self)

# 需要导入模块: from twisted.internet.posixbase import PosixReactorBase [as 别名]
# 或者: from twisted.internet.posixbase.PosixReactorBase import __init__ [as 别名]
	def __init__(self):
		self._reads = {}
		self._writes = {}
		self.savedTimeout = None
		self._timer = eTimer()
		self._timer.callback.append(self.simulate)
		self._insimulate = False
		self._wakeupPending = False
		# to limit the systemcalls per loop
		# twistes gets a cached monotonic time for internal timers
		# only updated once per loop (monotonic_time call in def simulate)
		PosixReactorBase.seconds = self.now
		PosixReactorBase.__init__(self)
		self.addSystemEventTrigger('after', 'shutdown', self.cleanup)

# 需要导入模块: from twisted.internet.posixbase import PosixReactorBase [as 别名]
# 或者: from twisted.internet.posixbase.PosixReactorBase import __init__ [as 别名]
 def __init__(self):
     self._reads = {}
     self._writes = {}
     self._timer = QTimer()
     self._timer.setSingleShot(True)
     if QCoreApplication.startingUp():
         self.qApp = QCoreApplication([])
         self._ownApp = True
     else:
         self.qApp = QCoreApplication.instance()
         self._ownApp = False
     self._blockApp = None
     self._readWriteQ = []
     PosixReactorBase.__init__(self)

# 需要导入模块: from twisted.internet.posixbase import PosixReactorBase [as 别名]
# 或者: from twisted.internet.posixbase.PosixReactorBase import __init__ [as 别名]
    def __init__(self):
        QObject.__init__(self)

        self._readers = {}
        self._writers = {}
        self._timer = QTimer()
        self._timer.setSingleShot(True)
        self.connect(self._timer, SIGNAL("timeout()"), self._timerSlot)

        self._eventLoop = QCoreApplication.instance()
        if self._eventLoop is None:
            # create dummy application for testing
            self._eventLoop = QCoreApplication([])

        PosixReactorBase.__init__(self)  # goes last, because it calls addReader

# 需要导入模块: from twisted.internet.posixbase import PosixReactorBase [as 别名]
# 或者: from twisted.internet.posixbase.PosixReactorBase import __init__ [as 别名]
 def __init__(self):
     self._loop = pyuv.Loop()
     self._async_handle = pyuv.Async(self._loop, self._async_cb)
     self._async_handle_lock = threading.Lock()
     self._async_callbacks = deque()
     self._readers = {}  # map of reader objects to fd
     self._writers = {}  # map of writer objects to fd
     self._fds = {}      # map of fd to a (reader, writer) tuple
     self._delayedCalls = {}
     self._poll_handles = {}
     self._signal_fds = SocketPair()
     self._signal_checker = pyuv.util.SignalChecker(self._loop, self._signal_fds.reader_fileno())
     self._signal_checker.unref()
     self._signal_checker.start()
     PosixReactorBase.__init__(self)

# 需要导入模块: from twisted.internet.posixbase import PosixReactorBase [as 别名]
# 或者: from twisted.internet.posixbase.PosixReactorBase import __init__ [as 别名]
    def __init__(self):
        self._io_loop = tornado.ioloop.IOLoop.current()
        self._readers = {}  # map of reader objects to fd
        self._writers = {}  # map of writer objects to fd
        self._fds = {}  # a map of fd to a (reader, writer) tuple
        self._delayedCalls = {}
        PosixReactorBase.__init__(self)
        self.addSystemEventTrigger('during', 'shutdown', self.crash)

        # IOLoop.start() bypasses some of the reactor initialization.
        # Fire off the necessary events if they weren't already triggered
        # by reactor.run().
        def start_if_necessary():
            if not self._started:
                self.fireSystemEvent('startup')
        self._io_loop.add_callback(start_if_necessary)

# 需要导入模块: from twisted.internet.posixbase import PosixReactorBase [as 别名]
# 或者: from twisted.internet.posixbase.PosixReactorBase import __init__ [as 别名]
 def __init__(self):
     self._reads = {}
     self._writes = {}
     self._timer=QTimer()
     self._timer.setSingleShot(True)
     if QCoreApplication.startingUp():
         self.qApp=QCoreApplication([])
         self._ownApp=True
     else:
         self.qApp = QCoreApplication.instance()
         self._ownApp=False
     self._blockApp = None
     self._readWriteQ=[]
     
     """ some debugging instrumentation """
     self._doSomethingCount=0
     
     PosixReactorBase.__init__(self)

# 需要导入模块: from twisted.internet.posixbase import PosixReactorBase [as 别名]
# 或者: from twisted.internet.posixbase.PosixReactorBase import __init__ [as 别名]
    def __init__(self, io_loop=None):
        if not io_loop:
            io_loop = tornado.ioloop.IOLoop.instance()
        self._io_loop = io_loop
        self._readers = {}  # map of reader objects to fd
        self._writers = {}  # map of writer objects to fd
        self._fds = {}  # a map of fd to a (reader, writer) tuple
        self._delayedCalls = {}
        PosixReactorBase.__init__(self)

        # IOLoop.start() bypasses some of the reactor initialization.
        # Fire off the necessary events if they weren't already triggered
        # by reactor.run().
        def start_if_necessary():
            if not self._started:
                self.fireSystemEvent("startup")

        self._io_loop.add_callback(start_if_necessary)

# 需要导入模块: from twisted.internet.posixbase import PosixReactorBase [as 别名]
# 或者: from twisted.internet.posixbase.PosixReactorBase import __init__ [as 别名]
    def __init__(self, io_loop=None):
        if not io_loop:
            io_loop = tornado.ioloop.IOLoop.instance()
        self._io_loop = io_loop
        self._readers = {}  # map of reader objects to fd
        self._writers = {}  # map of writer objects to fd
        self._fds = {}  # a map of fd to a (reader, writer) tuple
        self._delayedCalls = {}
        PosixReactorBase.__init__(self)
        # The default is a ThreadedResolver which spawns worker threads
        # from a thread pool which is probably *correct* but was quite
        # confusing and inconsistent with default Tornado behavior.
        self.installResolver(BlockingResolver())
        self.addSystemEventTrigger('during', 'shutdown', self.crash)

        # IOLoop.start() bypasses some of the reactor initialization.
        # Fire off the necessary events if they weren't already triggered
        # by reactor.run().
        def start_if_necessary():
            if not self._started:
                self.fireSystemEvent('startup')
        self._io_loop.add_callback(start_if_necessary)

# 需要导入模块: from twisted.internet.posixbase import PosixReactorBase [as 别名]
# 或者: from twisted.internet.posixbase.PosixReactorBase import __init__ [as 别名]
 def __init__(self):
     self._readers = {}
     self._writers = {}
     PosixReactorBase.__init__(self)

# 需要导入模块: from twisted.internet.posixbase import PosixReactorBase [as 别名]
# 或者: from twisted.internet.posixbase.PosixReactorBase import __init__ [as 别名]
 def __init__(self, eventloop):
     self._asyncioEventloop = eventloop
     self._writers = set()
     self._readers = set()
     self._delayedCalls = set()
     PosixReactorBase.__init__(self)