com.asayama.gwt.angular.client

Class AbstractModule

java.lang.Object

com.asayama.gwt.angular.client.AbstractModule

Direct Known Subclasses:

NG

public abstract class AbstractModule
extends Object

Provides an abstract implementation for AngularJS's Module object, and acts as an adapter for GWT module (represented by the EntryPoint interface) and Angular module (represented by the added interfaces in this class.

http://docs.angularjs.org/api/angular.Module

An Angular module represents a set of Angular components, such as controllers, services, filters, and directives. In and of itself, module component does not offer any added functionality. The task of registering various components relevant to the module is done by implementing the onModuleLoad() method.

It is recommended that the code to be organized such that a single GWT module represents a single Angular module. This will help the code kept organized, and easier to understand, though this is not strictly enforced by this framework. More advanced users may create separate sets of GWT and Angular module hierarchies and assemble them any way he wishes.

If you choose to mirror the GWT and Angular modules, then be sure to register your implementation of your Module to the GWT module descriptor as an entry point, e.g. com/example/app/MyModule.gwt.xml

<?xml version="1.0" encoding="UTF-8"?>
 <module>
   <inherits name="com.google.gwt.user.User" />
   <inherits name="com.asayama.gwt.angular.NG" />
   <source path="client" />
   <entry-point class="com.example.app.client.MyModule" />
 </module>
 

The corresponding MyModule class definition may look like

 // In this hypothetical example, the module consists of a constant named
 // "pages", directive named "myHello", filter named "reverse", and two
 // controllers, "com.exmaple.client.FooController" and 
 // "com.example.client.BarController".
 
 package com.example.app.client;
 
 public class MyModule extends AbstractModule implements EntryPoint {
   public void onModuleLoad() {
     Angular.module(this);
     constant("pages", JSArray.create(new String[]{
       "Introduction", "Theory", "Design", "Implementation", 
       "Test Methods", "Test Results", "Analysis", "Reference"
     }));
     directive(MyHello.class);
     filter(Reverse.class);
     controller(FooController.class);
     controller(BarController.class);
   }
 }
 

Note that this module focuses on registering the components into a single module, and is not concerned with building the user interface. The work of building the user interface (or bootstrapping) should be the job of a GWT module, and it is recommended that this is separated from the rest of the Angular module hierarchy. For example, com/example/ui/MyEntryPoint.gwt.xml

<?xml version="1.0" encoding="UTF-8"?>
 <module>
   <inherits name="com.google.gwt.user.User" />
   <inherits name="com.example.app.MyModule" />
   <source path="client" />
   <entry-point class="com.example.ui.client.MyEntryPoint" />
 </module>
 

The corresponding MyEntryPoint class definition may look like

 package com.example.ui.client;
 
 public class MyEntryPoint implements EntryPoint {
   public void onModuleLoad() {
     Angular.bootstrap();
   }
 }
 

If you follow this code organization convention, then the module dependency declared with <inherits> statements in *.gwt.xml files will be consistent with the Angular module dependency (i.e. "requires" property in AngularJS). You should have only one entry point that bootstraps the user interface per application.

Author:

kyoken74

Field Summary

Fields

Modifier and Type	Field and Description
protected com.asayama.gwt.angular.client.NGModule	ngo References to a JavaScriptObject representation known to the underlying AngularJS framework.

Constructor Summary

Constructors

Constructor and Description
AbstractModule()

Method Summary

Methods

Modifier and Type	Method and Description
<P extends Provider<?>> AbstractModule	config(Class<P> klass, Configurator<P> configurator) Configures a provider prior to obtaining the factory from it.
AbstractModule	constant(String name, Object value) Registers an object/data structure to the module.
<C extends Controller> AbstractModule	controller(Class<C> klass) Registers a controller component with the module.
<D extends Directive> AbstractModule	directive(Class<D> klass) Registers a Directive type with the module.
<S extends Service> AbstractModule	factory(Class<S> klass) Deprecated. Replaced by service(Class) since 0.0.68
<S extends Service> AbstractModule	factory(Factory<S> factory) Registers a service object factory instance with the module, so that the service object is created by the factory if/when the service is requested.
protected <S extends Service> AbstractModule	factory(String name, Factory<S> factory)
<F extends Filter> AbstractModule	filter(Class<F> klass) Registers a Filter type with the module.
String	getName() Returns the name of the module.
<P extends Provider<?>> AbstractModule	provider(Class<P> klass) TODO Implement this method
<R extends Runnable> AbstractModule	run(Class<R> klass) Runs module initialization task provided by klass.
<S extends Service> AbstractModule	service(Class<S> klass) Registers a Service class to the module.
<S extends Service> AbstractModule	service(S service) Registers an instance of a Service object to the module.
AbstractModule	value(String name, Object object) Registers an object/data structure to the module.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

ngo

protected com.asayama.gwt.angular.client.NGModule ngo

References to a JavaScriptObject representation known to the underlying AngularJS framework.

See Also:

Angular.module(AbstractModule, Closure, String...)

Constructor Detail

AbstractModule

public AbstractModule()

Method Detail

provider

public <P extends Provider<?>> AbstractModule provider(Class<P> klass)

TODO Implement this method

Parameters:

klass -

Returns:

factory

@Deprecated
public <S extends Service> AbstractModule factory(Class<S> klass)

Deprecated. Replaced by service(Class) since 0.0.68

factory

public <S extends Service> AbstractModule factory(Factory<S> factory)

Registers a service object factory instance with the module, so that the service object is created by the factory if/when the service is requested. The method is useful if the service creation needs customization/configuration, e.g. the creation of the service depends on other resources. If you merely wish to create an object via new or GWT.create(), then there is a convenience method service(Class) so you do not have to define or instantiate a custom factory.

Parameters:

factory - An instance of Factory object that creates a Service object.

factory

protected <S extends Service> AbstractModule factory(String name,
                                         Factory<S> factory)

service

public <S extends Service> AbstractModule service(Class<S> klass)

Registers a Service class to the module. This method is equivalent to

 MyModule module = new MyModule();
 module.factory(new DefaultFactory<S>(MyService.class)); 
 

service

public <S extends Service> AbstractModule service(S service)

Registers an instance of a Service object to the module. This method is useful if the service object has already been instantiated by someone else outside of Angular, so there is no benefit to deferring the instantiation of that object.

If you have defined your own Service type, and wish to let the framework handle the instantiation, then use service(Class) instead.

See Also:

Factory, DefaultFactory

value

public AbstractModule value(String name,
                   Object object)

Registers an object/data structure to the module. Objects registered by this method are accessible by services and controllers via Injector.Inject annotation within the same module. For example,

 MyModule module = new MyModule();
 Angular.module(module);
 module.value("myValue", "Hello, World!");
 module.service(MyService.class);
 ...
 class MyService implements Service {
   @Injector.Inject("myValue") 
   String myValue; //injector assigns "Hello, World!"
 }
 

The concept of value in AngularJS is a useful way to manage objects that are of module scope. With GWT, however, we can accomplish the same thing by simply using the Java package name with public static, if the value is used exclusively in GWT. The method is nevertheless useful if your module is expected to be a hybrid of GWT and JavaScript.

Parameters:

name - Name of the object.

object - The instance of the object.

constant

public AbstractModule constant(String name,
                      Object value)

Registers an object/data structure to the module. Objects registered by this method are accessible by services and controllers via Injector.Inject annotation within the same module, or to a module during configuration. For example,

 MyModule module = new MyModule();
 Angular.module(module);
 module.constant("myConstant", "Hello, World!");
 module.configure(MyServiceProvider.class, Configurator<MyServiceProvider>() {
   public void configure(MyServiceProvider provider) {
     //configure provider
   }
 });
 ...
 class MyServiceProvider implements Provider {
   @Injector.Inject("myConstant") 
   String myConstant; //injector assigns "Hello, World!"
 }
 

The concept of value in AngularJS is a useful way to manage objects that are of module scope. With GWT, however, we can accomplish the same thing by simply using the Java package name with public static, if the value is used exclusively in GWT. The method is nevertheless useful if your module is expected to be a hybrid of GWT and JavaScript.

Parameters:

name - Name of the object.

object - The instance of the object.

filter

public <F extends Filter> AbstractModule filter(Class<F> klass)

Registers a Filter type with the module. The name of the component is derived from the class name, e.g.

 // Derived name is "myFilter". Java package is omitted.
 filter(com.example.MyFilter.class);
 

Parameters:

klass - Filter type

controller

public <C extends Controller> AbstractModule controller(Class<C> klass)

Registers a controller component with the module. The name of the component is derived from the class name, e.g.

 // Derived name is "com.example.MyController".
 controller(com.example.MyController.class);
 

Parameters:

klass - Controller type.

directive

public <D extends Directive> AbstractModule directive(Class<D> klass)

Registers a Directive type with the module. The name of the component is derived from the class name, e.g.

 // Derived name is "myDirective". Java package is omitted.
 // Attribute directive usage is <div data-my-directive> 
 // Class directive usage is <div class="my-directive"> 
 // Element directive usage is <my-directive> 
 directive(com.example.MyDirective.class);
 

Parameters:

Directive - type.

config

public <P extends Provider<?>> AbstractModule config(Class<P> klass,
                                            Configurator<P> configurator)

Configures a provider prior to obtaining the factory from it. Use the Configurator to configure the provider injected into the module.

Parameters:

klass - Provider type to be configured at module initialization.

configuration - Configures the provider.

run

public <R extends Runnable> AbstractModule run(Class<R> klass)

Runs module initialization task provided by klass. Whilst the task is defined as a Runnable, the task is not executed in a separate thread. The tasks are executed synchronously.

Parameters:

runnable - Module initialization task.

Since:

0.1.1

getName

public String getName()

Returns the name of the module. Every Angular module must be registered with Angular framework, and give a name at the time of the registration. This ensures that only one instance of the module per name exists at runtime. See Angular class methods for more details.