some work on mediator

Author: Sean-Bradley

mediator/README.md

@@ -0,0 +1,15 @@
+# Mediator Design Pattern
+
+In software engineering, the mediator pattern defines an object that encapsulates how a set of objects interact. This pattern is considered to be a behavioral pattern due to the way it can alter the program's running behavior.
+
+With the mediator pattern, communication between objects is encapsulated within a mediator object. Objects no longer communicate directly with each other, but instead communicate through the mediator. This reduces the dependencies between communicating objects, thereby reducing coupling. 
+
+The Mediator interface declares a method used by components to notify the
+mediator about various events. The Mediator may react to these events and
+pass the execution to other components.
+
+The Base Component provides the basic functionality of storing a mediator's
+instance inside component objects.
+
+Concrete Components implement various functionality. They don't depend on other
+components. They also don't depend on any concrete mediator classes.

mediator/README.py

@@ -1,12 +1,8 @@
 digraph "classes" {
 charset="utf-8"
 rankdir=BT
-"0" [label="{BaseComponent|mediator\l|}", shape="record"];
-"1" [label="{Component1|\l|do_a()\ldo_b()\l}", shape="record"];
-"2" [label="{Component2|\l|do_c()\ldo_d()\l}", shape="record"];
-"3" [label="{ConcreteMediator|\l|notify()\l}", shape="record"];
-"4" [label="{Mediator|\l|notify()\l}", shape="record"];
-"1" -> "0" [arrowhead="empty", arrowtail="none"];
-"2" -> "0" [arrowhead="empty", arrowtail="none"];
-"3" -> "4" [arrowhead="empty", arrowtail="none"];
+"0" [label="{Component|mediator\lname\l|notify()\lreceive()\l}", shape="record"];
+"1" [label="{IComponent|\l|notify()\lreceive()\l}", shape="record"];
+"2" [label="{Mediator|components : list\l|add()\lnotify()\l}", shape="record"];
+"0" -> "1" [arrowhead="empty", arrowtail="none"];
 }

mediator/classes.dot

@@ -1,89 +1,50 @@
-from __future__ import annotations
-from abc import ABC
+from abc import ABCMeta, abstractmethod
 
 
-class Mediator(ABC):
-    """
-    The Mediator interface declares a method used by components to notify the
-    mediator about various events. The Mediator may react to these events and
-    pass the execution to other components.
-    """
+class IComponent(metaclass=ABCMeta):
+    @staticmethod
+    @abstractmethod
+    def notify(msg):
+        """The required notify method"""
 
-    def notify(self, sender: object, event: str) -> None:
-        pass
+    @staticmethod
+    @abstractmethod
+    def receive(msg):
+        """The required receive method"""
 
 
-class ConcreteMediator(Mediator):
-    def __init__(self, component1: Component1, component2: Component2) -> None:
-        self._component1 = component1
-        self._component1.mediator = self
-        self._component2 = component2
-        self._component2.mediator = self
+class Component(IComponent):
+    def __init__(self, mediator, name):
+        self.mediator = mediator
+        self.name = name
 
-    def notify(self, sender: object, event: str) -> None:
-        if event == "A":
-            print("Mediator reacts on A and triggers following operations:")
-            self._component2.do_c()
-        elif event == "D":
-            print("Mediator reacts on D and triggers following operations:")
-            self._component1.do_b()
-            self._component2.do_c()
+    def notify(self, message):
+        print(self.name + ": Sending : " + message)
+        self.mediator.notify(message, self)
 
+    def receive(self, message):
+        print(self.name + ": Received : " + message)
 
-class BaseComponent:
-    """
-    The Base Component provides the basic functionality of storing a mediator's
-    instance inside component objects.
-    """
 
-    def __init__(self, mediator: Mediator = None) -> None:
-        self._mediator = mediator
+class Mediator:
+    def __init__(self):
+        self.components = []
 
-    @property
-    def mediator(self) -> Mediator:
-        return self._mediator
+    def add(self, component):
+        self.components.append(component)
 
-    @mediator.setter
-    def mediator(self, mediator: Mediator) -> None:
-        self._mediator = mediator
+    def notify(self, message, component):
+        for _component in self.components:
+            if _component != component:
+                _component.receive(message)
 
 
-"""
-Concrete Components implement various functionality. They don't depend on other
-components. They also don't depend on any concrete mediator classes.
-"""
+MEDIATOR = Mediator()
+COMPONENT1 = Component(MEDIATOR, "Component1")
+COMPONENT2 = Component(MEDIATOR, "Component2")
+COMPONENT3 = Component(MEDIATOR, "Component3")
+MEDIATOR.add(COMPONENT1)
+MEDIATOR.add(COMPONENT2)
+MEDIATOR.add(COMPONENT3)
 
-
-class Component1(BaseComponent):
-    def do_a(self) -> None:
-        print("Component 1 does A.")
-        self.mediator.notify(self, "A")
-
-    def do_b(self) -> None:
-        print("Component 1 does B.")
-        self.mediator.notify(self, "B")
-
-
-class Component2(BaseComponent):
-    def do_c(self) -> None:
-        print("Component 2 does C.")
-        self.mediator.notify(self, "C")
-
-    def do_d(self) -> None:
-        print("Component 2 does D.")
-        self.mediator.notify(self, "D")
-
-
-if __name__ == "__main__":
-    # The client code.
-    c1 = Component1()
-    c2 = Component2()
-    mediator = ConcreteMediator(c1, c2)
-
-    print("Client triggers operation A.")
-    c1.do_a()
-
-    print("\n", end="")
-
-    print("Client triggers operation D.")
-    c2.do_d()
+COMPONENT1.notify("Lets Play")