Changeset 81

Timestamp:

07/05/07 19:41:39 (2 years ago)

Author:

jkyllo

Message:

--

Files:

• branches/spike-20070613 tubes/tubes.py (modified) (1 diff)

branches/spike-20070613 tubes/tubes.py

@@ -28 +28 @@
-
-    def __init__(self):
+        """Initialize a new Node."""
-        self.inputs = []
-        self.outputs = []
-
-    def getInputs(self):
-s
+
-        return self.inputs
-
-    def getOutputs(self):
-s
+
-        return self.outputs
-
+class Input(object):
+    """An Input on a Node that receives incoming data."""
+    source = None
+
+    def connect(self, output):
+        """Associate this Input with the given Output so that the Input can pull data from the Output when necessary."""
+        self.source = output
+
+class Output(object):
+    """An Output on a Node that sends data to Inputs."""
+    signalListeners = []
+
+    def __init__(self):
+        """Initialize a new Output."""
+        self.signalListeners = {}
+
+    def read(self):
+        """Read data from this Output if available.  If none is available then return None.  i.e. this is non-blocking."""
+        pass
+
+    def addListener(self, listener, signal='all'):
+        self.signalListeners[signal].append(listener)
+
+    def tripSignal(self, signal):
+        if self.signalListeners.hasKey(signal):
+            listeners = self.signalListeners[signal]
+            for listener in listeners:
+                listener(self, signal)
+
+
+class NotificationCenter(Singleton):
+    def __init__(self):
+        self.listeners = {}
+
+    def _ensureListenerList(self, source, signal):
+        if not self.listeners.has_key((source, signal)):
+            self.listeners[(source, signal)] = []
+
+    def addListener(self, source, signal, callable):
+        self._ensureListenerList(source, signal)
+        self.listeners[(source, signal)].append(callable)
+
+    def removeListener(self, source, signal, func):
+        key = (source, signal)
+        if self.listeners.has_key(key):
+            f = lambda x: x not func,
+            self.listeners[key] = filter(f, self.listeners[key])
+
+    def post(self, source, signal):
+        key = (source, signal)
+        if self.listeners.has_key(key):
+            for f in self.listeners[key]:
+                f(source, signal)
+
+
-class PassthroughNode(Node):
+    class PassthroughOutput(Output):
+        def __init__(self, input=None):
+            if input is not None:
+                self.source = input
+
+        def read(self):
+            return self.source
+
-    def __init__(self):
+        Node.__init__(self)
+        i = Input()
+        self.inputs.append(i)
+        self.outputs.append(PassthroughOutput(i))
-
+
+class Singleton(object):
+    """An implementation of the Singleton pattern.  When a new Singleton is created, it first checks to see if an instance of its particular class exists.  If not, then a new instance is created.  After the created or stored instance is returned.  The Singleton is designed so that subclasses of Singleton inherit this ability thereby leaving only the implmentation work for the subclass.
+
+    >>> class Test(Singleton):
+    ...     pass
+    ...
+    >>> s = Singleton()
+    >>> s2 = Singleton()
+    >>> s == s2
+    True
+    >>> t = Test()
+    >>> t2 = Test()
+    >>> t == t2
+    True
+    >>> s == t
+    False
+    """
+    __singletons = {}
+
+    def __new__(cls, *args, **kwargs):
+        """Overrides default object creation to ensure that only one instance per class is ever returned.  These instances are stored in a dictionary on the Singleton class that is keyed on the type of the object being created."""
+        if not Singleton.__singletons.has_key(cls):
+            Singleton.__singletons[cls] = None
+
+        if Singleton.__singletons[cls] is None:
+            Singleton.__singletons[cls] = object.__new__(cls, *args, **kwargs)
+
+        return Singleton.__singletons[cls]
+