def registerTransport(self, tDomain, transport):
     if self.loopingcall is None and self.getTimerResolution() > 0:
         self.loopingcall = asyncio.async(self.handle_timeout())
     AbstractTransportDispatcher.registerTransport(
         self, tDomain, transport
         )
     self.__transportCount += 1

 def registerTransport(self, tDomain, transport):
     if not self.loopingcall.running and self.getTimerResolution() > 0:
         self.loopingcall.start(self.getTimerResolution(), now = False)
     AbstractTransportDispatcher.registerTransport(
         self, tDomain, transport
         )
     self.__transportCount = self.__transportCount + 1

 def registerTransport(self, tDomain, transport):
     if not self.loopingcall.running and self.timeout > 0:
         self.loopingcall.start(self.timeout, now = False)
     AbstractTransportDispatcher.registerTransport(
         self, tDomain, transport
         )
     self.__transportCount = self.__transportCount + 1

 def __init__(self, *args, **kwargs):
     AbstractTransportDispatcher.__init__(self)
     self.__transportCount = 0
     if 'timeout' in kwargs:
         self.setTimerResolution(kwargs['timeout'])
     self.loopingcall = task.LoopingCall(
         lambda self=self: self.handleTimerTick(time.time())
     )

 def __init__(self, *args, **kwargs):
     AbstractTransportDispatcher.__init__(self)
     self.__transportCount = 0
     if 'timeout' in kwargs:
         self.setTimerResolution(kwargs['timeout'])
     else:
         self.setTimerResolution(1.0)            
     self.loopingcall = task.LoopingCall(self.handleTimeout)

    def __init__(self, io_loop=None):
        AbstractTransportDispatcher.__init__(self)

        self.io_loop = io_loop or IOLoop.current()
        self.timer = PeriodicCallback(self.on_timer,
            self.getTimerResolution()*1000, io_loop=self.io_loop)

        self.timer.start()

    def unregisterTransport(self, tDomain):
        t = AbstractTransportDispatcher.getTransport(self, tDomain)
        if t is not None:
            AbstractTransportDispatcher.unregisterTransport(self, tDomain)
            self.__transportCount = self.__transportCount - 1

        # The last transport has been removed, stop the timeout
        if self.__transportCount == 0 and self.loopingcall.running:
            self.loopingcall.stop()

    def unregisterTransport(self, tDomain):
        t = AbstractTransportDispatcher.getTransport(self, tDomain)
        if t is not None:
            AbstractTransportDispatcher.unregisterTransport(self, tDomain)
            self.__transportCount -= 1

        # The last transport has been removed, stop the timeout
        if self.__transportCount == 0 and not self.loopingcall.done():
            self.loopingcall.cancel()
            self.loopingcall = None

    def __init__(self, *args, **kwargs):
        AbstractTransportDispatcher.__init__(self)

        self.__transportCount = 0

        if 'timeout' in kwargs:
            self.setTimerResolution(kwargs['timeout'])

        self.loopingcall = None
        self.loop = kwargs.pop('loop', asyncio.get_event_loop())

    def registerTransport(self, tDomain, transport):
        if self.loopingcall is None and self.getTimerResolution() > 0:
            # Avoid deprecation warning for asyncio.async()
            if IS_PYTHON_344_PLUS:
                self.loopingcall = asyncio.ensure_future(self.handle_timeout())

            else:
                self.loopingcall = getattr(asyncio, 'async')(self.handle_timeout())

        AbstractTransportDispatcher.registerTransport(
            self, tDomain, transport
        )

        self.__transportCount += 1

 def __init__(self, *args, **kwargs):
     AbstractTransportDispatcher.__init__(self)
     self.__transportCount = 0
     self.timeout = kwargs.get('timeout', 1.0)
     self.loopingcall = task.LoopingCall(self.handleTimeout)

 def __init__(self):
     self.__sockMap = {} # use own map for MT safety
     self.timeout = 0.5
     AbstractTransportDispatcher.__init__(self)