org.codehaus.griffon.runtime.core.mvc

Class AbstractMVCGroupManager

java.lang.Object

org.codehaus.griffon.runtime.core.mvc.AbstractMVCGroupManager

All Implemented Interfaces:

MVCGroupManager, MVCHandler

Direct Known Subclasses:

DefaultMVCGroupManager

public abstract class AbstractMVCGroupManager
extends Object
implements MVCGroupManager

Base implementation of the MVCGroupManager interface.

Since:

2.0.0

Author:

Andres Almiray

Field Summary

Fields

Modifier and Type	Field and Description
protected static String	ERROR_ARGS_NULL
protected static String	ERROR_CONFIG_NULL
protected static String	ERROR_CONFIGURATION_NULL
protected static String	ERROR_GROUP_NULL
protected static String	ERROR_MVCID_BLANK
protected static String	ERROR_MVCTYPE_BLANK
protected static String	ERROR_NAME_BLANK
protected static String	ERROR_TYPE_NULL

Constructor Summary

Constructors

Constructor and Description
AbstractMVCGroupManager(GriffonApplication application)

Method Summary

Modifier and Type	Method and Description
void	addConfiguration(MVCGroupConfiguration configuration)
protected void	addGroup(MVCGroup group)
MVCGroupConfiguration	cloneMVCGroupConfiguration(String mvcType, Map<String,Object> config) Clones an existing MVCGroupConfiguration, optionally overriding additional config values.
List<? extends GriffonMvcArtifact>	createMVC(Map<String,Object> args, String mvcType) Instantiates an MVC group of the specified type with additional variables.
List<? extends GriffonMvcArtifact>	createMVC(Map<String,Object> args, String mvcType, String mvcId) Instantiates an MVC group of the specified type with a particular name.
protected List<? extends GriffonMvcArtifact>	createMVC(MVCGroupConfiguration configuration, String mvcId, Map<String,Object> args)
List<? extends GriffonMvcArtifact>	createMVC(String mvcType) Instantiates an MVC group of the specified type returning only the MVC parts.
List<? extends GriffonMvcArtifact>	createMVC(String mvcType, Map<String,Object> args) Instantiates an MVC group of the specified type with additional variables.
List<? extends GriffonMvcArtifact>	createMVC(String mvcType, String mvcId) Instantiates an MVC group of the specified type with a particular name.
List<? extends GriffonMvcArtifact>	createMVC(String mvcType, String mvcId, Map<String,Object> args) Instantiates an MVC group of the specified type with a particular name.
MVCGroup	createMVCGroup(Map<String,Object> args, String mvcType) Instantiates an MVC group of the specified type with additional variables.
MVCGroup	createMVCGroup(Map<String,Object> args, String mvcType, String mvcId) Instantiates an MVC group of the specified type with a particular name.
protected abstract MVCGroup	createMVCGroup(MVCGroupConfiguration configuration, String mvcId, Map<String,Object> args)
MVCGroup	createMVCGroup(String mvcType) Instantiates an MVC group of the specified type.
MVCGroup	createMVCGroup(String mvcType, Map<String,Object> args) Instantiates an MVC group of the specified type with additional variables.
MVCGroup	createMVCGroup(String mvcType, String mvcId) Instantiates an MVC group of the specified type with a particular name.
MVCGroup	createMVCGroup(String mvcType, String mvcId, Map<String,Object> args) Instantiates an MVC group of the specified type with a particular name.
protected abstract void	doInitialize(Map<String,MVCGroupConfiguration> configurations)
MVCGroupConfiguration	findConfiguration(String mvcType)
<C extends GriffonController> C	findController(String name, Class<C> type) Finds a named controller.
MVCGroup	findGroup(String mvcId)
<M extends GriffonModel> M	findModel(String name, Class<M> type) Finds a named model.
<V extends GriffonView> V	findView(String name, Class<V> type) Finds a named view.
GriffonApplication	getApplication()
MVCGroup	getAt(String mvcId)
Map<String,MVCGroupConfiguration>	getConfigurations()
<C extends GriffonController> C	getController(String name, Class<C> type) Finds a named controller.
Map<String,? extends GriffonController>	getControllers() Returns all currently available controller instances, keyed by group name.
Map<String,MVCGroup>	getGroups()
<M extends GriffonModel> M	getModel(String name, Class<M> type) Finds a named model.
Map<String,? extends GriffonModel>	getModels() Returns all currently available model instances, keyed by group name.
<V extends GriffonView> V	getView(String name, Class<V> type) Finds a named view.
Map<String,? extends GriffonView>	getViews() Returns all currently available view instances, keyed by group name.
void	initialize(Map<String,MVCGroupConfiguration> configurations) Initializes this manager with the group configurations provided by the application and addons.
void	removeConfiguration(MVCGroupConfiguration configuration)
void	removeConfiguration(String name)
protected void	removeGroup(MVCGroup group)
<M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVC(Map<String,Object> args, String mvcType, MVCFunction<M,V,C> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
<M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVC(Map<String,Object> args, String mvcType, String mvcId, MVCFunction<M,V,C> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
<M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVC(String mvcType, Map<String,Object> args, MVCFunction<M,V,C> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
<M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVC(String mvcType, MVCFunction<M,V,C> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
<M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVC(String mvcType, String mvcId, Map<String,Object> args, MVCFunction<M,V,C> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
<M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVC(String mvcType, String mvcId, MVCFunction<M,V,C> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
void	withMVCGroup(Map<String,Object> args, String mvcType, MVCGroupFunction handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
void	withMVCGroup(Map<String,Object> args, String mvcType, String mvcId, MVCGroupFunction handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
protected <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVCGroup(MVCGroupConfiguration configuration, String mvcId, Map<String,Object> args, MVCFunction<M,V,C> handler)
protected void	withMVCGroup(MVCGroupConfiguration configuration, String mvcId, Map<String,Object> args, MVCGroupFunction handler)
void	withMVCGroup(String mvcType, Map<String,Object> args, MVCGroupFunction handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
void	withMVCGroup(String mvcType, MVCGroupFunction handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
void	withMVCGroup(String mvcType, String mvcId, Map<String,Object> args, MVCGroupFunction handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
void	withMVCGroup(String mvcType, String mvcId, MVCGroupFunction handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.

Methods inherited from class java.lang.Object

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

Methods inherited from interface griffon.core.mvc.MVCGroupManager

newMVCGroup, newMVCGroupConfiguration

Methods inherited from interface griffon.core.mvc.MVCHandler

destroyMVCGroup

Field Detail

ERROR_MVCTYPE_BLANK

protected static final String ERROR_MVCTYPE_BLANK

See Also:

Constant Field Values

ERROR_MVCID_BLANK

protected static final String ERROR_MVCID_BLANK

See Also:

Constant Field Values

ERROR_CONFIGURATION_NULL

protected static final String ERROR_CONFIGURATION_NULL

See Also:

Constant Field Values

ERROR_GROUP_NULL

protected static final String ERROR_GROUP_NULL

See Also:

Constant Field Values

ERROR_CONFIG_NULL

protected static final String ERROR_CONFIG_NULL

See Also:

Constant Field Values

ERROR_ARGS_NULL

protected static final String ERROR_ARGS_NULL

See Also:

Constant Field Values

ERROR_NAME_BLANK

protected static final String ERROR_NAME_BLANK

See Also:

Constant Field Values

ERROR_TYPE_NULL

protected static final String ERROR_TYPE_NULL

See Also:

Constant Field Values

Constructor Detail

AbstractMVCGroupManager

@Inject
public AbstractMVCGroupManager(@Nonnull
                                       GriffonApplication application)

Method Detail

getApplication

public GriffonApplication getApplication()

Specified by:

getApplication in interface MVCGroupManager

getConfigurations

@Nonnull
public Map<String,MVCGroupConfiguration> getConfigurations()

Specified by:

getConfigurations in interface MVCGroupManager

getGroups

@Nonnull
public Map<String,MVCGroup> getGroups()

Specified by:

getGroups in interface MVCGroupManager

findConfiguration

@Nonnull
public MVCGroupConfiguration findConfiguration(@Nonnull
                                                        String mvcType)

Specified by:

findConfiguration in interface MVCGroupManager

findGroup

@Nullable
public MVCGroup findGroup(@Nonnull
                                    String mvcId)

Specified by:

findGroup in interface MVCGroupManager

getAt

@Nullable
public MVCGroup getAt(@Nonnull
                                String mvcId)

Specified by:

getAt in interface MVCGroupManager

initialize

public final void initialize(@Nonnull
                             Map<String,MVCGroupConfiguration> configurations)

Description copied from interface: MVCGroupManager

Initializes this manager with the group configurations provided by the application and addons.

Specified by:

initialize in interface MVCGroupManager

Parameters:

configurations - available group configurations

addConfiguration

public void addConfiguration(@Nonnull
                             MVCGroupConfiguration configuration)

Specified by:

addConfiguration in interface MVCGroupManager

removeConfiguration

public void removeConfiguration(@Nonnull
                                MVCGroupConfiguration configuration)

Specified by:

removeConfiguration in interface MVCGroupManager

removeConfiguration

public void removeConfiguration(@Nonnull
                                String name)

Specified by:

removeConfiguration in interface MVCGroupManager

addGroup

protected void addGroup(@Nonnull
                        MVCGroup group)

removeGroup

protected void removeGroup(@Nonnull
                           MVCGroup group)

getModels

@Nonnull
public final Map<String,? extends GriffonModel> getModels()

Description copied from interface: MVCGroupManager

Returns all currently available model instances, keyed by group name.

Specified by:

getModels in interface MVCGroupManager

Returns:

a Map of all currently instantiated models.

getViews

@Nonnull
public final Map<String,? extends GriffonView> getViews()

Description copied from interface: MVCGroupManager

Returns all currently available view instances, keyed by group name.

Specified by:

getViews in interface MVCGroupManager

Returns:

a Map of all currently instantiated views.

getControllers

@Nonnull
public final Map<String,? extends GriffonController> getControllers()

Description copied from interface: MVCGroupManager

Returns all currently available controller instances, keyed by group name.

Specified by:

getControllers in interface MVCGroupManager

Returns:

a Map of all currently instantiated controllers.

cloneMVCGroupConfiguration

@Nonnull
public MVCGroupConfiguration cloneMVCGroupConfiguration(@Nonnull
                                                                 String mvcType,
                                                                 @Nonnull
                                                                 Map<String,Object> config)

Description copied from interface: MVCGroupManager

Clones an existing MVCGroupConfiguration, optionally overriding additional config values.

Specified by:

cloneMVCGroupConfiguration in interface MVCGroupManager

Parameters:

mvcType - the name of the configuration to clone

config - additional config parameters to be set on the configuration

Returns:

a ready-to-use MVCGroupConfiguration instance

createMVC

@Nonnull
protected List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                                MVCGroupConfiguration configuration,
                                                                @Nullable
                                                                String mvcId,
                                                                @Nonnull
                                                                Map<String,Object> args)

withMVCGroup

protected <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVCGroup(@Nonnull
                                                                                                       MVCGroupConfiguration configuration,
                                                                                                       @Nullable
                                                                                                       String mvcId,
                                                                                                       @Nonnull
                                                                                                       Map<String,Object> args,
                                                                                                       @Nonnull
                                                                                                       MVCFunction<M,V,C> handler)

withMVCGroup

protected void withMVCGroup(@Nonnull
                            MVCGroupConfiguration configuration,
                            @Nullable
                            String mvcId,
                            @Nonnull
                            Map<String,Object> args,
                            @Nonnull
                            MVCGroupFunction handler)

createMVCGroup

@Nonnull
protected abstract MVCGroup createMVCGroup(@Nonnull
                                                    MVCGroupConfiguration configuration,
                                                    @Nullable
                                                    String mvcId,
                                                    @Nonnull
                                                    Map<String,Object> args)

doInitialize

protected abstract void doInitialize(@Nonnull
                                     Map<String,MVCGroupConfiguration> configurations)

createMVCGroup

@Nonnull
public MVCGroup createMVCGroup(@Nonnull
                                        String mvcType)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

An instance of the "foo" group can be created as follows

 Map fooGroup = createMVCGroup('foo')
 assert (fooGroup.controller instanceof FooController)
 

Specified by:

createMVCGroup in interface MVCHandler

Parameters:

mvcType - the type of group to build.

Returns:

an MVCGroup instance of the desired type

createMVCGroup

@Nonnull
public MVCGroup createMVCGroup(@Nonnull
                                        String mvcType,
                                        @Nonnull
                                        String mvcId)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with a particular name.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

An instance of the "foo" group can be created as follows

 MVCGroup fooGroup = createMVCGroup('foo', 'foo' + System.currentTimeMillis())
 assert (fooGroup.controller instanceof FooController)
 

MVC groups must have an unique name.

Specified by:

createMVCGroup in interface MVCHandler

Parameters:

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

Returns:

an MVCGroup instance of the desired type

createMVCGroup

@Nonnull
public MVCGroup createMVCGroup(@Nonnull
                                        Map<String,Object> args,
                                        @Nonnull
                                        String mvcType)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with additional variables.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
     'bar' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.BarView'
         controller = 'com.acme.BarController'
     }
 }
 

Notice that groups "foo" and "bar share the same model type, We can make them share the same model instance by creating the groups in the following way:

 MVCGroup fooGroup = createMVCGroup('foo')
 MVCGroup barGroup = createMVCGroup('bar', model: fooGroup.model)
 assert fooGroup.model == barGroup.model
 

Specified by:

createMVCGroup in interface MVCHandler

Parameters:

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

mvcType - the type of group to build.

Returns:

an MVCGroup instance of the desired type

createMVCGroup

@Nonnull
public MVCGroup createMVCGroup(@Nonnull
                                        String mvcType,
                                        @Nonnull
                                        Map<String,Object> args)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with additional variables.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
     'bar' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.BarView'
         controller = 'com.acme.BarController'
     }
 }
 

Notice that groups "foo" and "bar share the same model type, We can make them share the same model instance by creating the groups in the following way:

 MVCGroup fooGroup = createMVCGroup('foo')
 MVCGroup barGroup = createMVCGroup('bar', model: fooGroup.model)
 assert fooGroup.model == barGroup.model
 

Specified by:

createMVCGroup in interface MVCHandler

Parameters:

mvcType - the type of group to build.

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

Returns:

an MVCGroup instance of the desired type

createMVCGroup

@Nonnull
public MVCGroup createMVCGroup(@Nonnull
                                        Map<String,Object> args,
                                        @Nonnull
                                        String mvcType,
                                        @Nonnull
                                        String mvcId)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with a particular name.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

We can create two instances of the same group that share the same model instance in the following way:

 MVCGroup fooGroup1 = createMVCGroup('foo', 'foo1')
 MVCGroup fooGroup2 = createMVCGroup('bar', 'foo2', model: fooGroup1.model)
 assert fooGroup1.model == fooGroup2.model
 

MVC groups must have an unique name.

Specified by:

createMVCGroup in interface MVCHandler

Parameters:

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

Returns:

an MVCGroup instance of the desired type

createMVCGroup

@Nonnull
public MVCGroup createMVCGroup(@Nonnull
                                        String mvcType,
                                        @Nonnull
                                        String mvcId,
                                        @Nonnull
                                        Map<String,Object> args)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with a particular name.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

We can create two instances of the same group that share the same model instance in the following way:

 MVCGroup fooGroup1 = createMVCGroup('foo', 'foo1')
 MVCGroup fooGroup2 = createMVCGroup('bar', 'foo2', model: fooGroup1.model)
 assert fooGroup1.model == fooGroup2.model
 

MVC groups must have an unique name.

Specified by:

createMVCGroup in interface MVCHandler

Parameters:

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

Returns:

an MVCGroup instance of the desired type

createMVC

@Nonnull
public List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                             String mvcType)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type returning only the MVC parts.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

An instance of the "foo" group can be created as follows

 def (m, v, c) = createMVC('foo')
 assert (c instanceof FooController)
 

Specified by:

createMVC in interface MVCHandler

Parameters:

mvcType - the type of group to build.

Returns:

a List with the canonical MVC members of the group

createMVC

@Nonnull
public List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                             Map<String,Object> args,
                                                             @Nonnull
                                                             String mvcType)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with additional variables.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
     'bar' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.BarView'
         controller = 'com.acme.BarController'
     }
 }
 

Notice that groups "foo" and "bar share the same model type, We can make them share the same model instance by creating the groups in the following way:

 def (m1, v1, c1) = createMVC('foo')
 def (m2, v2, c2) = createMVC('bar', model: m1)
 assert fm1 == m2
 

Specified by:

createMVC in interface MVCHandler

Parameters:

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

mvcType - the type of group to build.

Returns:

a List with the canonical MVC members of the group

createMVC

@Nonnull
public List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                             String mvcType,
                                                             @Nonnull
                                                             Map<String,Object> args)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with additional variables.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
     'bar' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.BarView'
         controller = 'com.acme.BarController'
     }
 }
 

Notice that groups "foo" and "bar share the same model type, We can make them share the same model instance by creating the groups in the following way:

 def (m1, v1, c1) = createMVC('foo')
 def (m2, v2, c2) = createMVC('bar', model: m1)
 assert fm1 == m2
 

Specified by:

createMVC in interface MVCHandler

Parameters:

mvcType - the type of group to build.

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

Returns:

a List with the canonical MVC members of the group

createMVC

@Nonnull
public List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                             String mvcType,
                                                             @Nonnull
                                                             String mvcId)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with a particular name.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
      }
 }
 

An instance of the "foo" group can be created as follows

 def (m, v, c) = createMVC('foo', 'foo' + System.currenttimeMillis())
 assert (c instanceof FooController)
 

MVC groups must have an unique name.

Specified by:

createMVC in interface MVCHandler

Parameters:

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

Returns:

a List with the canonical MVC members of the group

createMVC

@Nonnull
public List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                             Map<String,Object> args,
                                                             @Nonnull
                                                             String mvcType,
                                                             @Nonnull
                                                             String mvcId)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with a particular name.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

We can create two instances of the same group that share the same model instance in the following way:

 def (m1, v1, c1) = createMVC('foo', 'foo1')
 def (m2, v2, c2) = createMVC('foo', 'foo2', model: m1)
 assert fm1 == m2
 

MVC groups must have an unique name.

Specified by:

createMVC in interface MVCHandler

Parameters:

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

Returns:

a List with the canonical MVC members of the group

createMVC

@Nonnull
public List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                             String mvcType,
                                                             @Nonnull
                                                             String mvcId,
                                                             @Nonnull
                                                             Map<String,Object> args)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type with a particular name.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

We can create two instances of the same group that share the same model instance in the following way:

 def (m1, v1, c1) = createMVC('foo', 'foo1')
 def (m2, v2, c2) = createMVC('foo', 'foo2', model: m1)
 assert fm1 == m2
 

MVC groups must have an unique name.

Specified by:

createMVC in interface MVCHandler

Parameters:

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

Returns:

a List with the canonical MVC members of the group

withMVC

public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                               String mvcType,
                                                                                               @Nonnull
                                                                                               MVCFunction<M,V,C> handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
    }
 }
 

An instance of the "foo" group can be used as follows

 withMVC("foo", new MVCCallable<FooModel, FooView, FooController>() {
     public void call(FooModel m, FooView v, FooController c) {
         m.setSomeProperty(someValue);
         c.invokeAnAction();
     }
 });
 

Specified by:

withMVC in interface MVCHandler

Parameters:

mvcType - the type of group to build.

handler - a code block used to configure and manage the instantiated group

withMVC

public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                               String mvcType,
                                                                                               @Nonnull
                                                                                               String mvcId,
                                                                                               @Nonnull
                                                                                               MVCFunction<M,V,C> handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

An instance of the "foo" group can be used as follows

 withMVC("foo", "foo1", new MVCCallable<FooModel, FooView, FooController>() {
     public void call(FooModel m, FooView v, FooController c) {
         m.setSomeProperty(someValue);
         c.invokeAnAction();
     }
 });
 

MVC groups must have an unique name.

Specified by:

withMVC in interface MVCHandler

Parameters:

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

handler - a code block used to configure and manage the instantiated group

withMVC

public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                               String mvcType,
                                                                                               @Nonnull
                                                                                               String mvcId,
                                                                                               @Nonnull
                                                                                               Map<String,Object> args,
                                                                                               @Nonnull
                                                                                               MVCFunction<M,V,C> handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

An instance of the "foo" group can be used as follows

 Map map = ... // initialized elsewhere
 withMVC("foo", "foo1", map, new MVCCallable<FooModel, FooView, FooController>() {
    public void call(FooModel m, FooView v, FooController c) {
        m.setSomeProperty(someValue);
        c.invokeAnAction();
    }
 });
 

MVC groups must have an unique name.

Specified by:

withMVC in interface MVCHandler

Parameters:

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

handler - a code block used to configure and manage the instantiated group

withMVC

public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                               Map<String,Object> args,
                                                                                               @Nonnull
                                                                                               String mvcType,
                                                                                               @Nonnull
                                                                                               String mvcId,
                                                                                               @Nonnull
                                                                                               MVCFunction<M,V,C> handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

An instance of the "foo" group can be used as follows

 Map map = ... // initialized elsewhere
 withMVC("foo", "foo1", map, new MVCCallable<FooModel, FooView, FooController>() {
    public void call(FooModel m, FooView v, FooController c) {
        m.setSomeProperty(someValue);
        c.invokeAnAction();
    }
 });
 

MVC groups must have an unique name.

Specified by:

withMVC in interface MVCHandler

Parameters:

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

handler - a code block used to configure and manage the instantiated group

withMVC

public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                               String mvcType,
                                                                                               @Nonnull
                                                                                               Map<String,Object> args,
                                                                                               @Nonnull
                                                                                               MVCFunction<M,V,C> handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
    }
 }
 

An instance of the "foo" group can be used as follows

 Map map = ... // initialized elsewhere
 withMVC("foo", map, new MVCCallable<FooModel, FooView, FooController>() {
    public void call(FooModel m, FooView v, FooController c) {
        m.setSomeProperty(someValue);
        c.invokeAnAction();
    }
 });
 

Specified by:

withMVC in interface MVCHandler

Parameters:

mvcType - the type of group to build.

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

handler - a code block used to configure and manage the instantiated group

withMVC

public <M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                               Map<String,Object> args,
                                                                                               @Nonnull
                                                                                               String mvcType,
                                                                                               @Nonnull
                                                                                               MVCFunction<M,V,C> handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
    }
 }
 

An instance of the "foo" group can be used as follows

 Map map = ... // initialized elsewhere
 withMVC("foo", map, new MVCCallable<FooModel, FooView, FooController>() {
    public void call(FooModel m, FooView v, FooController c) {
        m.setSomeProperty(someValue);
        c.invokeAnAction();
    }
 });
 

Specified by:

withMVC in interface MVCHandler

Parameters:

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

mvcType - the type of group to build.

handler - a code block used to configure and manage the instantiated group

withMVCGroup

public void withMVCGroup(@Nonnull
                         String mvcType,
                         @Nonnull
                         MVCGroupFunction handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
    }
 }
 

An instance of the "foo" group can be used as follows

 withMVC("foo", new MVCGroupCallable() {
     public void call(MVCGroup group) {
         group.getModel().setSomeProperty(someValue);
         group.getController().invokeAnAction();
     }
 });
 

Specified by:

withMVCGroup in interface MVCHandler

Parameters:

mvcType - the type of group to build.

handler - a code block used to configure and manage the instantiated group

withMVCGroup

public void withMVCGroup(@Nonnull
                         String mvcType,
                         @Nonnull
                         String mvcId,
                         @Nonnull
                         MVCGroupFunction handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

An instance of the "foo" group can be used as follows

 withMVCGroup("foo", "foo1", new MVCGroupCallable() {
     public void call(MVCGroup group) {
         group.getModel().setSomeProperty(someValue);
         group.getController().invokeAnAction();
     }
 });
 

MVC groups must have an unique name.

Specified by:

withMVCGroup in interface MVCHandler

Parameters:

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

handler - a code block used to configure and manage the instantiated group

withMVCGroup

public void withMVCGroup(@Nonnull
                         String mvcType,
                         @Nonnull
                         String mvcId,
                         @Nonnull
                         Map<String,Object> args,
                         @Nonnull
                         MVCGroupFunction handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

An instance of the "foo" group can be used as follows

 Map map = ... // initialized elsewhere
 withMVCGroup("foo", "foo1", map, new MVCGroupCallable() {
    public void call(MVCGroup group) {
        group.getModel().setSomeProperty(someValue);
        group.getController().invokeAnAction();
    }
 });
 

MVC groups must have an unique name.

Specified by:

withMVCGroup in interface MVCHandler

Parameters:

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

handler - a code block used to configure and manage the instantiated group

withMVCGroup

public void withMVCGroup(@Nonnull
                         Map<String,Object> args,
                         @Nonnull
                         String mvcType,
                         @Nonnull
                         String mvcId,
                         @Nonnull
                         MVCGroupFunction handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
     }
 }
 

An instance of the "foo" group can be used as follows

 Map map = ... // initialized elsewhere
 withMVCGroup("foo", "foo1", map, new MVCGroupCallable() {
    public void call(MVCGroup group) {
        group.getModel().setSomeProperty(someValue);
        group.getController().invokeAnAction();
    }
 });
 

MVC groups must have an unique name.

Specified by:

withMVCGroup in interface MVCHandler

Parameters:

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

mvcType - the type of group to build.

mvcId - the name to assign to the built group.

handler - a code block used to configure and manage the instantiated group

withMVCGroup

public void withMVCGroup(@Nonnull
                         String mvcType,
                         @Nonnull
                         Map<String,Object> args,
                         @Nonnull
                         MVCGroupFunction handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
    }
 }
 

An instance of the "foo" group can be used as follows

 Map map = ... // initialized elsewhere
 withMVCGroup("foo", map, new MVCGroupCallable() {
    public void call(MVCGroup group) {
        group.getModel().setSomeProperty(someValue);
        group.getController().invokeAnAction();
    }
 });
 

Specified by:

withMVCGroup in interface MVCHandler

Parameters:

mvcType - the type of group to build.

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

handler - a code block used to configure and manage the instantiated group

withMVCGroup

public void withMVCGroup(@Nonnull
                         Map<String,Object> args,
                         @Nonnull
                         String mvcType,
                         @Nonnull
                         MVCGroupFunction handler)

Description copied from interface: MVCHandler

Instantiates an MVC group of the specified type then destroys it after it has been handled.

This method is of particular interest when working with short lived MVC groups such as those used to build dialogs.

MVC groups must be previously configured with the application's metadata before they can be used. This registration process usually takes place automatically at boot time. The type of the group can be normally found in the application's configuration file.

The args Map can contain any value that will be used in one of the following scenarios

• The key matches a member definition; the value will be used as the instance of such member.
• The key does not match a member definition, the value is assumed to be a property that can be set on any MVC member of the group.
For example, with the following entry available in Application.groovy

 mvcGroups {
     'foo' {
         model      = 'com.acme.FooModel'
         view       = 'com.acme.FooView'
         controller = 'com.acme.FooController'
    }
 }
 

An instance of the "foo" group can be used as follows

 Map map = ... // initialized elsewhere
 withMVCGroup("foo", map, new MVCGroupCallable() {
    public void call(MVCGroup group) {
        group.getModel().setSomeProperty(someValue);
        group.getController().invokeAnAction();
    }
 });
 

Specified by:

withMVCGroup in interface MVCHandler

Parameters:

args - any useful values that can be set as properties on each MVC member or that identify a member that can be shared with other groups.

mvcType - the type of group to build.

handler - a code block used to configure and manage the instantiated group

getController

@Nonnull
public <C extends GriffonController> C getController(@Nonnull
                                                              String name,
                                                              @Nonnull
                                                              Class<C> type)
                                                       throws ArtifactNotFoundException

Description copied from interface: MVCGroupManager

Finds a named controller.

Specified by:

getController in interface MVCGroupManager

Parameters:

name - the name of the group that holds the controller

type - the type of the controller

Returns:

the controller instance if found

Throws:

ArtifactNotFoundException - if the named controller could not be found

getModel

@Nonnull
public <M extends GriffonModel> M getModel(@Nonnull
                                                    String name,
                                                    @Nonnull
                                                    Class<M> type)
                                             throws ArtifactNotFoundException

Description copied from interface: MVCGroupManager

Finds a named model.

Specified by:

getModel in interface MVCGroupManager

Parameters:

name - the name of the group that holds the model

type - the type of the model

Returns:

the model instance if found

Throws:

ArtifactNotFoundException - if the named model could not be found

getView

@Nonnull
public <V extends GriffonView> V getView(@Nonnull
                                                  String name,
                                                  @Nonnull
                                                  Class<V> type)
                                           throws ArtifactNotFoundException

Description copied from interface: MVCGroupManager

Finds a named view.

Specified by:

getView in interface MVCGroupManager

Parameters:

name - the name of the group that holds the view

type - the type of the view

Returns:

the view instance if found

Throws:

ArtifactNotFoundException - if the named view could not be found

findController

@Nullable
public <C extends GriffonController> C findController(@Nonnull
                                                                String name,
                                                                @Nonnull
                                                                Class<C> type)

Description copied from interface: MVCGroupManager

Finds a named controller.

Specified by:

findController in interface MVCGroupManager

Parameters:

name - the name of the group that holds the controller

type - the type of the controller

Returns:

the controller instance if found

findModel

@Nullable
public <M extends GriffonModel> M findModel(@Nonnull
                                                      String name,
                                                      @Nonnull
                                                      Class<M> type)

Description copied from interface: MVCGroupManager

Finds a named model.

Specified by:

findModel in interface MVCGroupManager

Parameters:

name - the name of the group that holds the model

type - the type of the model

Returns:

the model instance if found

findView

@Nullable
public <V extends GriffonView> V findView(@Nonnull
                                                    String name,
                                                    @Nonnull
                                                    Class<V> type)

Description copied from interface: MVCGroupManager

Finds a named view.

Specified by:

findView in interface MVCGroupManager

Parameters:

name - the name of the group that holds the view

type - the type of the view

Returns:

the view instance if found