Python weakref.WeakKeyDictionary类代码示例

class LazyInvalidation(object):
  def __enter__(self):
    assert threading.current_thread() == MAIN_THREAD
    assert not evaluation_stack
    self._watchMap = WeakKeyDictionary()
    self._watchable_objects = WeakSet()
    global invalidation_strategy
    invalidation_strategy._invalidate_all()
    invalidation_strategy = self

  def _watch_object(self, object):
    if object.watcher is not None and object.watcher not in self._watchMap:
      self._watchMap[object.watcher] = WeakWatchIntermediary(object, object.watcher)

  def _add_dependency(self, object):
    if evaluation_stack:
      evaluation_stack[-1].deps.append(object)

  def _unwatch_object(self, object):
    object.invalidate()
    self._watchable_objects.discard(object)

  def __exit__(self, type, value, traceback):
    global invalidation_strategy
    invalidation_strategy = LazyConstants()
    for intermediary in self._watchMap.itervalues():
      intermediary.release()
    self._watchMap.clear()

  def _invalidate_all(self):
    raise TypeError('Cannot nest lazy_invalidation contexts')

class FrameRegistry(object):
    """
    This class implements a method to keep track of wrapped frames.  In short,
    Qt will give us frames that are QWebFrames, and we want to only deal with
    WebFrames that we control.  This registry will either wrap a given frame,
    or return the previously-wrapped one from the registry.
    """
    def __init__(self, klass, *args, **kwargs):
        self._registry = WeakKeyDictionary()
        self.klass = klass
        self.args = args
        self.kwargs = kwargs

    def wrap(self, frame):
        if frame is None:
            return None

        existing = self._registry.get(frame)
        if existing is not None:
            return existing

        # Create web frame, passing the underlying value, and ourselves.
        new = self.klass(frame, self, *self.args, **self.kwargs)
        self._registry[frame] = new
        return new

    def clear(self):
        self._registry.clear()

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 )

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)

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)

class ShapeManager( object ):
    def __init__( self, canvas ):
        self.canvasItemToPartMap = WeakKeyDictionary()
        self.canvasItemToShapeMap = WeakKeyDictionary()
        self.canvas = canvas

    def associateCanvasItemWithShape( self, canvasItem, shape ):
        self.canvasItemToShapeMap[ canvasItem ] = ref( shape )

    def associateCanvasItemWithPart( self, canvasItem, part ):
        self.canvasItemToPartMap[ canvasItem ] = mrt

    def getPartByCanvasItem( self, canvasItem ):
        return self.canvasItemToPartMap.get( canvasItem, None )

    def getShapeByCanvasItem( self, canvasItem ):
        r = self.canvasItemToShapeMap.get( canvasItem, None )
        if r != None:
            return r()
        return None

    def createComplexShape( self, molds, modelObject = None ):
        return ComplexShape( self, self.canvas, molds, modelObject )

    def createConnector( self, modelObject = None ):
        return Connector( self, self.canvas, modelObject )

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 )

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)

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)

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)

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)

 def __init__(self, latency):
     self.latency = latency
     self.mounts = WeakKeyDictionary()
     self.contexts = WeakSet()
     self.lock = RLock()
     self.cell_updates = deque()
     self._tick = Event()
     self.paths = WeakKeyDictionary()

class Signal(object):
    """
    Simple class to emit signals to connected callable receivers.
    """

    def __init__(self):
        """
        Instantiate a new object
        """
        self.funcs = WeakSet()
        self.meths = WeakKeyDictionary()

    def connect(self, c):
        """
        Connect a callable as receiver for the signal
        @param c: signal receiver
        @type c: Callable
        """
        if inspect.ismethod(c):
            if c.__self__ not in self.meths:
                self.meths[c.__self__] = set()

            self.meths[c.__self__].add(c.__func__)
        else:
            if c not in self.funcs:
                self.funcs.add(c)

    def disconnect(self, c):
        """
        Disconnect the callable from receiving the signal
        @param c: signal receiver
        @type c: Callable
        """
        if inspect.ismethod(c):
            if c.__self__ in self.meths:
                self.meths[c.__self__].remove(c.__func__)
        else:
            if c in self.funcs:
                self.funcs.remove(c)

    def disconnectAll(self):
        """
        Disconnects all signal receivers
        """
        self.funcs.clear()
        self.meths.clear()

    def emit(self, *args, **kwargs):
        """
        Fires the signal to all connected receivers
        """
        for c in self.funcs:
            c(*args, **kwargs)

        for obj, funcs in self.meths.items():
            for func in funcs:
                func(obj, *args, **kwargs)

 def __init__(self, type, default=None, nillable=False):
     if default is None and not nillable:
         raise TypeError("default must be specified if object is not nillable")
     self.type = type
     self.default = default
     self.nillable = nillable
     self.values = WeakKeyDictionary()
     self.oldvalues = WeakKeyDictionary()
     self.dirty = WeakKeyDictionary()

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 )