First changes

Author: dudochkin-victor

Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "ruex"
+version = "0.1.0"
+authors = ["Victor Dudochkin <dudochkin.victor@gmail.com>"]
+edition = "2018"
+
+[dependencies]
+yew = "0.17"
+log = "0.4"
+serde = { version = "1.0", features = ["derive"] }
+wasm-logger = "0.2"

src/core/controller.rs

@@ -0,0 +1,144 @@
+//! A Singleton IController implementation.
+//!
+//! In RuEx, the Controller class follows the
+//! 'Command and Controller' strategy, and assumes these
+//! responsibilities:
+//!
+//! * Remembering which ICommands
+//! are intended to handle which INotifications.
+//! * Registering itself as an IObserver with
+//! the View for each INotification
+//! that it has an ICommand mapping for.
+//! * Creating a new instance of the proper ICommand
+//! to handle a given INotification when notified by the View.
+//! * Calling the ICommand's execute
+//! method, passing in the INotification.
+//! 
+//! Your application must register ICommands with the
+//! Controller.
+//!
+//! The simplest way is to subclass Facade,
+//! and use its initializeController method to add your
+//! registrations.
+//!
+
+#![allow(unused_variables)]
+#![allow(dead_code)]
+
+// use crate::core::*;
+use crate::interfaces::*;
+// use crate::patterns::observer::*;
+
+// // Singleton instance
+// protected static var instance : IController;
+
+// // Message Constants
+// protected const SINGLETON_MSG : String = "Controller Singleton already constructed!";
+
+pub struct Controller<B, C, V> {
+ /// Local reference to View
+ view: Box<dyn IView<B, C, V>>,
+
+ /// Mapping of Notification names to Command Class references
+ command_map: Vec<String>,
+}
+
+impl<B, C, V> Controller<B, C, V> {
+ /// Constructor.
+ ///
+ ///
+ /// This IController implementation is a Singleton,
+ /// so you should not call the constructor
+ /// directly, but instead call the static Singleton
+ /// Factory method Controller.getInstance()
+ ///
+ /// @throws Error Error if Singleton instance has already been constructed
+ pub fn new() {
+ // if (instance != null) throw Error(SINGLETON_MSG);
+ // instance = this;
+ // commandMap = new Array();
+ // initializeController();
+ }
+
+ /// Initialize the Singleton Controller instance.
+ ///
+ /// Called automatically by the constructor.
+ ///
+ /// Note that if you are using a subclass of View
+ /// in your application, you should also subclass Controller
+ /// and override the initializeController method in the
+ /// following way:
+ ///
+ /// //TODO: Example here
+ ///
+ fn initialize_controller() {
+ // view = View.getInstance();
+ }
+
+ /// Controller Singleton Factory method.
+ ///
+ /// Returns the Singleton instance of Controller
+ /// pub static fn
+ pub fn get_instance() -> Box<dyn IController<B>> {
+ // if ( instance == null ) instance = new Controller( );
+ // return instance;
+ unimplemented!()
+ }
+}
+
+impl<B, C, V> IController<B> for Controller<B, C, V> {
+ /// If an ICommand has previously been registered
+ /// to handle a the given INotification, then it is executed.
+ ///
+ /// * `note` - an INotification
+ fn execute_command(&self, note: Box<dyn INotification<B>>) {
+ // var commandFactory : Box<dyn FnOnce()> = commandMap[ note.getName() ];
+ // if ( commandFactory == null ) return;
+
+ // var commandInstance : ICommand = new commandFactory();
+ // commandInstance.execute( note );
+ }
+
+ /// Register a particular ICommand class as the handler
+ /// for a particular INotification.
+ ///
+ /// If an ICommand has already been registered to
+ /// handle INotifications with this name, it is no longer
+ /// used, the new ICommand is used instead.
+ ///
+ /// The Observer for the new ICommand is only created if this the
+ /// first time an ICommand has been regisered for this Notification name.
+ ///
+ /// * `notification_name` - the name of the INotification
+ /// * `command_factory` - the Class of the ICommand
+ fn register_command(&self, notification_name: String, command_factory: Box<dyn FnOnce()>) {
+ // if ( commandMap[ notificationName ] == null ) {
+ //	view.registerObserver( notificationName, new Observer( executeCommand, this ) );
+ // }
+ // commandMap[ notificationName ] = commandFactory;
+ }
+
+ /// Check if a Command is registered for a given Notification
+ ///
+ /// * `notification_name` - 
+ /// Returns whether a Command is currently registered for the given notificationName.
+ fn has_command(&self, notification_name: String) -> bool {
+ // return commandMap[ notificationName ] != null;
+ unimplemented!()
+ }
+
+ /// Remove a previously registered ICommand to INotification mapping.
+ ///
+ /// * `notification_name` - the name of the INotification to remove the ICommand mapping for
+ fn remove_command(&self, notification_name: String) {
+ // // if the Command is registered...
+ // if ( hasCommand( notificationName ) )
+ // {
+ //	// remove the observer
+ //	view.removeObserver( notificationName, this );
+
+ //	// remove the command
+ //	commandMap[ notificationName ] = null;
+ // }
+ }
+}

src/core/mod.rs

@@ -0,0 +1,8 @@
+mod controller;
+pub use controller::*;
+
+mod model;
+pub use model::*;
+
+mod view;
+pub use model::*;

src/core/model.rs

@@ -0,0 +1,112 @@
+//! A Singleton IModel implementation.
+//!
+//! In RuEx, the Model class provides
+//! access to model objects (Proxies) by named lookup.
+//!
+//! The Model assumes these responsibilities:
+//!
+//! * Maintain a cache of IProxy instances.
+//! * Provide methods for registering, retrieving, and removing
+//! IProxy instances.
+//!
+//! Your application must register IProxy instances
+//! with the Model. Typically, you use an
+//! ICommand to create and register IProxy
+//! instances once the Facade has initialized the Core
+//! actors.
+
+#![allow(dead_code)]
+#![allow(unused_variables)]
+
+use crate::interfaces::*;
+
+// // Singleton instance
+// protected static var instance : IModel;
+
+// // Message Constants
+// protected const SINGLETON_MSG	: String = "Model Singleton already constructed!";
+
+pub struct Model<D> {
+ /// Mapping of proxyNames to IProxy instances
+ proxy_map: Vec<D>, // FIXME: adjust
+}
+
+impl<D> Model<D> {
+ /// Constructor.
+ ///
+ ///
+ /// This IModel implementation is a Singleton,
+ /// so you should not call the constructor
+ /// directly, but instead call the static Singleton
+ /// Factory method Model.getInstance()
+ ///
+ /// @throws Error Error if Singleton instance has already been constructed
+ pub fn new() {
+ // if (instance != null) throw Error(SINGLETON_MSG);
+ // instance = this;
+ // proxyMap = new Array();
+ // initializeModel();
+ }
+
+ /// Initialize the Singleton Model instance.
+ ///
+ /// Called automatically by the constructor, this
+ /// is your opportunity to initialize the Singleton
+ /// instance in your subclass without overriding the
+ /// constructor.
+ ///
+ fn initialize_model() {}
+
+ /// Model Singleton Factory method.
+ ///
+ /// Returns the Singleton instance
+ /// static fn
+ fn get_instance() -> Box<dyn IModel<D>> {
+ // if (instance == null) instance = new Model( );
+ // return instance;
+ unimplemented!()
+ }
+}
+
+impl<D> IModel<D> for Model<D> {
+ /// Register an IProxy with the Model.
+ ///
+ /// * `proxy` - an IProxy to be held by the Model.
+ fn register_proxy(&self, proxy: Box<dyn IProxy<D>>) {
+ // proxyMap[ proxy.getProxyName() ] = proxy;
+ // proxy.onRegister();
+ }
+
+ /// Retrieve an IProxy from the Model.
+ ///
+ /// * `proxy_name` -
+ /// Returns the IProxy instance previously registered with the given proxyName.
+ fn retrieve_proxy(&self, proxy_name: String) -> Box<dyn IProxy<D>> {
+ // return proxyMap[ proxyName ];
+ unimplemented!()
+ }
+
+ /// Check if a Proxy is registered
+ ///
+ /// * `proxy_name` -
+ /// Returns whether a Proxy is currently registered with the given proxyName.
+ fn has_proxy(&self, proxy_name: String) -> bool {
+ // return proxyMap[ proxy_name ] != null;
+ unimplemented!()
+ }
+
+ /// Remove an IProxy from the Model.
+ ///
+ /// * `proxy_name` - name of the IProxy instance to be removed.
+ /// Returns the IProxy that was removed from the Model
+ fn remove_proxy(&self, proxy_name: String) -> Box<dyn IProxy<D>> {
+ // var proxy:IProxy = proxyMap [ proxyName ] as IProxy;
+ // if ( proxy )
+ // {
+ //	proxyMap[ proxyName ] = null;
+ //	proxy.onRemove();
+ // }
+ // return proxy;
+ unimplemented!()
+ }
+}