griffon.core.mvc

Interface MVCHandler

All Known Subinterfaces:

GriffonArtifact, GriffonController, GriffonModel, GriffonMvcArtifact, GriffonService, GriffonView, JavaFXGriffonView, MVCGroup, MVCGroupManager, TypedMVCGroup<M,V,C>

All Known Implementing Classes:

AbstractGriffonArtifact, AbstractGriffonController, AbstractGriffonModel, AbstractGriffonMvcArtifact, AbstractGriffonService, AbstractGriffonView, AbstractJavaFXGriffonView, AbstractLanternaGriffonView, AbstractMVCGroup, AbstractMVCGroupManager, AbstractMVCHandler, AbstractPivotGriffonView, AbstractSwingGriffonView, AbstractTypedMVCGroup, DefaultMVCGroup, DefaultMVCGroupManager, DelegatingMVCGroup, GroovyAwareMVCGroup, GroovyAwareMVCGroupManager

public interface MVCHandler

Base contract for classes that can manipulate MVC groups. There are 4 types of methods used for instantiating a group:

createMVCGroup() - creates a new group instance returning all members.
createMVC() - creates a new group instance returning only Model, View and Controller members.
withMVCGroup() - creates a new group instance and destroys it immediately after it has been processed by the callback.
withMVC() - creates a new group instance and destroys it immediately after it has been processed by the callback.

It's worth mentioning that the value of the mvcId parameter must be unique otherwise a collision will occur. When that happens the application will report and exception and terminate. This behavior can be configured to be more lenient, by defining a configuration flag griffon.mvcid.collision in Config.
Accepted values are

warning - reports the error but allows the application to continue. Destroys the existing group before continuing.
exception - reports the error and terminates the application. this is the default behavior.

Since:

2.0.0

Author:

Andres Almiray

Method Summary

Modifier and Type	Method and Description
<MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact>	createMVC(Class<? extends MVC> mvcType) Instantiates an MVC group of the specified type returning only the MVC parts.
<MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact>	createMVC(Class<? extends MVC> mvcType, Map<String,Object> args) Instantiates an MVC group of the specified type with additional variables.
<MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact>	createMVC(Class<? extends MVC> mvcType, String mvcId) Instantiates an MVC group of the specified type with a particular name.
<MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact>	createMVC(Class<? extends MVC> mvcType, String mvcId, Map<String,Object> args) Instantiates an MVC group of the specified type with a particular name.
<MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact>	createMVC(Map<String,Object> args, Class<? extends MVC> mvcType) Instantiates an MVC group of the specified type with additional variables.
<MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact>	createMVC(Map<String,Object> args, Class<? extends MVC> mvcType, String mvcId) Instantiates an MVC group of the specified type with a particular name.
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.
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.
<MVC extends TypedMVCGroup> MVC	createMVCGroup(Class<? extends MVC> mvcType) Instantiates an MVC group of the specified type.
<MVC extends TypedMVCGroup> MVC	createMVCGroup(Class<? extends MVC> mvcType, Map<String,Object> args) Instantiates an MVC group of the specified type with additional variables.
<MVC extends TypedMVCGroup> MVC	createMVCGroup(Class<? extends MVC> mvcType, String mvcId) Instantiates an MVC group of the specified type with a particular name.
<MVC extends TypedMVCGroup> MVC	createMVCGroup(Class<? extends MVC> mvcType, String mvcId, Map<String,Object> args) Instantiates an MVC group of the specified type with a particular name.
<MVC extends TypedMVCGroup> MVC	createMVCGroup(Map<String,Object> args, Class<? extends MVC> mvcType) Instantiates an MVC group of the specified type with additional variables.
<MVC extends TypedMVCGroup> MVC	createMVCGroup(Map<String,Object> args, Class<? extends MVC> mvcType, String mvcId) 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.
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.
void	destroyMVCGroup(String mvcId) Destroys an MVC group identified by a particular name.
<MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVC(Class<? extends MVC> 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.
<MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVC(Class<? extends MVC> mvcType, MVCFunction<M,V,C> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
<MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVC(Class<? extends MVC> 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.
<MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVC(Class<? extends MVC> mvcType, String mvcId, MVCFunction<M,V,C> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
<MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVC(Map<String,Object> args, Class<? extends MVC> mvcType, MVCFunction<M,V,C> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
<MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> void	withMVC(Map<String,Object> args, Class<? extends MVC> 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(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.
<MVC extends TypedMVCGroup> void	withMVCGroup(Class<? extends MVC> mvcType, Map<String,Object> args, TypedMVCGroupFunction<MVC> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
<MVC extends TypedMVCGroup> void	withMVCGroup(Class<? extends MVC> mvcType, String mvcId, Map<String,Object> args, TypedMVCGroupFunction<MVC> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
<MVC extends TypedMVCGroup> void	withMVCGroup(Class<? extends MVC> mvcType, String mvcId, TypedMVCGroupFunction<MVC> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
<MVC extends TypedMVCGroup> void	withMVCGroup(Class<? extends MVC> mvcType, TypedMVCGroupFunction<MVC> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
<MVC extends TypedMVCGroup> void	withMVCGroup(Map<String,Object> args, Class<? extends MVC> mvcType, String mvcId, TypedMVCGroupFunction<MVC> handler) Instantiates an MVC group of the specified type then destroys it after it has been handled.
<MVC extends TypedMVCGroup> void	withMVCGroup(Map<String,Object> args, Class<? extends MVC> mvcType, TypedMVCGroupFunction<MVC> 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.
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.

Method Detail

createMVCGroup

@Nonnull
MVCGroup createMVCGroup(@Nonnull
                                 String mvcType)

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 Config.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')
 assert (fooGroup.controller instanceof FooController)
 

Parameters:

mvcType - the type of group to build.

Returns:

an MVCGroup instance of the desired type

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

createMVCGroup

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

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 Config.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.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

createMVCGroup

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

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 Config.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
 

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

createMVCGroup

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

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 Config.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
 

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

createMVCGroup

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

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 Config.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('foo', 'foo2', model: fooGroup1.model)
 assert fooGroup1.model == fooGroup2.model
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

createMVCGroup

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

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 Config.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('foo', 'foo2', model: fooGroup1.model)
 assert fooGroup1.model == fooGroup2.model
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

createMVCGroup

@Nonnull
<MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull
                                                        Class<? extends MVC> mvcType)

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 Config.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

 FooMVCGroup fooGroup = createMVCGroup(FooMVCGroup)
 assert (fooGroup.controller instanceof FooController)
 

Parameters:

mvcType - the type of group to build.

Returns:

an MVCGroup instance of the desired type

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

Since:

2.11.0

createMVCGroup

@Nonnull
<MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull
                                                        Class<? extends MVC> mvcType,
                                                        @Nonnull
                                                        String mvcId)

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 Config.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

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

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

Since:

2.11.0

createMVCGroup

@Nonnull
<MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull
                                                        Map<String,Object> args,
                                                        @Nonnull
                                                        Class<? extends MVC> mvcType)

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 Config.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:

 FooMVCGroup fooGroup = createMVCGroup(FooMVCGroup)
 BarMVCGroup barGroup = createMVCGroup(BarMVCGroup, model: fooGroup.model)
 assert fooGroup.model == barGroup.model
 

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

Since:

2.11.0

createMVCGroup

@Nonnull
<MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull
                                                        Class<? extends MVC> mvcType,
                                                        @Nonnull
                                                        Map<String,Object> args)

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 Config.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:

 FooMVCGroup fooGroup = createMVCGroup(FooMVCGroup)
 BarMVCGroup barGroup = createMVCGroup(BarMVCGroup, model: fooGroup.model)
 assert fooGroup.model == barGroup.model
 

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

Since:

2.11.0

createMVCGroup

@Nonnull
<MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull
                                                        Map<String,Object> args,
                                                        @Nonnull
                                                        Class<? extends MVC> mvcType,
                                                        @Nonnull
                                                        String mvcId)

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 Config.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:

 FooMVCGroup fooGroup1 = createMVCGroup(FooMVCGroup, 'foo1')
 FooMVCGroup fooGroup2 = createMVCGroup(FooMVCGroup, 'foo2', model: fooGroup1.model)
 assert fooGroup1.model == fooGroup2.model
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

Since:

2.11.0

createMVCGroup

@Nonnull
<MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull
                                                        Class<? extends MVC> mvcType,
                                                        @Nonnull
                                                        String mvcId,
                                                        @Nonnull
                                                        Map<String,Object> args)

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 Config.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:

 FooMVCGroup fooGroup1 = createMVCGroup(FooMVCGroup, 'foo1')
 FooMVCGroup fooGroup2 = createMVCGroup(FooMVCGroup, 'foo2', model: fooGroup1.model)
 assert fooGroup1.model == fooGroup2.model
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

Since:

2.11.0

createMVC

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

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 Config.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)
 

Parameters:

mvcType - the type of group to build.

Returns:

a List with the canonical MVC members of the group

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

createMVC

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

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 Config.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
 

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

createMVC

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

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 Config.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
 

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

createMVC

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

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 Config.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.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

createMVC

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

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 Config.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.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

createMVC

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

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 Config.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.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

createMVC

@Nonnull
<MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                                                  Class<? extends MVC> mvcType)

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 Config.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(FooMVCGroup)
 assert (c instanceof FooController)
 

Parameters:

mvcType - the type of group to build.

Returns:

a List with the canonical MVC members of the group

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

Since:

2.11.0

createMVC

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

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 Config.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(FooMVCGroup)
 def (m2, v2, c2) = createMVC(BarMVCGroup, model: m1)
 assert fm1 == m2
 

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

Since:

2.11.0

createMVC

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

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 Config.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(FooMVCGroup)
 def (m2, v2, c2) = createMVC(BarMVCGroup, model: m1)
 assert fm1 == m2
 

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

Since:

2.11.0

createMVC

@Nonnull
<MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull
                                                                                  Class<? extends MVC> mvcType,
                                                                                  @Nonnull
                                                                                  String mvcId)

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 Config.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(FooMVCGroup, 'foo' + System.currentTimeMillis())
 assert (c instanceof FooController)
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

Since:

2.11.0

createMVC

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

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 Config.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(FooMVCGroup, 'foo1')
 def (m2, v2, c2) = createMVC(FooMVCGroup, 'foo2', model: m1)
 assert fm1 == m2
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

Since:

2.11.0

createMVC

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

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 Config.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(FooMVCGroup, 'foo1')
 def (m2, v2, c2) = createMVC(FooMVCGroup, 'foo2', model: m1)
 assert fm1 == m2
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration or if a group with the same mvcId exists already.

Since:

2.11.0

destroyMVCGroup

void destroyMVCGroup(@Nonnull
                     String mvcId)

Destroys an MVC group identified by a particular name.

ATTENTION: make sure to call the super implementation if you override this method otherwise group references will not be kept up to date.

Parameters:

mvcId - the name of the group to destroy and dispose.

withMVC

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

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 Config.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 MVCFunction<FooModel, FooView, FooController>() {
     public void call(FooModel m, FooView v, FooController c) {
         m.setSomeProperty(someValue);
         c.invokeAnAction();
     }
 });
 

Parameters:

mvcType - the type of group to build.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

withMVC

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

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 Config.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 MVCFunction<FooModel, FooView, FooController>() {
     public void call(FooModel m, FooView v, FooController c) {
         m.setSomeProperty(someValue);
         c.invokeAnAction();
     }
 });
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

withMVC

<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)

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 Config.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 MVCFunction<FooModel, FooView, FooController>() {
    public void call(FooModel m, FooView v, FooController c) {
        m.setSomeProperty(someValue);
        c.invokeAnAction();
    }
 });
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

withMVC

<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)

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 Config.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 MVCFunction<FooModel, FooView, FooController>() {
    public void call(FooModel m, FooView v, FooController c) {
        m.setSomeProperty(someValue);
        c.invokeAnAction();
    }
 });
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

withMVC

<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)

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 Config.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 MVCFunction<FooModel, FooView, FooController>() {
    public void call(FooModel m, FooView v, FooController c) {
        m.setSomeProperty(someValue);
        c.invokeAnAction();
    }
 });
 

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

withMVC

<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)

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 Config.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 MVCFunction<FooModel, FooView, FooController>() {
    public void call(FooModel m, FooView v, FooController c) {
        m.setSomeProperty(someValue);
        c.invokeAnAction();
    }
 });
 

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

withMVC

<MVC extends TypedMVCGroup,M extends GriffonModel,V extends GriffonView,C extends GriffonController> void withMVC(@Nonnull
                                                                                                                  Class<? extends MVC> mvcType,
                                                                                                                  @Nonnull
                                                                                                                  MVCFunction<M,V,C> handler)

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 Config.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(FooMVCGroup.class, new MVCFunction<FooModel, FooView, FooController>() {
     public void call(FooModel m, FooView v, FooController c) {
         m.setSomeProperty(someValue);
         c.invokeAnAction();
     }
 });
 

Parameters:

mvcType - the type of group to build.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

Since:

2.11.0

withMVC

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

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 Config.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(FooMVCGroup.class, "foo1", new MVCFunction<FooModel, FooView, FooController>() {
     public void call(FooModel m, FooView v, FooController c) {
         m.setSomeProperty(someValue);
         c.invokeAnAction();
     }
 });
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

Since:

2.11.0

withMVC

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

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 Config.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(FooMVCGroup.class, "foo1", map, new MVCFunction<FooModel, FooView, FooController>() {
    public void call(FooModel m, FooView v, FooController c) {
        m.setSomeProperty(someValue);
        c.invokeAnAction();
    }
 });
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

Since:

2.11.0

withMVC

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

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 Config.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(FooMVCGroup.class, "foo1", map, new MVCFunction<FooModel, FooView, FooController>() {
    public void call(FooModel m, FooView v, FooController c) {
        m.setSomeProperty(someValue);
        c.invokeAnAction();
    }
 });
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

Since:

2.11.0

withMVC

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

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 Config.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(FooMVCGroup.class, map, new MVCFunction<FooModel, FooView, FooController>() {
    public void call(FooModel m, FooView v, FooController c) {
        m.setSomeProperty(someValue);
        c.invokeAnAction();
    }
 });
 

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

Since:

2.11.0

withMVC

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

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 Config.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(FooMVCGroup.class, map, new MVCFunction<FooModel, FooView, FooController>() {
    public void call(FooModel m, FooView v, FooController c) {
        m.setSomeProperty(someValue);
        c.invokeAnAction();
    }
 });
 

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

Since:

2.11.0

withMVCGroup

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

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 Config.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", new MVCGroupFunction() {
     public void call(MVCGroup group) {
         group.getModel().setSomeProperty(someValue);
         group.getController().invokeAnAction();
     }
 });
 

Parameters:

mvcType - the type of group to build.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

Since:

2.1.0

withMVCGroup

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

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 Config.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 MVCGroupFunction() {
     public void call(MVCGroup group) {
         group.getModel().setSomeProperty(someValue);
         group.getController().invokeAnAction();
     }
 });
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

Since:

2.1.0

withMVCGroup

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

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 Config.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 MVCGroupFunction() {
    public void call(MVCGroup group) {
        group.getModel().setSomeProperty(someValue);
        group.getController().invokeAnAction();
    }
 });
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

Since:

2.1.0

withMVCGroup

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

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 Config.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 MVCGroupFunction() {
    public void call(MVCGroup group) {
        group.getModel().setSomeProperty(someValue);
        group.getController().invokeAnAction();
    }
 });
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

Since:

2.1.0

withMVCGroup

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

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 Config.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 MVCGroupFunction() {
    public void call(MVCGroup group) {
        group.getModel().setSomeProperty(someValue);
        group.getController().invokeAnAction();
    }
 });
 

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

Since:

2.1.0

withMVCGroup

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

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 Config.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 MVCGroupFunction() {
    public void call(MVCGroup group) {
        group.getModel().setSomeProperty(someValue);
        group.getController().invokeAnAction();
    }
 });
 

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

Since:

2.1.0

withMVCGroup

<MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull
                                              Class<? extends MVC> mvcType,
                                              @Nonnull
                                              TypedMVCGroupFunction<MVC> handler)

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 Config.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(FooMVCGroup.class, new TypedMVCGroupFunction<>() {
     public void call(MVC group) {
         group.getModel().setSomeProperty(someValue);
         group.getController().invokeAnAction();
     }
 });
 

Parameters:

mvcType - the type of group to build.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

Since:

2.11.0

withMVCGroup

<MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull
                                              Class<? extends MVC> mvcType,
                                              @Nonnull
                                              String mvcId,
                                              @Nonnull
                                              TypedMVCGroupFunction<MVC> handler)

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 Config.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(FooMVCGroup.class, "foo1", new TypedMVCGroupFunction<>() {
     public void call(MVC group) {
         group.getModel().setSomeProperty(someValue);
         group.getController().invokeAnAction();
     }
 });
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

Since:

2.11.0

withMVCGroup

<MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull
                                              Class<? extends MVC> mvcType,
                                              @Nonnull
                                              String mvcId,
                                              @Nonnull
                                              Map<String,Object> args,
                                              @Nonnull
                                              TypedMVCGroupFunction<MVC> handler)

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 Config.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(FooMVCGroup.class, "foo1", map, new TypedMVCGroupFunction<>() {
    public void call(MVC group) {
        group.getModel().setSomeProperty(someValue);
        group.getController().invokeAnAction();
    }
 });
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

Since:

2.11.0

withMVCGroup

<MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull
                                              Map<String,Object> args,
                                              @Nonnull
                                              Class<? extends MVC> mvcType,
                                              @Nonnull
                                              String mvcId,
                                              @Nonnull
                                              TypedMVCGroupFunction<MVC> handler)

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 Config.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(FooMVCGroup.class, "foo1", map, new TypedMVCGroupFunction<>() {
    public void call(MVC group) {
        group.getModel().setSomeProperty(someValue);
        group.getController().invokeAnAction();
    }
 });
 

MVC groups must have an unique name.

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

Since:

2.11.0

withMVCGroup

<MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull
                                              Class<? extends MVC> mvcType,
                                              @Nonnull
                                              Map<String,Object> args,
                                              @Nonnull
                                              TypedMVCGroupFunction<MVC> handler)

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 Config.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(FooMVCGroup.class, map, new TypedMVCGroupFunction<>() {
    public void call(MVC group) {
        group.getModel().setSomeProperty(someValue);
        group.getController().invokeAnAction();
    }
 });
 

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

Since:

2.11.0

withMVCGroup

<MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull
                                              Map<String,Object> args,
                                              @Nonnull
                                              Class<? extends MVC> mvcType,
                                              @Nonnull
                                              TypedMVCGroupFunction<MVC> handler)

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 Config.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(FooMVCGroup.class, map, new TypedMVCGroupFunction<>() {
    public void call(MVC group) {
        group.getModel().setSomeProperty(someValue);
        group.getController().invokeAnAction();
    }
 });
 

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

Throws:

MVCGroupInstantiationException - - if the type specified is not found in the application's configuration

Since:

2.11.0