com.asayama.gwt.angular.client.package-info Maven / Gradle / Ivy

Go to download
/**
 * Provides GWT Java wrapper around AngularJS. This module contains the 
 * components in Angular's "ng" module, which is the core of AngularJS 
 * framework. The core module contains enough components to start building a
 * simple application.
 * 
 * In order to use the components in this module, the user must add the 
 * following inherit statements in his or code.
 * 
 * {@code
 * 
 * }
 */
package com.asayama.gwt.angular.client;

import com.asayama.gwt.jsni.client.JSClosure;
import com.google.gwt.core.client.GWT;

/**
 * Provides interfaces for an object creator. This interface is intended to be
 * used with {@link DefaultInstantiableCreatorGenerator}, which inspects the types eligible for
 * creation at compile time.
 * 
 * The decision to separate the code generator from the underlying classes was
 * made to work around a limitation in GWT, which prevents us from implementing
 * multiple JavaScriptObject extensions sharing an interface.
 * 
 * 
 * @author kyoken74
 */
interface Creator {
     X create(Class klass);
}

interface FilterCreator extends Creator {
    static FilterCreator INSTANCE = GWT.create(FilterCreator.class);
    @Override
     X create(Class klass);
}

interface DirectiveCreator extends Creator {
    static DirectiveCreator INSTANCE = GWT.create(DirectiveCreator.class);
    @Override
     X create(Class klass);
}

interface ProviderCreator extends Creator {
    static ProviderCreator INSTANCE = GWT.create(ProviderCreator.class);
    @Override
     X create(Class klass);
}

interface ServiceCreator extends Creator {
    //static ServiceCreator INSTANCE = GWT.create(ServiceCreator.class);
    @Override
     X create(Class klass);
}

interface ControllerCreator extends Creator {
    static ControllerCreator INSTANCE = GWT.create(ControllerCreator.class);
    @Override
     X create(Class klass);
}

interface ClientResourcesCreator extends Creator {
    static ClientResourcesCreator INSTANCE = GWT.create(ClientResourcesCreator.class);
    @Override
     X create(Class klass);
}

/**
 * Provides interfaces for an object creator. This interface is intended to be
 * used with {@link DependenciesFactoryGenerator}, which inspects the types eligible for
 * creation at compile time.
 * 
 * The decision to separate the code generator from the underlying classes was
 * made to work around a limitation in GWT, which prevents us from implementing
 * multiple JavaScriptObject extensions sharing an interface.
 * 
 * 
 * @author kyoken74
 *
 * @see DependenciesFactoryGenerator
 * @param 
 */
interface DependenciesFactory {
    String[] create(T object);
}

interface ProviderDependenciesFactory extends DependenciesFactory {
    static ProviderDependenciesFactory INSTANCE = GWT.create(ProviderDependenciesFactory.class);
    @Override
    public String[] create(Provider object);
}

interface ServiceDependenciesFactory extends DependenciesFactory {
    static ServiceDependenciesFactory INSTANCE = GWT.create(ServiceDependenciesFactory.class);
    @Override
    public String[] create(Service object);
}

interface ControllerDependenciesFactory extends DependenciesFactory {
    static ControllerDependenciesFactory INSTANCE = GWT.create(ControllerDependenciesFactory.class);
    @Override
    public String[] create(Controller object);
}

interface DirectiveDependenciesFactory extends DependenciesFactory {
    static DirectiveDependenciesFactory INSTANCE = GWT.create(DirectiveDependenciesFactory.class);
    @Override
    public String[] create(Directive object);
}

interface FilterDependenciesFactory extends DependenciesFactory {
    static FilterDependenciesFactory INSTANCE = GWT.create(FilterDependenciesFactory.class);
    @Override
    public String[] create(Filter object);
}

/**
 * Provides interfaces for an object binder. This interface is intended to be
 * used with {@link ScopeBinderFactoryGenerator}, which inspects the types eligible for
 * creation at compile time.
 * 
 * The decision to separate the code generator from the underlying classes was
 * made to work around a limitation in GWT, which prevents us from implementing
 * multiple JavaScriptObject extensions sharing an interface.
 * 
 * 
 * @author kyoken74
 *
 * @see ScopeBinderFactoryGenerator
 * @param 
 */
interface ScopeBinderFactory {
    JSClosure create(T object);
}

/**
 * Represents the ScopeBinder factory for Controllers. In AngularJS, during the
 * construction of Controller class, we assign view models to the scope, so that
 * they are accessible from the view (HTML). This factory generates this
 * construction method on behalf of the user.
 * 
 * @author kyoken74
 */
interface ControllerScopeBinderFactory extends ScopeBinderFactory {
    static ControllerScopeBinderFactory INSTANCE = GWT.create(ControllerScopeBinderFactory.class);
    @Override
    public JSClosure create(Controller object);
}

/**
 * Represents the ScopeBinder factory for ClientBundle, so that the resources
 * declared as ClientBundle are readily available to the view (HTML) in a 
 * similar way the view models are available to the view via Controllers.
 *  
 * In AngularJS, during the construction of Controller class, we assign view 
 * models to the scope, so that they are accessible from the view (HTML). This 
 * factory generates this construction method on behalf of the user.
 * 
 * WARNING:
 * ClientBundleScopeBinderFactory is unable to provide the proper binding for
 * ClientBundle classes when the application is run in classic DevMode.
 * 
 * @author kyoken74
 */
interface ClientResourcesScopeBinderFactory extends ScopeBinderFactory {
    static ClientResourcesScopeBinderFactory INSTANCE = GWT.create(ClientResourcesScopeBinderFactory.class);
    @Override
    public JSClosure create(ClientResources object);
}

/**
 * Provides interfaces for an object injector. This interface is intended to be
 * used with {@link BinderFactoryGenerator}, which inspects the types eligible for
 * creation at compile time.
 * 
 * The decision to separate the code generator from the underlying classes was
 * made to work around a limitation in GWT, which prevents us from implementing
 * multiple JavaScriptObject extensions sharing an interface.
 * 
 * 
 * @author kyoken74
 *
 * @see BinderFactoryGenerator
 * @param 
 */
interface BinderFactory {
    JSClosure create(T object);
}

interface ProviderBinderFactory extends BinderFactory {
    static ProviderBinderFactory INSTANCE = GWT.create(ProviderBinderFactory.class);
    @Override
    public JSClosure create(Provider object);
}

interface ServiceBinderFactory extends BinderFactory {
    static ServiceBinderFactory INSTANCE = GWT.create(ServiceBinderFactory.class);
    @Override
    public JSClosure create(Service object);
}

interface ControllerBinderFactory extends BinderFactory {
    static ControllerBinderFactory INSTANCE = GWT.create(ControllerBinderFactory.class);
    @Override
    public JSClosure create(Controller object);
}

interface DirectiveBinderFactory extends BinderFactory {
    static DirectiveBinderFactory INSTANCE = GWT.create(DirectiveBinderFactory.class);
    @Override
    public JSClosure create(Directive object);
}

interface FilterBinderFactory extends BinderFactory {
    static FilterBinderFactory INSTANCE = GWT.create(FilterBinderFactory.class);
    @Override
    public JSClosure create(Filter object);
}