| Class | 81 |Description | 82 |
|---|---|
| Controller | 87 |
88 | A Singleton
89 | IController implementation. |
90 |
| Model | 93 |
94 | A Singleton
95 | IModel implementation. |
96 |
| View | 99 |
100 | A Singleton
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 Singleton
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 |
A Singleton IModel implementation.
In PureMVC, the Model class provides
21 | * access to model objects (Proxies) by named lookup.
The Model assumes these responsibilities:
IProxy instances.IProxy instances.Your application must register IProxy instances
32 | * with the Model. Typically, you use an
33 | * ICommand to create and register IProxy
34 | * instances once the Facade has initialized the Core
35 | * actors.
Constructor.
53 | * 54 | *This IModel implementation is a Singleton,
55 | * so you should not call the constructor
56 | * directly, but instead call the static Singleton
57 | * Factory method Model.getInstance()
Initialize the Singleton Model instance.
Called automatically by the constructor, this 73 | * is your opportunity to initialize the Singleton 74 | * instance in your subclass without overriding the 75 | * constructor.
76 | * 77 | */ 78 | protected void initializeModel() { 79 | } 80 | 81 | /** 82 | *Model Singleton Factory method.
Register an IProxy with the Model.
IProxy to be held by the Model.
96 | */
97 | public void registerProxy(IProxy proxy) {
98 | proxyMap.put(proxy.getProxyName(), proxy);
99 | proxy.onRegister();
100 | }
101 |
102 | /**
103 | * Retrieve an IProxy from the Model.
IProxy instance previously registered with the given proxyName.
107 | */
108 | public IProxy retrieveProxy(String proxyName) {
109 | return proxyMap.get(proxyName);
110 | }
111 |
112 | /**
113 | * Check if a Proxy is registered
114 | * 115 | * @param proxyName proxy name 116 | * @return whether a Proxy is currently registered with the givenproxyName.
117 | */
118 | public boolean hasProxy(String proxyName) {
119 | return proxyMap.containsKey(proxyName);
120 | }
121 |
122 | /**
123 | * Remove an IProxy from the Model.
IProxy instance to be removed.
126 | * @return the IProxy that was removed from the Model
127 | */
128 | public IProxy removeProxy(String proxyName) {
129 | IProxy proxy = proxyMap.get(proxyName);
130 | if(proxy != null) {
131 | proxyMap.remove(proxyName);
132 | proxy.onRemove();
133 | }
134 | return proxy;
135 | }
136 |
137 | }
138 |
--------------------------------------------------------------------------------
/src/main/java/org/puremvc/java/interfaces/ICommand.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Standard
3 | //
4 | // Copyright(c) 2019 Saad Shams 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/interfaces/IController.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Standard
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 the Supplier Function of the ICommand
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/interfaces/IModel.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Standard
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/interfaces/INotification.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Standard
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
INotification
83 | */
84 | String toString();
85 |
86 | }
87 |
--------------------------------------------------------------------------------
/src/main/java/org/puremvc/java/interfaces/INotifier.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Standard
3 | //
4 | // Copyright(c) 2019 Saad Shams 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 convienience 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 | -------------------------------------------------------------------------------- /src/main/java/org/puremvc/java/interfaces/IObserver.java: -------------------------------------------------------------------------------- 1 | // 2 | // PureMVC Java Standard 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 notification 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/interfaces/IProxy.java: -------------------------------------------------------------------------------- 1 | // 2 | // PureMVC Java Standard 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/interfaces/IView.java: -------------------------------------------------------------------------------- 1 | // 2 | // PureMVC Java Standard 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/patterns/command/MacroCommand.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Standard
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
68 | * // Initialize MyMacroCommand
69 | * protected void initializeMacroCommand( )
70 | * {
71 | * addSubCommand( () -> new com.me.myapp.controller.FirstCommand() );
72 | * addSubCommand( () -> new com.me.myapp.controller.SecondCommand() );
73 | * addSubCommand( () -> new com.me.myapp.controller.ThirdCommand() );
74 | * }
75 | * }
76 | *
77 | *
78 | * Note that SubCommands may be any ICommand implementor,
79 | * MacroCommands or SimpleCommands are both acceptable.
Add a SubCommand.
86 | * 87 | *The SubCommands will be called in First In/First Out (FIFO) 88 | * order.
89 | * 90 | * @param factory a reference to the factory of theICommand.
91 | */
92 | protected void addSubCommand(SupplierExecute this MacroCommand's SubCommands.
The SubCommands will be called in First In/First Out (FIFO) 100 | * order.
101 | * 102 | * @param notification theINotification object to be passsed to each SubCommand.
103 | */
104 | public void execute(INotification notification) {
105 | while(!subCommands.isEmpty()) {
106 | SupplierA 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/patterns/mediator/Mediator.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Standard
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.
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.
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 |
--------------------------------------------------------------------------------
/src/main/java/org/puremvc/java/patterns/observer/Notifier.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Standard
3 | //
4 | // Copyright(c) 2019 Saad Shams A Base INotifier implementation.
MacroCommand, Command, Mediator and Proxy all
18 | * have a need to send Notifications.
The INotifier interface provides a common method called
21 | * sendNotification that relieves implementation code of the
22 | * 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 | * Singleton, which is required for the convienience method for sending
27 | * Notifications, but also eases implementation as these classes
28 | * have frequent Facade interactions and usually require access
29 | * to the facade anyway.
Local reference to the Facade Singleton
41 | */ 42 | protected IFacade facade = Facade.getInstance(()-> new Facade()); 43 | 44 | /** 45 | *Send an INotifications.
Keeps us from having to construct new notification instances in our 48 | * implementation code.
49 | * 50 | * @param notificationName the name of the notiification to send 51 | * @param body the body of the notification 52 | * @param type the type of the notification 53 | */ 54 | public void sendNotification(String notificationName, Object body, String type) { 55 | facade.sendNotification(notificationName, body, type); 56 | } 57 | 58 | /** 59 | *Send an INotifications.
Keeps us from having to construct new notification instances in our 62 | * implementation code.
63 | * 64 | * @param notificationName the name of the notiification to send 65 | * @param body the body of the notification 66 | */ 67 | public void sendNotification(String notificationName, Object body) { 68 | facade.sendNotification(notificationName, body); 69 | } 70 | 71 | /** 72 | *Send an INotifications.
Keeps us from having to construct new notification instances in our 75 | * implementation code.
76 | * 77 | * @param notificationName the name of the notiification to send 78 | */ 79 | public void sendNotification(String notificationName) { 80 | facade.sendNotification(notificationName); 81 | } 82 | 83 | } 84 | -------------------------------------------------------------------------------- /src/main/java/org/puremvc/java/patterns/observer/Observer.java: -------------------------------------------------------------------------------- 1 | // 2 | // PureMVC Java Standard 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.
42 | * 43 | *The notification method on the interested object should take one
44 | * parameter of type INotification
Compare an object to the notification context.
56 | * 57 | * @param object the object to compare 58 | * @return boolean indicating if the object and the notification context are 59 | * the same 60 | */ 61 | public boolean compareNotifyContext(Object object) { 62 | return object == this.notifyContext; 63 | } 64 | 65 | /** 66 | *Notify the interested object.
67 | * 68 | * @param notification theINotification to pass to the interested
69 | * object's notification method.
70 | */
71 | public void notifyObserver(INotification notification) {
72 | notifyMethod.accept(notification);
73 | }
74 |
75 | /**
76 | * Get the notification context.
77 | * 78 | * @return the notification context (this) of the
79 | * interested object.
80 | */
81 | protected Object getNotifyContext() {
82 | return notifyContext;
83 | }
84 |
85 | /**
86 | * Set the notification context.
87 | * 88 | * @param notifyContext the notification context (this) of the interested object. 89 | */ 90 | public void setNotifyContext(Object notifyContext) { 91 | this.notifyContext = notifyContext; 92 | } 93 | 94 | /** 95 | *Get the notification method.
96 | * 97 | * @return the notification (callback) consumer function of the interested object. 98 | */ 99 | protected ConsumerSet the notification method.
105 | * 106 | *The notification method should take one parameter of type
107 | * 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
20 | * object, in which case interacting with it might involve setting and getting
21 | * 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, we
25 | * adopt an asyncronous idiom; setting data (or calling a method) on the
26 | * Proxy and listening for a Notification to be
27 | * sent when the Proxy has retrieved the data from the service.
Constructor
44 | * 45 | * @param proxyName proxy name 46 | * @param data data object 47 | */ 48 | public Proxy(String proxyName, Object data) { 49 | this.proxyName = (proxyName != null) ? proxyName : NAME; 50 | if(data != null) setData(data); 51 | } 52 | 53 | /** 54 | *Constructor
55 | * 56 | * @param proxyName Name of theProxy
57 | */
58 | public Proxy(String proxyName) {
59 | this(proxyName, null);
60 | }
61 |
62 | /**
63 | * Constructor
64 | */ 65 | public Proxy(){ 66 | this(null, null); 67 | } 68 | 69 | /** 70 | *Called by the Model when the Proxy is registered
71 | */ 72 | public void onRegister() { 73 | 74 | } 75 | 76 | /** 77 | *Called by the Model when the Proxy is removed
78 | */ 79 | public void onRemove() { 80 | 81 | } 82 | 83 | /** 84 | *Get the proxy name
85 | * 86 | * @return the proxy name 87 | */ 88 | public String getProxyName() { 89 | return proxyName; 90 | } 91 | 92 | /** 93 | *Get the data object
94 | * 95 | * @return the data object 96 | */ 97 | public Object getData() { 98 | return data; 99 | } 100 | 101 | /** 102 | *Set the data object
103 | * 104 | * @param data data object 105 | */ 106 | public void setData(Object data) { 107 | this.data = data; 108 | } 109 | 110 | } 111 | -------------------------------------------------------------------------------- /src/test/java/org/puremvc/java/core/ControllerTestCommand.java: -------------------------------------------------------------------------------- 1 | // 2 | // PureMVC Java Standard 3 | // 4 | // Copyright(c) 2019 Saad ShamsThis tests accumulation effect that would show if the command were executed more than once.
25 | * @param notification the note carrying the ControllerTestVO 26 | */ 27 | public void execute(INotification notification) { 28 | ControllerTestVO vo = (ControllerTestVO)notification.getBody(); 29 | 30 | // Fabricate a result 31 | vo.result = vo.result + (2 * vo.input); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/test/java/org/puremvc/java/core/ControllerTestVO.java: -------------------------------------------------------------------------------- 1 | // 2 | // PureMVC Java Standard 3 | // 4 | // Copyright(c) 2019 Saad ShamsTests registerProxy and retrieveProxy in the same test.
35 | * These methods cannot currently be tested separately
36 | * in any meaningful way other than to show that the
37 | * 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 | * @return INotification 44 | */ 45 | public static INotification create(Object body) { 46 | return new ViewTestNote(NAME, body); 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/test/java/org/puremvc/java/patterns/command/MacroCommandTest.java: -------------------------------------------------------------------------------- 1 | // 2 | // PureMVC Java Standard 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.
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.
INotification 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/patterns/command/MacroCommandTestSub2Command.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Standard
3 | //
4 | // Copyright(c) 2019 Saad Shams INotification 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/patterns/command/MacroCommandTestVO.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Standard
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/patterns/command/SimpleCommandTestCommand.java: -------------------------------------------------------------------------------- 1 | // 2 | // PureMVC Java Standard 3 | // 4 | // Copyright(c) 2019 Saad ShamsINotification carrying the SimpleCommandTestVO
24 | */
25 | @Override
26 | public void execute(INotification notification) {
27 | SimpleCommandTestVO vo = (SimpleCommandTestVO) notification.getBody();
28 |
29 | // Fabricate a result
30 | vo.result = 2 * vo.input;
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/src/test/java/org/puremvc/java/patterns/command/SimpleCommandTestVO.java:
--------------------------------------------------------------------------------
1 | //
2 | // PureMVC Java Standard
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 | // test assertions 88 | Object negTestObj = new Object(); 89 | 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 | * @param notification notification 100 | */ 101 | public void handleNotification(INotification notification) { 102 | observerTestVar = (int)notification.getBody(); 103 | } 104 | 105 | } 106 | -------------------------------------------------------------------------------- /src/test/java/org/puremvc/java/patterns/proxy/ProxyTest.java: -------------------------------------------------------------------------------- 1 | // 2 | // PureMVC Java Standard 3 | // 4 | // Copyright(c) 2019 Saad Shams