updates

Author: Sean-Bradley

mediator/client.py

@@ -1,40 +1,15 @@
-"Mediator Pattern Example Code"
-
-
-from game_engine import GameEngine
-from game_client import GameClient
-from player import Player
-from scheduler import Scheduler
-
-# The concrete GameEngine process that would run on a dedicated server
-GAMEENGINE = GameEngine()
-
-# 3 Hypothetical game clients, all running externally on mobile phones
-# calling the GAMEENGINE mediator across a network proxy
-MOBILECLIENT1 = GameClient(GAMEENGINE)
-PLAYER1 = Player("Sean", 100)
-MOBILECLIENT1.add_player(PLAYER1)
-
-MOBILECLIENT2 = GameClient(GAMEENGINE)
-PLAYER2 = Player("Cosmo", 200)
-MOBILECLIENT2.add_player(PLAYER2)
-
-MOBILECLIENT3 = GameClient(GAMEENGINE)
-PLAYER3 = Player("Emmy", 300, )
-MOBILECLIENT3.add_player(PLAYER3)
-
-# A scheduler is a separate process that manages game rounds and
-# triggers game events at time intervals
-SCHEDULER = Scheduler(GAMEENGINE)
-SCHEDULER.new_game()
-
-# 3 Hypothetical game clients have received notifications of new game,
-# they now place there bets
-PLAYER1.place_bets([1, 2, 3])
-PLAYER2.place_bets([5, 6, 7, 8])
-PLAYER3.place_bets([10, 11])
-
-# The scheduler closes the round, and triggers the result and
-# winnings notifications
-SCHEDULER.calculate_winners()
-SCHEDULER.notify_winners()
+"The Mediator Use Case Example"
+from component import Component
+from mediator import Mediator
+
+MEDIATOR = Mediator()
+COMPONENT1 = Component(MEDIATOR, "Component1")
+COMPONENT2 = Component(MEDIATOR, "Component2")
+COMPONENT3 = Component(MEDIATOR, "Component3")
+MEDIATOR.add(COMPONENT1)
+MEDIATOR.add(COMPONENT2)
+MEDIATOR.add(COMPONENT3)
+
+COMPONENT1.notify("data A")
+COMPONENT2.notify("data B")
+COMPONENT3.notify("data C")

mediator/component.py

@@ -0,0 +1,17 @@
+"Each component stays synchronized through a mediator"
+from interface_component import IComponent
+
+
+class Component(IComponent):
+    "Each component stays synchronized through a mediator"
+
+    def __init__(self, mediator, name):
+        self._mediator = mediator
+        self._name = name
+
+    def notify(self, message):
+        print(self._name + ": >>> Out >>> : " + message)
+        self._mediator.notify(message, self)
+
+    def receive(self, message):
+        print(self._name + ": <<< In <<< : " + message)

mediator/game_client.py

@@ -0,0 +1,16 @@
+"An interface that each component will implement"
+from abc import ABCMeta, abstractmethod
+
+
+class IComponent(metaclass=ABCMeta):
+    "An interface that each component will implement"
+
+    @staticmethod
+    @abstractmethod
+    def notify(message):
+        "The required notify method"
+
+    @staticmethod
+    @abstractmethod
+    def receive(message):
+        "The required receive method"

mediator/game_engine.py

@@ -0,0 +1,18 @@
+"The Subject that all components will stay synchronized with"
+
+
+class Mediator():
+    "A Subject whose notify method is mediated"
+
+    def __init__(self):
+        self._components = set()
+
+    def add(self, component):
+        "Add components"
+        self._components.add(component)
+
+    def notify(self, message, originator):
+        "Add components except for the originator component"
+        for component in self._components:
+            if component != originator:
+                component.receive(message)

mediator/interface_component.py

@@ -1,63 +1,48 @@
+# pylint: disable=too-few-public-methods
 "Mediator Concept Sample Code"
-from abc import ABCMeta, abstractmethod
 
 
-class IMediator(metaclass=ABCMeta):
-    "The Mediator interface indicating all the methods to implement"
-    @staticmethod
-    @abstractmethod
-    def colleague1_method():
-        "A method to implement"
-
-    @staticmethod
-    @abstractmethod
-    def colleague2_method():
-        "A method to implement"
-
-
-class Mediator(IMediator):
+class Mediator():
     "The Mediator Concrete Class"
 
     def __init__(self):
         self.colleague1 = Colleague1()
         self.colleague2 = Colleague2()
 
     def colleague1_method(self):
-        return self.colleague1.colleague1_method()
+        "Calls the method provided by Colleague1"
+        return self.colleague1.method_1()
 
     def colleague2_method(self):
-        return self.colleague2.colleague2_method()
+        "Calls the method provided by Colleague2"
+        return self.colleague2.method_2()
 
 
-class Colleague1(IMediator):
-    "This Colleague calls the other Colleague via the Mediator"
+class Colleague1():
+    "This Colleague provides data for Colleague2"
 
-    def colleague1_method(self):
+    @staticmethod
+    def method_1():
+        "A simple method"
         return "Here is the Colleague1 specific data you asked for"
 
-    def colleague2_method(self):
-        "not implemented"
-
-
-class Colleague2(IMediator):
-    "This Colleague calls the other Colleague via the Mediator"
 
-    def colleague1_method(self):
-        "not implemented"
+class Colleague2():
+    "This Colleague provides data for Colleague1"
 
-    def colleague2_method(self):
+    @staticmethod
+    def method_2():
+        "A simple method"
         return "Here is the Colleague2 specific data you asked for"
 
 
-# This Client is either Colleague1 or Colleague2
-# This Colleague will instantiate a Mediator, rather than calling
-# the other Colleague directly.
+# The Client
 MEDIATOR = Mediator()
 
-# If I am Colleague1, I want some data from Colleague2
+# Colleague1 wants some data from Colleague2
 DATA = MEDIATOR.colleague2_method()
 print(f"COLLEAGUE1 <--> {DATA}")
 
-# If I am Colleague2, I want some data from Colleague1
+# Colleague2 wants some data from Colleague1
 DATA = MEDIATOR.colleague1_method()
 print(f"COLLEAGUE2 <--> {DATA}")