Пример #1
0
class List(list):
    def __init__(self, *args, **kwargs):
        list.__init__(self, *args, **kwargs)
        
        # addEvent(pos, item)
        self._addEvent = Event()
        # removeEvent(pos, item)
        self._removeEvent = Event()
        # setitemEvent(pos, item)
        self._setitemEvent = Event()
    
    def __setitem__(self, key, value):
        self._setitemEvent.trigger(key, value)
        return list.__setitem__(self, key, value)
    
    def __delitem__(self, key):
        self._removeEvent.trigger(key, self[key])
        return list.__delitem__(self, key)
    
    def append(self, item):
        self._addEvent.trigger(len(self), item)
        return list.append(self, item)
    
    def insert(self, pos, item):
        self._addEvent.trigger(pos, item)
        return list.insert(self, pos, item)
    
    def pop(self, pos=-1):
        self._removeEvent.trigger(pos, self[pos])
        return list.pop(self, pos)
    
    def remove(self, item):
        pos = self.index(item)
        del self[pos]
Пример #2
0
class Condition:
    def __init__(self, pf):
        if issubclass(pf.__class__, Condition):
            self._pollFunc = pf._pollFunc
            self.status = pf.status
            self.changed = pf.changed
        else:
            self._pollFunc = pf
            self.status = self._pollFunc()
            self.changed = Event()

    def poll(self):
        oldStatus = self.status
        self.status = self._pollFunc()
        if self.status != oldStatus:
            self.changed.trigger(self.status)
            
    def parentChanged(self, newStatus):
        self.poll()

    def getStatus(self):
        return self.status

    def __invert__(self):
        nc = Condition(lambda: not self.status)
        self.changed.addResponder(nc.parentChanged)
        return nc

    def __and__(self, other):
        nc = Condition(lambda: self.status and other.status)
        self.changed.addResponder(nc.parentChanged)
        other.changed.addResponder(nc.parentChanged)
        return nc

    def __or__(self, other):
        nc = Condition(lambda: self.status or other.status)
        self.changed.addResponder(nc.parentChanged)
        other.changed.addResponder(nc.parentChanged)
        return nc
Пример #3
0
class DataField:
    def __init__(self, value=None):
        self._value = value
        self._setEvent = Event()
        
    def _setInner(self, value):
        self._value = value
    
    def set(self, value):
        if value != self.get():
            self._setInner(value)
            self._setEvent.trigger(value)
    
    def get(self):
        return self._value
        
    def equals(self, value):
        return self._value == value
        
    def __str__(self):
        return str(self._value)
        
    def __repr__(self):
        return "\%s/" % (str(self.get()))
        
    def _mkcond(self, value, method, pollEvent):
        def pollFunc():
            return method(value)
        cond = Condition(pollFunc)
        def wrapPoll(*args, **kwargs):
            cond.poll()
        pollEvent.addResponder(wrapPoll)
        return cond
        
    def _equalsCond(self, value):
        return self._mkcond(value, self.equals, self._setEvent)
Пример #4
0
 def trigger(self, *args, **kwargs):
     if self._cond.status:
         return Event.trigger(self, *args, **kwargs)