Python WeakKeyDictionary.keys方法代码示例

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import keys [as 别名]
class EventManager:
    """
   this class is responsible for coordinating most communication between
   the Model, View and Controller.
   I use WeakKeyDictionary to keep track of the registered listeners. From the 
   python documentation:
   
   Mapping class that references keys weakly. Entries in the dictionary will 
   be discarded when there is no longer a strong reference to the key.
   
   Using this dictionary takes care of object scope, avoiding dispatching to
   a non existing listener.
   
   @todo: I need to implement event categories, avoiding spamming notifies for
   events that only matters for some listeners.
   """

    def __init__(self):
        self.listeners = WeakKeyDictionary()

    def RegisterListener(self, listener):
        self.listeners[listener] = 1

    def UnregisterListener(self, listener):
        if listener in self.listeners.keys():
            del self.listeners[listener]

    def Post(self, event):
        for listener in self.listeners.keys():
            listener.Notify(event)

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import keys [as 别名]
class EventMediator:
    def __init__(self):
        self.Listeners = WeakKeyDictionary()
        self.EventQueue = []

    def RegisterListener(self, listener):
        self.Listeners[listener] = 1

    def UnregisterListener(self, listener):
        if listener in self.Listeners.keys():
            del self.Listeners[listener]

    def Post(self, event):
        if not isinstance(event, TickEvent):
            self.EventQueue.append(event)
        else:
            Events = copy(self.EventQueue)
            self.EventQueue = []

            while len(Events) > 0:
                ev = Events.pop(0)
                for listener in self.Listeners.keys():
                    listener.Notify(ev)
            for listener in self.Listeners.keys():
                listener.Notify(event)

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import keys [as 别名]
class EventManager:
	"""this object is responsible for coordinating most communication
	between the Model, View, and Controller."""
	def __init__(self ):
		from weakref import WeakKeyDictionary
		self.listeners = WeakKeyDictionary()
		self.eventQueue= []

	#----------------------------------------------------------------------
	def RegisterListener( self, listener ):
		self.listeners[ listener ] = 1

	#----------------------------------------------------------------------
	def UnregisterListener( self, listener ):
		if listener in self.listeners.keys():
			del self.listeners[ listener ]
		
	#----------------------------------------------------------------------
	def Post( self, event ):
		if not isinstance(event, TickEvent): Debug( "     Message: " + event.name )
		for listener in self.listeners.keys():
			#NOTE: If the weakref has died, it will be 
			#automatically removed, so we don't have 
			#to worry about it.
			listener.Notify( event )

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import keys [as 别名]
class EventManager(object):
    def __init__(self):
        from weakref import WeakKeyDictionary
        self.listeners = WeakKeyDictionary()

    def register_listener(self, listener):
        """
        Register new listener

        """

        self.listeners[listener] = 1

    def unregister_listener(self, listener):
        """
        Unregister existing listener

        """

        if listener in self.listeners.keys():
            del self.listeners[listener]

    def post(self, event):
        """
        Post new event

        """

        for listener in self.listeners.keys():
            listener.notify(event)

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import keys [as 别名]
class EventManager(object):
    """
    We coordinate communication between the Model, View, and Controller.
    """
    def __init__(self):
        from weakref import WeakKeyDictionary
        self.listeners = WeakKeyDictionary()

    def register_listener(self, listener):
        """
        Adds a listener to our spam list.
        It will receive post()ed events through it's notify(event) call.
        """
        self.listeners[listener] = 1

    def unregister_listener(self, listener):
        """
        Remove a listener from our spam list.
        This is implemented but hardly used.
        Our weak ref spam list will auto remove any listeners who stop existing.
        """
        if listener in self.listeners.keys():
            del self.listeners[listener]

    def post(self, event):
        """
        Post a new event to the message queue.
        It will be broadcast to all listeners.
        """
        if not isinstance(event, TickEvent) and \
           not isinstance(event, CharUpdateEvent):
            print(str(event))                   # print the event (unless it is TickEvent)
        for listener in self.listeners.keys():
            listener.notify(event)

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import keys [as 别名]
class EventManager:

    """Event Manager -- coordinate communication between the Model,
    View, and Controller."""

    def __init__(self):
        self.listeners = WeakKeyDictionary()
        # self.event_queue= []

    def register_listener(self, listener):
        self.listeners[listener] = True

    def UnregisterListener(self, listener):
        if listener in self.listeners.keys():
            del self.listeners[listener]

    def post(self, ev):
        if not (isinstance(ev, TickEvent) or \
                isinstance(ev, StepEvent) or \
                isinstance(ev, HelpEvent) or \
                isinstance(ev, ToggleViewEvent) or \
                isinstance(ev, ToggleAutoEvent) or \
                isinstance(ev, BusyEvent) or \
                isinstance(ev, ReadyEvent)):
            debug(" ** " + ev.name)

        for listener in self.listeners.keys():
            # If the weakref has died, remove it and continue
            # through the list
            if listener is None:
                del self.listeners[listener]
                continue
            listener.notify(ev)

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import keys [as 别名]
class EventManager:
   """
   Superclass for all event managers.  Keeps a list of listeners and 
   dispatches events to them.
   """
   
   def __init__(self):
      self.listeners = WeakKeyDictionary()
      
   #--------------------------------------------------------------------------
   
   def register_listener(self,listener):
      self.listeners[listener] = 1
      
   #--------------------------------------------------------------------------
   
   def unregister_listener(self,listener):
      if listener in self.listeners.keys():
         del self.listeners[listener]
         
   #--------------------------------------------------------------------------
   
   def post(self,event):
      for listener in self.listeners.keys():
         listener.notify(event)

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import keys [as 别名]
class EventHandler:
    """this object is responsible for coordinating most communication
    between the Model, View, and Controller.
    """
    def __init__(self ):
        from weakref import WeakKeyDictionary
        self.listeners = WeakKeyDictionary()

    #----------------------------------------------------------------------
    def register_listener( self, listener ):
        self.listeners[ listener ] = 1

    #----------------------------------------------------------------------
    def unregister_listener( self, listener ):
        if listener in self.listeners.keys():
            del self.listeners[ listener ]

    #----------------------------------------------------------------------
    def post( self, event ):
        """Post a new event.  It will be broadcast to all listeners"""
        for listener in self.listeners.keys():
            #NOTE: If the weakref has died, it will be
            #automatically removed, so we don't have
            #to worry about it.
            listener.notify( event )

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import keys [as 别名]
class EventManager:
    """this object is responsible for coordinating most communication
    between the Model, View, and Controller."""
    def __init__(self, initlist=None ):
        self.listeners = WeakKeyDictionary()
        self.eventQueue = []
     
        self.__lock = threading.Lock()


    #----------------------------------------------------------------------
    def RegisterListener( self, listener , eventList):
        #if not hasattr( listener, "Notify" ): raise blah blah...
        self.listeners[ listener ] = eventList
    
    def addListener(self, listener, eventList):
    
        if self.listeners.has_key( listener ):
            self.listeners[ listener ].append( eventList )
        else:
            self.listeners[ listener ] = eventList

    #----------------------------------------------------------------------
    def UnregisterListener( self, listener ):
        if listener in self.listeners.keys():
            del self.listeners[ listener ]
        
    #----------------------------------------------------------------------
    def Post( self, event ):

        if event==OneSecondEvent:
            self.sendEvent( event )
                
        if not event==TickEvent: 
            self.__lock.acquire()
            self.eventQueue.append( event )
            self.__lock.release()
        else:
            self.flushEvents()

            #at the end, notify listeners of the Tick event
            for listener in self.listeners.keys():
                listener.Notify( event )
        
        
    def flushEvents(self):
        if self.eventQueue:
            for k in range(len(self.eventQueue)):
                ev = self.eventQueue.pop(0)
                self.sendEvent(ev)
                
    def sendEvent(self, ev):
        for listener in self.listeners.keys():
            throwable_events = self.listeners[listener]
            if ev in throwable_events:
                listener.Notify( ev )

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import keys [as 别名]
class EventManager:
    def __init__(self):
        from weakref import WeakKeyDictionary
        self.listeners = WeakKeyDictionary()
    def RegisterListener(self, listener):
        self.listeners[listener] = 1
    def UnregisterListener(self, listener):
        if listener in self.listeners.keys():
            del self.listeners[ listener ]
    def Post(self, event):
        for listener in self.listeners.keys():
            listener.Notify( event )

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import keys [as 别名]
class EventManager(object):
    def __init__(self):
        self.listeners = WeakKeyDictionary()
    
    def register_listener(self, listener):
        self.listeners[listener] = 1

    def unregister_listener(self, listener):
        if listener in self.listeners.keys():
            del self.listeners[listener]

    def post(self, event):
        for listener in self.listeners.keys():
            listener.notify(event)

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import keys [as 别名]
class EventManager:
    """this object is responsible for coordinating most communication
    between the Model, View, and Controller."""
    def __init__(self ):
        self.listeners = WeakKeyDictionary()
        self.eventQueue= []

    #----------------------------------------------------------------------
    def RegisterListener( self, listener ):
        #if not hasattr( listener, "Notify" ): raise blah blah...
        self.listeners[ listener ] = 1

    #----------------------------------------------------------------------
    def UnregisterListener( self, listener ):
        if listener in self.listeners.keys():
            del self.listeners[ listener ]
        
    #----------------------------------------------------------------------
    def Post( self, event ):
        from copy import copy
        if not isinstance(event, TickEvent): 
            self.eventQueue.append( event )
        else:
            events = copy( self.eventQueue )
            self.eventQueue = []
            while len(events) > 0:
                ev = events.pop(0)
                #self.Debug( ev )

                for listener in self.listeners.keys():
                    listener.Notify( ev )

            #at the end, notify listeners of the Tick event
            for listener in self.listeners.keys():
                listener.Notify( event )
        
    def Send( self, event ):
        for listener in self.listeners.keys():
            listener.Notify( event )
            
    def SendAll( self ):
        from copy import copy
        events = copy( self.eventQueue )
        self.eventQueue = []
        while len(events) > 0:
            ev = events.pop(0)
            #self.Debug( ev )

            for listener in self.listeners.keys():
                listener.Notify( ev )

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import keys [as 别名]
class Manager(object):

    """The manager object receives all the events and forwards them to the
    interested objects.
    """
    
    def __init__(self):
        self.listeners = WeakKeyDictionary()
        self.eventQueue = Deferred() # Uses a deferred object to handle the
                                     # queueing of events
        self.eventQueue.callback(1) # kick-off the queue on initialization
                                       # so it attempts to run the next job
                                       # whenever it can
    
    def register(self, listener):
        assert isinstance(listener, Listener), "Only classes inheriting from \
the Listener base-class can register with the manager as a listener"
        self.listeners[listener] = 1
        
    def queueEvent(self, event):
        self.eventQueue.addCallbacks(self.post, self.printError, (event,) )
    
    def post(self, __, event):
        """This method is designed to be queued in a deferred object, so its
        first parameter is ignored, and its return in None, because the return
        of a callback in a deferred is passed in as the first parameter of the
        next callback method, so posts can be chained together in the
        eventQueue deferred indefinitely."""
        for listener in self.listeners.keys():
            listener.getEvent(event)
        return 1
        
    def printError(self, fail):
        print fail.getTraceback()
        fail.trap(RuntimeError)

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import keys [as 别名]
class EventManager:
    __shared_state = {}
    def __init__(self):
        self.__dict__ = self.__shared_state
        if not hasattr(self, 'listeners'):
            self.listeners = WeakKeyDictionary()
        
    def register_listener(self, listener):
        self.listeners[listener] = 1

    def unregister_listener(self, listener):
        if listener in self.listeners.keys():
            del self.listeners[listener]
        
    def post(self, event):
        for listener in self.listeners.keys():
            listener.notify(event)

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import keys [as 别名]
class EventManager(object):
    def __init__(self):
        from weakref import WeakKeyDictionary
        self.listeners = WeakKeyDictionary()

    def RegisterListener(self, listener):
        self.listeners[listener] = 1

    def UnregisterListener(self, listener):
        if listener in self.listeners.keys():
            del self.listeners[listener]

    def Post(self, event):
        if not isinstance(event, TickEvent):
            print(str(event))
        for listener in self.listeners.keys():
            listener.notify(event)