| Class | 81 |Description | 82 |
|---|---|
| Controller | 87 |
88 | A Multiton
89 | IController implementation. |
90 |
| Model | 93 |
94 | A Multiton
95 | IModel implementation. |
96 |
| View | 99 |
100 | A Multiton
101 | IView implementation. |
102 |
| Class | 81 |Description | 82 |
|---|---|
| MacroCommand | 87 |
88 | A base
89 | ICommand implementation that executes other ICommands. |
90 |
| SimpleCommand | 93 |
94 | A base
95 | ICommand implementation. |
96 |
| Class | 81 |Description | 82 |
|---|---|
| Facade | 87 |
88 | A base Multiton
89 | IFacade implementation. |
90 |
| Class | 81 |Description | 82 |
|---|---|
| Mediator | 87 |
88 | A base
89 | IMediator implementation. |
90 |
| Class | 81 |Description | 82 |
|---|---|
| Proxy | 87 |
88 | A base
89 | IProxy implementation. |
90 |
39 | 40 | 41 | -------------------------------------------------------------------------------- /docs/overview-summary.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 |
Execute the ICommand's logic to handle a given INotification.
INotification to handle.
21 | */
22 | void execute(INotification notification);
23 |
24 | }
25 |
--------------------------------------------------------------------------------
/src/main/java/org/puremvc/java/multicore/interfaces/IController.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Multicore
3 | //
4 | // Copyright(c) 2019 Saad Shams The interface definition for a PureMVC Controller.
14 | * 15 | *In PureMVC, an IController implementor
16 | * follows the 'Command and Controller' strategy, and
17 | * assumes these responsibilities:
ICommands
21 | * are intended to handle which INotifications.IObserver with
23 | * the View for each INotification
24 | * that it has an ICommand mapping for.ICommand
26 | * to handle a given INotification when notified by the View.ICommand's execute
28 | * method, passing in the INotification.Register a particular ICommand class as the handler
38 | * for a particular INotification.
INotification
41 | * @param commandSupplier a reference to ICommand supplier
42 | */
43 | void registerCommand(String notificationName, SupplierExecute the ICommand previously registered as the
47 | * handler for INotifications with the given notification name.
INotification to execute the associated ICommand for
50 | */
51 | void executeCommand(INotification notification);
52 |
53 | /**
54 | * Remove a previously registered ICommand to INotification mapping.
INotification to remove the ICommand mapping for
57 | */
58 | void removeCommand(String notificationName);
59 |
60 | /**
61 | * Check if a Command is registered for a given Notification
62 | * 63 | * @param notificationName notification name 64 | * @return whether a Command is currently registered for the givennotificationName.
65 | */
66 | boolean hasCommand(String notificationName);
67 | }
68 |
--------------------------------------------------------------------------------
/src/main/java/org/puremvc/java/multicore/interfaces/IFacade.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Multicore
3 | //
4 | // Copyright(c) 2019 Saad Shams The interface definition for a PureMVC Facade.
14 | * 15 | *The Facade Pattern suggests providing a single 16 | * class to act as a central point of communication 17 | * for a subsystem.
18 | * 19 | *In PureMVC, the Facade acts as an interface between 20 | * the core MVC actors (Model, View, Controller) and 21 | * the rest of your application.
22 | * 23 | * @see IModel IModel 24 | * @see IView IView 25 | * @see org.puremvc.java.multicore.interfaces.IController IController 26 | * @see org.puremvc.java.multicore.interfaces.ICommand ICommand 27 | * @see org.puremvc.java.multicore.interfaces.INotification INotification 28 | */ 29 | public interface IFacade extends INotifier { 30 | 31 | /** 32 | *Register an IProxy with the Model by name.
IProxy to be registered with the Model.
35 | */
36 | void registerProxy(IProxy proxy);
37 |
38 | /**
39 | * Retrieve a IProxy from the Model by name.
IProxy instance to be retrieved.
42 | * @return the IProxy previously regisetered by proxyName with the Model.
43 | */
44 | IProxy retrieveProxy(String proxyName);
45 |
46 | /**
47 | * Remove an IProxy instance from the Model by name.
IProxy to remove from the Model.
50 | * @return the IProxy that was removed from the Model
51 | */
52 | IProxy removeProxy(String proxyName);
53 |
54 | /**
55 | * Check if a Proxy is registered
56 | * 57 | * @param proxyName proxy name 58 | * @return whether a Proxy is currently registered with the givenproxyName.
59 | */
60 | boolean hasProxy(String proxyName);
61 |
62 | /**
63 | * Register an ICommand with the Controller.
INotification to associate the ICommand with.
66 | * @param commandSupplier a reference to ICommand supplier
67 | */
68 | void registerCommand(String notificationName, SupplierRemove a previously registered ICommand to INotification mapping from the Controller.
INotification to remove the ICommand mapping for
74 | */
75 | void removeCommand(String notificationName);
76 |
77 | /**
78 | * Check if a Command is registered for a given Notification
79 | * 80 | * @param notificationName notification name 81 | * @return whether a Command is currently registered for the givennotificationName.
82 | */
83 | boolean hasCommand(String notificationName);
84 |
85 | /**
86 | * Register an IMediator instance with the View.
IMediator instance
89 | */
90 | void registerMediator(IMediator mediator);
91 |
92 | /**
93 | * Retrieve an IMediator instance from the View.
IMediator instance to retrievve
96 | * @return the IMediator previously registered with the given mediatorName.
97 | */
98 | IMediator retrieveMediator(String mediatorName);
99 |
100 | /**
101 | * Remove a IMediator instance from the View.
IMediator instance to be removed.
104 | * @return the IMediator instance previously registered with the given mediatorName.
105 | */
106 | IMediator removeMediator(String mediatorName);
107 |
108 | /**
109 | * Check if a Mediator is registered or not
110 | * 111 | * @param mediatorName mediator name 112 | * @return whether a Mediator is registered with the givenmediatorName.
113 | */
114 | boolean hasMediator(String mediatorName);
115 |
116 | /**
117 | * Notify Observers.
This method is left public mostly for backward 120 | * compatibility, and to allow you to send custom 121 | * notification classes using the facade.
122 | * 123 | *Usually you should just call sendNotification 124 | * and pass the parameters, never having to 125 | * construct the notification yourself.
126 | * 127 | * @param notification theINotification to have the View notify Observers of.
128 | */
129 | void notifyObservers(INotification notification);
130 | }
131 |
--------------------------------------------------------------------------------
/src/main/java/org/puremvc/java/multicore/interfaces/IModel.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Multicore
3 | //
4 | // Copyright(c) 2019 Saad Shams The interface definition for a PureMVC Model.
12 | * 13 | *In PureMVC, IModel implementors provide
14 | * access to IProxy objects by named lookup.
An IModel assumes these responsibilities:
IProxy instancesIProxy instancesRegister an IProxy instance with the Model.
Model.
29 | */
30 | void registerProxy(IProxy proxy);
31 |
32 | /**
33 | * Retrieve an IProxy instance from the Model.
IProxy instance previously registered with the given proxyName.
37 | */
38 | IProxy retrieveProxy(String proxyName);
39 |
40 | /**
41 | * Remove an IProxy instance from the Model.
IProxy instance to be removed.
44 | * @return the IProxy that was removed from the Model
45 | */
46 | IProxy removeProxy(String proxyName);
47 |
48 | /**
49 | * Check if a Proxy is registered
50 | * 51 | * @param proxyName proxy name 52 | * @return whether a Proxy is currently registered with the givenproxyName.
53 | */
54 | boolean hasProxy(String proxyName);
55 | }
56 |
--------------------------------------------------------------------------------
/src/main/java/org/puremvc/java/multicore/interfaces/INotification.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Multicore
3 | //
4 | // Copyright(c) 2019 Saad Shams The interface definition for a PureMVC Notification.
12 | * 13 | *PureMVC does not rely upon underlying event models such 14 | * as the one provided with Flash, and ActionScript 3 does 15 | * not have an inherent event model.
16 | * 17 | *The Observer Pattern as implemented within PureMVC exists 18 | * to support event-driven communication between the 19 | * application and the actors of the MVC triad.
20 | * 21 | *Notifications are not meant to be a replacement for Events
22 | * in Flex/Flash/AIR. Generally, IMediator implementors
23 | * place event listeners on their view components, which they
24 | * then handle in the usual way. This may lead to the broadcast of Notifications to
25 | * trigger ICommands or to communicate with other IMediators. IProxy and ICommand
26 | * instances communicate with each other and IMediators
27 | * by broadcasting INotifications.
A key difference between Flash Events and PureMVC
30 | * Notifications is that Events follow the
31 | * 'Chain of Responsibility' pattern, 'bubbling' up the display hierarchy
32 | * until some parent component handles the Event, while
33 | * PureMVC Notifications follow a 'Publish/Subscribe'
34 | * pattern. PureMVC classes need not be related to each other in a
35 | * parent/child relationship in order to communicate with one another
36 | * using Notifications.
Get the name of the INotification instance.
45 | * No setter, should be set by constructor only
Set the body of the INotification instance
Get the body of the INotification instance
Set the type of the INotification instance
Get the type of the INotification instance
Get the string representation of the INotification instance
The interface definition for a PureMVC Notifier.
12 | * 13 | *MacroCommand, Command, Mediator and Proxy
14 | * all have a need to send Notifications.
The INotifier interface provides a common method called
17 | * sendNotification that relieves implementation code of
18 | * the necessity to actually construct Notifications.
The Notifier class, which all of the above mentioned classes
21 | * extend, also provides an initialized reference to the Facade
22 | * Singleton, which is required for the convenience method
23 | * for sending Notifications, but also eases implementation as these
24 | * classes have frequent Facade interactions and usually require
25 | * access to the facade anyway.
Send a INotification.
Convenience method to prevent having to construct new 36 | * notification instances in our implementation code.
37 | * 38 | * @param notificationName the name of the notification to send 39 | * @param body the body of the notification 40 | * @param type the type of the notification 41 | */ 42 | void sendNotification(String notificationName, Object body, String type); 43 | 44 | /** 45 | *Send a INotification.
Convenience method to prevent having to construct new 48 | * notification instances in our implementation code.
49 | * 50 | * @param notificationName the name of the notification to send 51 | * @param body the body of the notification 52 | */ 53 | void sendNotification(String notificationName, Object body); 54 | 55 | /** 56 | *Send a INotification.
Convenience method to prevent having to construct new 59 | * notification instances in our implementation code.
60 | * 61 | * @param notificationName the name of the notification to send 62 | */ 63 | void sendNotification(String notificationName); 64 | 65 | /** 66 | *Initialize this INotifier instance.
67 | * 68 | *This is how a Notifier gets its multitonKey. 69 | * Calls to sendNotification or to access the 70 | * facade will fail until after this method 71 | * has been called.
72 | * 73 | * @param key the multitonKey for this INotifier to use 74 | */ 75 | void initializeNotifier(String key); 76 | } 77 | -------------------------------------------------------------------------------- /src/main/java/org/puremvc/java/multicore/interfaces/IObserver.java: -------------------------------------------------------------------------------- 1 | // 2 | // PureMVC Java Multicore 3 | // 4 | // Copyright(c) 2019 Saad ShamsThe interface definition for a PureMVC Observer.
14 | * 15 | *In PureMVC, IObserver implementors assume these responsibilities:
PureMVC does not rely upon underlying event 25 | * models such as the one provided with Flash, 26 | * and ActionScript 3 does not have an inherent 27 | * event model.
28 | * 29 | *The Observer Pattern as implemented within 30 | * PureMVC exists to support event driven communication 31 | * between the application and the actors of the 32 | * MVC triad.
33 | * 34 | *An Observer is an object that encapsulates information
35 | * about an interested object with a notification method that
36 | * should be called when an INotification is broadcast. The Observer then
37 | * acts as a proxy for notifying the interested object.
Observers can receive Notifications by having their
40 | * notifyObserver method invoked, passing
41 | * in an object implementing the INotification interface, such
42 | * as a subclass of Notification.
Set the notification method.
51 | * 52 | *The notification method should take one parameter of type INotification
Set the notification context.
60 | * 61 | * @param notifyContext the notification context (this) of the interested object 62 | */ 63 | void setNotifyContext(Object notifyContext); 64 | 65 | /** 66 | *Notify the interested object.
67 | * 68 | * @param notification theINotification to pass to the interested object's notification method
69 | */
70 | void notifyObserver(INotification notification);
71 |
72 | /**
73 | * Compare the given object to the notificaiton context object.
74 | * 75 | * @param object the object to compare. 76 | * @return boolean indicating if the notification context and the object are the same. 77 | */ 78 | boolean compareNotifyContext(Object object); 79 | 80 | } 81 | 82 | -------------------------------------------------------------------------------- /src/main/java/org/puremvc/java/multicore/interfaces/IProxy.java: -------------------------------------------------------------------------------- 1 | // 2 | // PureMVC Java Multicore 3 | // 4 | // Copyright(c) 2019 Saad ShamsThe interface definition for a PureMVC Proxy.
12 | * 13 | *In PureMVC, IProxy implementors assume these responsibilities:
Additionally, IProxys typically:
INotifications when their model data changes.public static const called NAME, if they are not instantiated multiple times.Get the Proxy name
34 | * 35 | * @return the Proxy instance name 36 | */ 37 | String getProxyName(); 38 | 39 | /** 40 | *Set the data object
41 | * 42 | * @param data the data object 43 | */ 44 | void setData(Object data); 45 | 46 | /** 47 | *Get the data object
48 | * 49 | * @return the data as type Object 50 | */ 51 | Object getData(); 52 | 53 | /** 54 | *Called by the Model when the Proxy is registered
55 | */ 56 | void onRegister(); 57 | 58 | /** 59 | *Called by the Model when the Proxy is removed
60 | */ 61 | void onRemove(); 62 | } 63 | -------------------------------------------------------------------------------- /src/main/java/org/puremvc/java/multicore/interfaces/IView.java: -------------------------------------------------------------------------------- 1 | // 2 | // PureMVC Java Multicore 3 | // 4 | // Copyright(c) 2019 Saad ShamsThe interface definition for a PureMVC View.
12 | * 13 | *In PureMVC, IView implementors assume these responsibilities:
In PureMVC, the View class assumes these responsibilities:
IMediator instances.IMediators.INotification in the application.IObservers to an INotification's observer list.INotification.IObservers of a given INotification when it broadcast.Register an IObserver to be notified
34 | * of INotifications with a given name.
INotifications to notify this IObserver of
37 | * @param observer the IObserver to register
38 | */
39 | void registerObserver(String notificationName, IObserver observer);
40 |
41 | /**
42 | * Remove a group of observers from the observer list for a given Notification name.
43 | * 44 | * @param notificationName which observer list to remove from 45 | * @param notifyContext removed the observers with this object as their notifyContext 46 | */ 47 | void removeObserver(String notificationName, Object notifyContext); 48 | 49 | /** 50 | *Notify the IObservers for a particular INotification.
All previously attached IObservers for this INotification's
53 | * list are notified and are passed a reference to the INotification in
54 | * the order in which they were registered.
INotification to notify IObservers of.
57 | */
58 | void notifyObservers(INotification notification);
59 |
60 | /**
61 | * Register an IMediator instance with the View.
Registers the IMediator so that it can be retrieved by name,
64 | * and further interrogates the IMediator for its
65 | * INotification interests.
If the IMediator returns any INotification
68 | * names to be notified about, an Observer is created encapsulating
69 | * the IMediator instance's handleNotification method
70 | * and registering it as an Observer for all INotifications the
71 | * IMediator is interested in.
IMediator instance
74 | */
75 | void registerMediator(IMediator mediator);
76 |
77 | /**
78 | * Retrieve an IMediator from the View.
IMediator instance to retrieve.
81 | * @return the IMediator instance previously registered with the given mediatorName.
82 | */
83 | IMediator retrieveMediator(String mediatorName);
84 |
85 | /**
86 | * Remove an IMediator from the View.
IMediator instance to be removed.
89 | * @return the IMediator that was removed from the View
90 | */
91 | IMediator removeMediator(String mediatorName);
92 |
93 | /**
94 | * Check if a Mediator is registered or not
95 | * 96 | * @param mediatorName mediator name 97 | * @return whether a Mediator is registered with the givenmediatorName.
98 | */
99 | boolean hasMediator(String mediatorName);
100 | }
101 |
--------------------------------------------------------------------------------
/src/main/java/org/puremvc/java/multicore/patterns/command/MacroCommand.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Multicore
3 | //
4 | // Copyright(c) 2019 Saad Shams A base ICommand implementation that executes other ICommands.
A MacroCommand maintains an list of
21 | * ICommand Class references called SubCommands.
When execute is called, the MacroCommand
24 | * instantiates and calls execute on each of its SubCommands turn.
25 | * Each SubCommand will be passed a reference to the original
26 | * INotification that was passed to the MacroCommand's
27 | * execute method.
Unlike SimpleCommand, your subclass
30 | * should not override execute, but instead, should
31 | * override the initializeMacroCommand method,
32 | * calling addSubCommand once for each SubCommand
33 | * to be executed.
Constructor.
45 | * 46 | *You should not need to define a constructor,
47 | * instead, override the initializeMacroCommand
48 | * method.
If your subclass does define a constructor, be
51 | * sure to call super().
Initialize the MacroCommand.
In your subclass, override this method to
62 | * initialize the MacroCommand's SubCommand
63 | * list with ICommand class references like
64 | * this:
67 | * {@code // Initialize MyMacroCommand
68 | * protected void initializeMacroCommand( )
69 | * {
70 | * addSubCommand( () -> new com.me.myapp.controller.FirstCommand() );
71 | * addSubCommand( () -> new com.me.myapp.controller.SecondCommand() );
72 | * addSubCommand( () -> new com.me.myapp.controller.ThirdCommand() );
73 | * }
74 | * }
75 | *
76 | *
77 | * Note that SubCommands may be any ICommand implementor,
78 | * MacroCommands or SimpleCommands are both acceptable.
Add a SubCommand.
85 | * 86 | *The SubCommands will be called in First In/First Out (FIFO) 87 | * order.
88 | * 89 | * @param factory a reference to the factory of theICommand.
90 | */
91 | protected void addSubCommand(SupplierExecute this MacroCommand's SubCommands.
The SubCommands will be called in First In/First Out (FIFO) 99 | * order.
100 | * 101 | * @param notification theINotification object to be passsed to each SubCommand.
102 | */
103 | public void execute(INotification notification) {
104 | while(!subCommands.isEmpty()) {
105 | ICommand command = subCommands.remove(0).get();
106 | command.initializeNotifier(multitonKey);
107 | command.execute(notification);
108 | }
109 | }
110 | }
111 |
--------------------------------------------------------------------------------
/src/main/java/org/puremvc/java/multicore/patterns/command/SimpleCommand.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Multicore
3 | //
4 | // Copyright(c) 2019 Saad Shams A base ICommand implementation.
Your subclass should override the execute
18 | * method where your business logic will handle the INotification.
Fulfill the use-case initiated by the given INotification.
In the Command Pattern, an application use-case typically
30 | * begins with some user action, which results in an INotification being broadcast, which
31 | * is handled by business logic in the execute method of an
32 | * ICommand.
INotification to handle.
35 | */
36 | public void execute(INotification notification) {
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/src/main/java/org/puremvc/java/multicore/patterns/mediator/Mediator.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Multicore
3 | //
4 | // Copyright(c) 2019 Saad Shams A base IMediator implementation.
The name of the Mediator.
Typically, a Mediator will be written to serve
25 | * one specific control or group controls and so,
26 | * will not have a need to be dynamically named.
Constructor.
38 | * 39 | * @param mediatorName mediator name 40 | * @param viewComponent view component 41 | */ 42 | public Mediator(String mediatorName, Object viewComponent) { 43 | this.mediatorName = mediatorName != null ? mediatorName : NAME; 44 | this.viewComponent = viewComponent; 45 | } 46 | 47 | /** 48 | *Constructor.
49 | * 50 | * @param mediatorName mediator name 51 | */ 52 | public Mediator(String mediatorName) { 53 | this(mediatorName, null); 54 | } 55 | 56 | /** 57 | *Constructor.
58 | */ 59 | public Mediator() { 60 | this(null, null); 61 | } 62 | 63 | /** 64 | *List the INotification names this
65 | * Mediator is interested in being notified of.
INotification names
68 | */
69 | public String[] listNotificationInterests() {
70 | return new String[0];
71 | }
72 |
73 | /**
74 | * Handle INotifications.
Typically this will be handled in a switch statement,
77 | * with one 'case' entry per INotification
78 | * the Mediator is interested in.
Called by the View when the Mediator is registered
86 | */ 87 | public void onRegister() { 88 | 89 | } 90 | 91 | /** 92 | *Called by the View when the Mediator is removed
93 | */ 94 | public void onRemove() { 95 | 96 | } 97 | 98 | /** 99 | *Get the name of the Mediator.
Get the Mediator's view component.
Additionally, an implicit getter will usually 111 | * be defined in the subclass that casts the view 112 | * object to a type, like this:
113 | * 114 | * {@code 115 | * public javax.swing.JComboBox getViewComponent() 116 | * { 117 | * return viewComponent; 118 | * } 119 | *} 120 | * 121 | * @return the view component 122 | */ 123 | public Object getViewComponent() { 124 | return viewComponent; 125 | } 126 | 127 | /** 128 | *Set the IMediator's view component.
A base INotification implementation.
PureMVC does not rely upon underlying event models such 16 | * as the one provided with Flash, and ActionScript 3 does 17 | * not have an inherent event model.
18 | * 19 | *The Observer Pattern as implemented within PureMVC exists 20 | * to support event-driven communication between the 21 | * application and the actors of the MVC triad.
22 | * 23 | *Notifications are not meant to be a replacement for Events
24 | * in Flex/Flash/Apollo. Generally, IMediator implementors
25 | * place event listeners on their view components, which they
26 | * then handle in the usual way. This may lead to the broadcast of Notifications to
27 | * trigger ICommands or to communicate with other IMediators. IProxy and ICommand
28 | * instances communicate with each other and IMediators
29 | * by broadcasting INotifications.
A key difference between Flash Events and PureMVC
32 | * Notifications is that Events follow the
33 | * 'Chain of Responsibility' pattern, 'bubbling' up the display hierarchy
34 | * until some parent component handles the Event, while
35 | * PureMVC Notifications follow a 'Publish/Subscribe'
36 | * pattern. PureMVC classes need not be related to each other in a
37 | * parent/child relationship in order to communicate with one another
38 | * using Notifications.
Constructor.
56 | * 57 | * @param name name of theNotification instance. (required)
58 | * @param body the Notification body.
59 | * @param type the type of the Notification
60 | */
61 | public Notification(String name, Object body, String type) {
62 | this.name = name;
63 | this.body = body;
64 | this.type = type;
65 | }
66 |
67 | /**
68 | * Constructor.
69 | * 70 | * @param name name of theNotification instance. (required)
71 | * @param body the Notification body.
72 | */
73 | public Notification(String name, Object body) {
74 | this(name, body, null);
75 | }
76 |
77 | /**
78 | * Constructor.
79 | * 80 | * @param name name of theNotification instance. (required)
81 | */
82 | public Notification(String name) {
83 | this(name, null, null);
84 | }
85 |
86 | /**
87 | * Get the name of the Notification instance.
Notification instance.
90 | */
91 | public String getName() {
92 | return name;
93 | }
94 |
95 | /**
96 | * Set the body of the Notification instance.
Get the body of the Notification instance.
Set the type of the Notification instance.
Get the type of the Notification instance.
Get the string representation of the Notification instance.
Notification instance.
131 | */
132 | public String toString() {
133 | return new StringBuilder("Notification Name: " + getName())
134 | .append("\nBody:" + ((body == null) ? "null" : body.toString()))
135 | .append("\nType:" + ((type == null) ? "null" : type))
136 | .toString();
137 | }
138 |
139 | }
140 |
--------------------------------------------------------------------------------
/src/main/java/org/puremvc/java/multicore/patterns/observer/Notifier.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Multicore
3 | //
4 | // Copyright(c) 2019 Saad Shams A Base INotifier implementation.
MacroCommand, Command, Mediator and Proxy
18 | * all have a need to send Notifications.
The INotifier interface provides a common method called
21 | * sendNotification that relieves implementation code of
22 | * the necessity to actually construct Notifications.
The Notifier class, which all of the above mentioned classes
25 | * extend, provides an initialized reference to the Facade
26 | * Multiton, which is required for the convienience method
27 | * for sending Notifications, but also eases implementation as these
28 | * classes have frequent Facade interactions and usually require
29 | * access to the facade anyway.
NOTE: In the MultiCore version of the framework, there is one caveat to 32 | * notifiers, they cannot send notifications or reach the facade until they 33 | * have a valid multitonKey.
34 | * 35 | *The multitonKey is set: 36 | * * on a Command when it is executed by the Controller 37 | * * on a Mediator is registered with the View 38 | * * on a Proxy is registered with the Model.
39 | * 40 | * @see org.puremvc.java.multicore.patterns.proxy.Proxy Proxy 41 | * @see Facade Facade 42 | * @see org.puremvc.java.multicore.patterns.mediator.Mediator Mediator 43 | * @see org.puremvc.java.multicore.patterns.command.MacroCommand MacroCommand 44 | * @see org.puremvc.java.multicore.patterns.command.SimpleCommand SimpleCommand 45 | */ 46 | public class Notifier implements INotifier { 47 | 48 | protected String multitonKey; 49 | 50 | protected final String MULTITON_MSG = "multitonKey for this Notifier not yet initialized!"; 51 | 52 | protected IFacade getFacade() { 53 | if(multitonKey == null) throw new RuntimeException(MULTITON_MSG); 54 | return Facade.getInstance(multitonKey, key -> new Facade(key)); 55 | } 56 | 57 | /** 58 | *Create and send an INotification.
Keeps us from having to construct new INotification 61 | * instances in our implementation code.
62 | * 63 | * @param notificationName the name of the notiification to send 64 | * @param body the body of the notification 65 | * @param type the type of the notification 66 | */ 67 | public void sendNotification(String notificationName, Object body, String type) { 68 | getFacade().sendNotification(notificationName, body, type); 69 | } 70 | 71 | /** 72 | *Create and send an INotification.
Keeps us from having to construct new INotification 75 | * instances in our implementation code.
76 | * 77 | * @param notificationName the name of the notiification to send 78 | * @param body the body of the notification 79 | */ 80 | public void sendNotification(String notificationName, Object body) { 81 | getFacade().sendNotification(notificationName, body); 82 | } 83 | 84 | /** 85 | *Create and send an INotification.
Keeps us from having to construct new INotification 88 | * instances in our implementation code.
89 | * 90 | * @param notificationName the name of the notiification to send 91 | */ 92 | public void sendNotification(String notificationName) { 93 | getFacade().sendNotification(notificationName); 94 | } 95 | 96 | /** 97 | *Initialize this INotifier instance.
98 | * 99 | *This is how a Notifier gets its multitonKey. 100 | * Calls to sendNotification or to access the 101 | * facade will fail until after this method 102 | * has been called.
103 | * 104 | *Mediators, Commands or Proxies may override 105 | * this method in order to send notifications 106 | * or access the Multiton Facade instance as 107 | * soon as possible. They CANNOT access the facade 108 | * in their constructors, since this method will not 109 | * yet have been called.
110 | * 111 | * @param key the multitonKey for this INotifier to use 112 | */ 113 | public void initializeNotifier(String key) { 114 | multitonKey = key; 115 | } 116 | } 117 | -------------------------------------------------------------------------------- /src/main/java/org/puremvc/java/multicore/patterns/observer/Observer.java: -------------------------------------------------------------------------------- 1 | // 2 | // PureMVC Java Multicore 3 | // 4 | // Copyright(c) 2019 Saad ShamsA base IObserver implementation.
An Observer is an object that encapsulates information
19 | * about an interested object with a method that should
20 | * be called when a particular INotification is broadcast.
In PureMVC, the Observer class assumes these responsibilities:
Constructor.
41 | * 42 | *The notification method on the interested object should take
43 | * one parameter of type INotification
Compare an object to the notification context.
55 | * 56 | * @param object the object to compare 57 | * @return boolean indicating if the object and the notification context are the same 58 | */ 59 | public boolean compareNotifyContext(Object object) { 60 | return object == this.context; 61 | } 62 | 63 | /** 64 | *Notify the interested object.
65 | * 66 | * @param notification theINotification to pass to the interested object's notification method.
67 | */
68 | public void notifyObserver(INotification notification) {
69 | notify.accept(notification);
70 | }
71 |
72 | /**
73 | * Get the notification context.
74 | * 75 | * @return the notification context (this) of the interested object.
76 | */
77 | protected Object getNotifyContext() {
78 | return context;
79 | }
80 |
81 | /**
82 | * Set the notification context.
83 | * 84 | * @param notifyContext the notification context (this) of the interested object. 85 | */ 86 | public void setNotifyContext(Object notifyContext) { 87 | this.context = notifyContext; 88 | } 89 | 90 | /** 91 | *Get the notification method.
92 | * 93 | * @return the notification consumer of the interested object. 94 | */ 95 | protected ConsumerSet the notification method.
101 | * 102 | *The notification method should take one parameter of type INotification.
A base IProxy implementation.
In PureMVC, Proxy classes are used to manage parts of the
17 | * application's data model.
A Proxy might simply manage a reference to a local data object,
20 | * in which case interacting with it might involve setting and
21 | * getting of its data in synchronous fashion.
Proxy classes are also used to encapsulate the application's
24 | * interaction with remote services to save or retrieve data, in which case,
25 | * we adopt an asyncronous idiom; setting data (or calling a method) on the
26 | * Proxy and listening for a Notification to be sent
27 | * when the Proxy has retrieved the data from the service.
Constructor.
41 | * 42 | * @param proxyName proxy name 43 | * @param data data 44 | */ 45 | public Proxy(String proxyName, Object data) { 46 | this.proxyName = (proxyName != null) ? proxyName : NAME; 47 | if(data != null) setData(data); 48 | } 49 | 50 | /** 51 | *Constructor.
52 | * 53 | * @param proxyName proxy name 54 | */ 55 | public Proxy(String proxyName) { 56 | this(proxyName, null); 57 | } 58 | 59 | /** 60 | *Constructor.
61 | */ 62 | public Proxy(){ 63 | this(null, null); 64 | } 65 | 66 | /** 67 | *Called by the Model when the Proxy is registered
68 | */ 69 | public void onRegister() { 70 | 71 | } 72 | 73 | /** 74 | *Called by the Model when the Proxy is removed
75 | */ 76 | public void onRemove() { 77 | 78 | } 79 | 80 | /** 81 | *Get the proxy name
82 | */ 83 | public String getProxyName() { 84 | return proxyName; 85 | } 86 | 87 | /** 88 | *Get the data object
89 | */ 90 | public Object getData() { 91 | return data; 92 | } 93 | 94 | /** 95 | *Set the data object
96 | */ 97 | public void setData(Object data) { 98 | this.data = data; 99 | } 100 | 101 | } 102 | -------------------------------------------------------------------------------- /src/test/java/org/puremvc/java/multicore/core/ControllerTestCommand.java: -------------------------------------------------------------------------------- 1 | // 2 | // PureMVC Java Multicore 3 | // 4 | // Copyright(c) 2019 Saad ShamsThis tests accumulation effect that would show if the command were executed more than once.
19 | * 20 | * @param notification the note carrying the ControllerTestVO 21 | */ 22 | public void execute(INotification notification) { 23 | ControllerTestVO vo = (ControllerTestVO)notification.getBody(); 24 | 25 | // Fabricate a result 26 | vo.result = vo.result + (2 * vo.input); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/test/java/org/puremvc/java/multicore/core/ControllerTestVO.java: -------------------------------------------------------------------------------- 1 | // 2 | // PureMVC Java Multicore 3 | // 4 | // Copyright(c) 2019 Saad ShamsTests registerProxy and retrieveProxy in the same test.
37 | * These methods cannot currently be tested separately
38 | * in any meaningful way other than to show that the
39 | * methods do not throw exception when called.
This method creates new instances of the ViewTestNote class, 39 | * automatically setting the note name so you don't have to. Use 40 | * this as an alternative to the constructor.
41 | * 42 | * @param body the body of the Notification to be constructed. 43 | */ 44 | public static INotification create(Object body) { 45 | return new ViewTestNote(NAME, body); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /src/test/java/org/puremvc/java/multicore/patterns/command/MacroCommandTest.java: -------------------------------------------------------------------------------- 1 | // 2 | // PureMVC Java Multicore 3 | // 4 | // Copyright(c) 2019 Saad ShamsMacroCommand.
25 | *
26 | * This test creates a new Notification, adding a
27 | * MacroCommandTestVO as the body.
28 | * It then creates a MacroCommandTestCommand and invokes
29 | * its execute method, passing in the
30 | * Notification.
31 | * 32 | *
The MacroCommandTestCommand has defined an
33 | * initializeMacroCommand method, which is
34 | * called automatically by its constructor. In this method
35 | * the MacroCommandTestCommand adds 2 SubCommands
36 | * to itself, MacroCommandTestSub1Command and
37 | * MacroCommandTestSub2Command.
38 | *
39 | *
The MacroCommandTestVO has 2 result properties,
40 | * one is set by MacroCommandTestSub1Command by
41 | * multiplying the input property by 2, and the other is set
42 | * by MacroCommandTestSub2Command by multiplying
43 | * the input property by itself.
44 | *
45 | *
Success is determined by evaluating the 2 result properties
46 | * on the MacroCommandTestVO that was passed to
47 | * the MacroCommandTestCommand on the Notification
48 | * body.
IEvent carrying the MacroCommandTestVO
25 | */
26 | public void execute(INotification notification) {
27 | MacroCommandTestVO vo = (MacroCommandTestVO)notification.getBody();
28 |
29 | // Fabricate a result
30 | vo.result1 = 2 * vo.input;
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/src/test/java/org/puremvc/java/multicore/patterns/command/MacroCommandTestSub2Command.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Multicore
3 | //
4 | // Copyright(c) 2019 Saad Shams IEvent carrying the MacroCommandTestVO
25 | */
26 | public void execute(INotification notification) {
27 | MacroCommandTestVO vo = (MacroCommandTestVO)notification.getBody();
28 |
29 | // Fabricate a result
30 | vo.result2 = vo.input * vo.input;
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/src/test/java/org/puremvc/java/multicore/patterns/command/MacroCommandTestVO.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Multicore
3 | //
4 | // Copyright(c) 2019 Saad Shams execute method of a SimpleCommand.
24 | *
25 | * This test creates a new Notification, adding a
26 | * SimpleCommandTestVO as the body.
27 | * It then creates a SimpleCommandTestCommand and invokes
28 | * its execute method, passing in the note.
Success is determined by evaluating a property on the 31 | * object that was passed on the Notification body, which will 32 | * be modified by the SimpleCommand
. 33 | * 34 | */ 35 | @Test 36 | public void testSimpleCommandExecute() { 37 | // Create the VO 38 | SimpleCommandTestVO vo = new SimpleCommandTestVO(5); 39 | 40 | // Create the Notification (note) 41 | Notification note = new Notification("SimpleCommandTestNote", vo); 42 | 43 | // Create the SimpleCommand 44 | SimpleCommandTestCommand command = new SimpleCommandTestCommand(); 45 | 46 | // Execute the SimpleCommand 47 | command.execute(note); 48 | 49 | // test assertions 50 | Assertions.assertTrue(vo.result == 10, "Expecting vo.result == 10"); 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /src/test/java/org/puremvc/java/multicore/patterns/command/SimpleCommandTestCommand.java: -------------------------------------------------------------------------------- 1 | // 2 | // PureMVC Java Multicore 3 | // 4 | // Copyright(c) 2019 Saad ShamsINotification carrying the SimpleCommandTestVO
24 | */
25 | public void execute(INotification notification) {
26 | SimpleCommandTestVO vo = (SimpleCommandTestVO) notification.getBody();
27 |
28 | // Fabricate a result
29 | vo.result = 2 * vo.input;
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/src/test/java/org/puremvc/java/multicore/patterns/command/SimpleCommandTestVO.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Multicore
3 | //
4 | // Copyright(c) 2019 Saad Shams Since the Observer encapsulates the interested object's 18 | * callback information, there are no getters, only setters. 19 | * It is, in effect write-only memory.
20 | * 21 | *Therefore, the only way to test it is to set the 22 | * notification method and context and call the notifyObserver 23 | * method.
24 | * 25 | */ 26 | public class ObserverTest { 27 | 28 | /** 29 | * A test variable that proves the notify method was 30 | * executed with 'this' as its exectution context 31 | */ 32 | private int observerTestVar; 33 | 34 | /** 35 | * Tests observer class when initialized by accessor methods. 36 | */ 37 | @Test 38 | public void testObserverAccessors() { 39 | // Create observer with null args, then 40 | // use accessors to set notification method and context 41 | Observer observer = new Observer(null, null); 42 | observer.setNotifyContext(this); 43 | observer.setNotifyMethod(this::handleNotification); 44 | 45 | // create a test event, setting a payload value and notify 46 | // the observer with it. since the observer is this class 47 | // and the notification method is observerTestMethod, 48 | // successful notification will result in our local 49 | // observerTestVar being set to the value we pass in 50 | // on the note body. 51 | Notification note = new Notification("ObserverTestNote", 10); 52 | observer.notifyObserver(note); 53 | 54 | // test assertions 55 | Assertions.assertTrue(observerTestVar == 10, "Expecting observerTestVar = 10"); 56 | } 57 | 58 | /** 59 | * Tests observer class when initialized by constructor. 60 | */ 61 | @Test 62 | public void testObserverConstructor() { 63 | // Create observer passing in notification method and context 64 | Observer observer = new Observer(this::handleNotification, this); 65 | 66 | // create a test note, setting a body value and notify 67 | // the observer with it. since the observer is this class 68 | // and the notification method is observerTestMethod, 69 | // successful notification will result in our local 70 | // observerTestVar being set to the value we pass in 71 | // on the note body. 72 | Notification note = new Notification("ObserverTestNote", 5); 73 | observer.notifyObserver(note); 74 | 75 | // test assertions 76 | Assertions.assertTrue(observerTestVar == 5, "Expecting observerTestVar = 5"); 77 | } 78 | 79 | /** 80 | * Tests the compareNotifyContext method of the Observer class 81 | */ 82 | @Test 83 | public void testCompareNotifyContext() { 84 | // Create observer passing in notification method and context 85 | Observer observer = new Observer(this::handleNotification, this); 86 | 87 | Object negTestObj = new Object(); 88 | 89 | // test assertions 90 | Assertions.assertFalse(observer.compareNotifyContext(negTestObj), "Expecting observer.compareNotifyContext(negTestObj) == false"); 91 | Assertions.assertTrue(observer.compareNotifyContext(this), "Expecting observer.compareNotifyContext(this) == true"); 92 | } 93 | 94 | /** 95 | * A function that is used as the observer notification 96 | * method. It multiplies the input number by the 97 | * observerTestVar value 98 | */ 99 | public void handleNotification(INotification notification) { 100 | observerTestVar = (int)notification.getBody(); 101 | } 102 | 103 | } 104 | -------------------------------------------------------------------------------- /src/test/java/org/puremvc/java/multicore/patterns/proxy/ProxyTest.java: -------------------------------------------------------------------------------- 1 | // 2 | // PureMVC Java Multicore 3 | // 4 | // Copyright(c) 2019 Saad Shams